Struct TextureData 

pub struct TextureData { /* private fields */ }

The texture a mesh slot is sampled from: 8-bit RGBA, sRGB-encoded, row by row from the top left.

Implementations

impl TextureData

pub fn rgba8(size: UVec2, pixels: Vec<u8>) -> Self

A size-sized texture over pixels, 4 bytes per pixel.

The length must match size; checked only in debug builds.

Examples found in repository

examples/material-playground.rs (lines 317-320)

fn emissive_checker() -> TextureData {
    TextureData::rgba8(
        MAP_SIZE,
        checker_pixels(MAP_SIZE, EMISSIVE_CELL, [0, 0, 0], [255, 255, 255]),
    )
}

examples/flock-parallelism.rs (line 180)

fn greyed(skin: &TextureData) -> TextureData {
    let pixels = skin
        .pixels()
        .chunks_exact(4)
        .flat_map(|texel| {
            let [red, green, blue, alpha] = [texel[0], texel[1], texel[2], texel[3]];
            let grey =
                (0.2126 * f32::from(red) + 0.7152 * f32::from(green) + 0.0722 * f32::from(blue))
                    .round() as u8;
            [grey, grey, grey, alpha]
        })
        .collect();
    TextureData::rgba8(skin.size(), pixels)
}

pub fn pixelated(self) -> Self

Marks this texture sampled from the nearest texel, so that its pixels stay pixels however large it is drawn; the default blends between them.

Examples found in repository

examples/isometric-board.rs (line 198)

    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(SPRITE_TEXTURE).pixelated())
    }

examples/sprite-adventure.rs (line 572)

    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(GROUND_SHEET).pixelated())
    }
}

/// The shoreline sprite laid over the pond's styled water, cutout so the
/// water shows through its cleared middle.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Shore;

impl Mesh for Shore {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(POND_SHEET).pixelated())
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A crate prop, its texture drawn over a cube.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Crate;

impl Mesh for Crate {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(CRATE_TEXTURE).pixelated())
    }
}

/// The well's rim.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Well;

impl Mesh for Well {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(WELL_SHEET).pixelated())
    }
}

/// The well's mouth, laid flat over the rim's top face.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct WellMouth;

impl Mesh for WellMouth {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(WELL_SHEET).pixelated())
    }
}

/// A stone box: the mouth's pillars and lintel.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Stone;

impl Mesh for Stone {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(STONE_SHEET).pixelated())
    }
}

/// A bush sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Bush;

impl Mesh for Bush {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(BUSH_SPRITE).pixelated())
            .with_relief(assets.relief(BUSH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A rock sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Rock;

impl Mesh for Rock {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(ROCK_SPRITE).pixelated())
            .with_relief(assets.relief(ROCK_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's post sprite, cutout with its own relief.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Torch;

impl Mesh for Torch {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(TORCH_SPRITE).pixelated())
            .with_relief(assets.relief(TORCH_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// A torch's flame sprite, added over the dark rather than lit.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Flame;

impl Mesh for Flame {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(FLAME_SHEET).pixelated())
            .with_material(Material::color(FLAME_TINT).additive())
    }
}

/// The player's sprite, cutout with its own relief, its sheet shared
/// with `examples/isometric-board.rs`.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct Walker;

impl Mesh for Walker {
    fn build(&self, assets: &Assets) -> MeshData {
        Quad.build(assets)
            .with_texture(assets.texture(WALKER_SHEET).pixelated())
            .with_relief(assets.relief(WALKER_RELIEF))
            .with_material(Material::lit(Color::WHITE).cutout())
    }
}

/// The cave floor tile.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct CaveFloor;

impl Mesh for CaveFloor {
    fn build(&self, assets: &Assets) -> MeshData {
        Plane
            .build(assets)
            .with_texture(assets.texture(CAVE_SHEET).pixelated())
    }
}

/// The cave wall face.
#[derive(Catalog, Clone, PartialEq, Eq, Hash)]
struct CaveWall;

impl Mesh for CaveWall {
    fn build(&self, assets: &Assets) -> MeshData {
        Cube.build(assets)
            .with_texture(assets.texture(CAVE_SHEET).pixelated())
    }

pub fn size(&self) -> UVec2

Pixels across and down; (0, 0) when there are none.

Examples found in repository

examples/flock-parallelism.rs (line 180)

fn greyed(skin: &TextureData) -> TextureData {
    let pixels = skin
        .pixels()
        .chunks_exact(4)
        .flat_map(|texel| {
            let [red, green, blue, alpha] = [texel[0], texel[1], texel[2], texel[3]];
            let grey =
                (0.2126 * f32::from(red) + 0.7152 * f32::from(green) + 0.0722 * f32::from(blue))
                    .round() as u8;
            [grey, grey, grey, alpha]
        })
        .collect();
    TextureData::rgba8(skin.size(), pixels)
}

pub fn pixels(&self) -> &[u8]

The pixels, 4 bytes each, row by row from the top left.

Examples found in repository

examples/flock-parallelism.rs (line 170)

fn greyed(skin: &TextureData) -> TextureData {
    let pixels = skin
        .pixels()
        .chunks_exact(4)
        .flat_map(|texel| {
            let [red, green, blue, alpha] = [texel[0], texel[1], texel[2], texel[3]];
            let grey =
                (0.2126 * f32::from(red) + 0.7152 * f32::from(green) + 0.0722 * f32::from(blue))
                    .round() as u8;
            [grey, grey, grey, alpha]
        })
        .collect();
    TextureData::rgba8(skin.size(), pixels)
}

Trait Implementations

impl Clone for TextureData

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TextureData

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

Formats the value using the given formatter.

impl Default for TextureData

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for TextureData

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for TextureData