veloren_common::terrain::structure::structure_block

Trait PackedElim

pub trait PackedElim {
Show 40 associated items
    type None;
    type Grass;
    type TemperateLeaves;
    type PineLeaves;
    type Acacia;
    type Mangrove;
    type PalmLeavesInner;
    type PalmLeavesOuter;
    type Water;
    type GreenSludge;
    type Fruit;
    type Coconut;
    type Chest;
    type Hollow;
    type Liana;
    type Normal;
    type Log;
    type Filled;
    type Sprite;
    type Chestnut;
    type Baobab;
    type BirchWood;
    type FrostpineLeaves;
    type RotatedSprite;
    type EntitySpawner;
    type Keyhole;
    type BoneKeyhole;
    type GlassKeyhole;
    type Sign;
    type KeyholeBars;
    type HaniwaKeyhole;
    type TerracottaKeyhole;
    type SahaginKeyhole;
    type VampireKeyhole;
    type MyrmidonKeyhole;
    type MinotaurKeyhole;
    type MapleLeaves;
    type CherryLeaves;
    type AutumnLeaves;
    type RedwoodWood;
}

Required Associated Types§

type None

type Grass

type TemperateLeaves

type PineLeaves

type Acacia

type Mangrove

type PalmLeavesInner

type PalmLeavesOuter

type Water

type GreenSludge

type Fruit

type Coconut

type Chest

type Hollow

type Liana

type Normal

type Log

type Filled

type Sprite

type Chestnut

type Baobab

type BirchWood

type FrostpineLeaves

type RotatedSprite

type EntitySpawner

type Keyhole

type BoneKeyhole

type GlassKeyhole

type Sign

type KeyholeBars

type HaniwaKeyhole

type TerracottaKeyhole

type SahaginKeyhole

type VampireKeyhole

type MyrmidonKeyhole

type MinotaurKeyhole

type MapleLeaves

type CherryLeaves

type AutumnLeaves

type RedwoodWood

Implementors§

impl<T> PackedElim for Pure<T>

type None = Pure<T>

type Grass = Pure<T>

type TemperateLeaves = Pure<T>

type PineLeaves = Pure<T>

type Acacia = Pure<T>

type Mangrove = Pure<T>

type PalmLeavesInner = Pure<T>

type PalmLeavesOuter = Pure<T>

type Water = Pure<T>

type GreenSludge = Pure<T>

type Fruit = Pure<T>

type Coconut = Pure<T>

type Chest = Pure<T>

type Hollow = Pure<T>

type Liana = Pure<T>

type Normal = Pure<T>

type Log = Pure<T>

type Filled = Pure<T>

type Sprite = Pure<T>

type Chestnut = Pure<T>

type Baobab = Pure<T>

type BirchWood = Pure<T>

type FrostpineLeaves = Pure<T>

type RotatedSprite = Pure<T>

type EntitySpawner = Pure<T>

type Keyhole = Pure<T>

type BoneKeyhole = Pure<T>

type GlassKeyhole = Pure<T>

type Sign = Pure<T>

type KeyholeBars = Pure<T>

type HaniwaKeyhole = Pure<T>

type TerracottaKeyhole = Pure<T>

type SahaginKeyhole = Pure<T>

type VampireKeyhole = Pure<T>

type MyrmidonKeyhole = Pure<T>

type MinotaurKeyhole = Pure<T>

type MapleLeaves = Pure<T>

type CherryLeaves = Pure<T>

type AutumnLeaves = Pure<T>

type RedwoodWood = Pure<T>

impl<Target> PackedElim for WeakHead<StructureBlock, Target>
where WeakHead<Pure<Target>, Target>: SynthTyped<(), Target> + SynthTyped<((BlockKind, Rgb<u8>), ()), Target> + SynthTyped<((SpriteKind, u8), ()), Target> + SynthTyped<((String, f32), ()), Target> + SynthTyped<((Content, u8), ()), Target>, WeakHead<Rgb<u8>, Target>: SynthTyped<((Rgb<u8>,), ()), Target>, WeakHead<SpriteKind, Target>: SynthTyped<((SpriteKind,), ()), Target>, WeakHead<String, Target>: SynthTyped<((String,), ()), Target>,

type None = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Grass = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type TemperateLeaves = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type PineLeaves = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Acacia = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Mangrove = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type PalmLeavesInner = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type PalmLeavesOuter = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Water = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type GreenSludge = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Fruit = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Coconut = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Chest = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Hollow = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Liana = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Normal = <WeakHead<Rgb<u8>, Target> as SynthTyped<((Rgb<u8>,), ()), Target>>::Expr

type Log = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Filled = <WeakHead<Pure<Target>, Target> as SynthTyped<((BlockKind, Rgb<u8>), ()), Target>>::Expr

type Sprite = <WeakHead<SpriteKind, Target> as SynthTyped<((SpriteKind,), ()), Target>>::Expr

type Chestnut = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type Baobab = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type BirchWood = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type FrostpineLeaves = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type RotatedSprite = <WeakHead<Pure<Target>, Target> as SynthTyped<((SpriteKind, u8), ()), Target>>::Expr

type EntitySpawner = <WeakHead<Pure<Target>, Target> as SynthTyped<((String, f32), ()), Target>>::Expr

type Keyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type BoneKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type GlassKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type Sign = <WeakHead<Pure<Target>, Target> as SynthTyped<((Content, u8), ()), Target>>::Expr

type KeyholeBars = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type HaniwaKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type TerracottaKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type SahaginKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type VampireKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type MyrmidonKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type MinotaurKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type MapleLeaves = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type CherryLeaves = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type AutumnLeaves = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type RedwoodWood = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr