Struct Transform2D 

#[repr(C)]
pub struct Transform2D {
    pub position: Vec2,
    pub rotation: f32,
    pub scale: Vec2,
}

Where an entity is: position, rotation and scale.

Positions are in window pixels, (0, 0) top-left, y down (same as Ctx::draw).

let t = Transform2D::at(vec2(100.0, 50.0)).rotated(0.5);
assert_eq!(t.position, vec2(100.0, 50.0));

Fields

position: Vec2

Where the entity is, in world pixels.

rotation: f32

Radians, clockwise on screen.

scale: Vec2

Size multiplier; negative flips. Default (1, 1).

Implementations

impl Transform2D

pub fn at(position: Vec2) -> Self

A transform at position with no rotation and scale 1.

Examples found in repository

examples/battle.rs (line 430)

fn spawn_unit(cmds: &mut Commands, sprite: Option<Texture>, team: Team, at: Vec2) {
    let unit = Unit {
        team,
        hp: HP,
        vel: Vec2::ZERO,
        cooldown: 0.0,
        engaged: false,
        push: Vec2::ZERO,
        hit: None,
    };
    match sprite {
        Some(tex) => cmds.spawn((Transform2D::at(at), Sprite::new(tex).with_color(team.color()), unit)),
        None => cmds.spawn((Transform2D::at(at), unit)),
    }
}

fn setup(ctx: &mut Ctx, units: usize, seed: u64, sprite: Option<Texture>) {
    let scale = (units as f32 / UNITS_PER_MAP).max(1.0).sqrt();
    let size = (MAP.as_vec2() * scale).as_uvec2();
    let (nav, bases) = make_map(size, seed);
    ctx.world.reflect::<Unit>();
    ctx.world.reflect::<Base>();
    let max_hp = 400.0 * (units as f32 / 1000.0).sqrt();
    let base_entities = [Team::Red, Team::Blue].map(|team| {
        ctx.world.spawn((
            Transform2D::at(bases[team.index()]),
            Base {
                team,
                hp: max_hp,
                max_hp,
                budget: 0.0,
            },
        ))
    });
    let mut battle = Battle {
        nav,
        fields: [FlowField::new(), FlowField::new()],
        rally: bases,
        bases,
        base_entities,
        cap: units / 2,
        field_ms: 0.0,
    };
    battle.set_rally(Team::Red, bases[1]);
    battle.set_rally(Team::Blue, bases[0]);
    ctx.world.insert_resource(battle);
    ctx.world.reflect_resource::<Score>();
    ctx.events.reflect::<Fallen>();
    ctx.world.insert_resource(Score::default());
    ctx.world.insert_resource(Look(sprite));
    start_round(ctx);
}

examples/ecs.rs (line 41)

fn spawn_crab(ctx: &mut Ctx, at: Vec2) {
    let s = ctx.world.resource_mut::<Settings>();
    let angle = s.random() * std::f32::consts::TAU;
    let speed = 40.0 + s.random() * 120.0;
    let tint = Color::rgb(0.5 + s.random() * 0.5, 0.5 + s.random() * 0.5, 0.5 + s.random() * 0.5);
    let crab = s.crab;
    ctx.world.spawn((
        Transform2D::at(at),
        Sprite::new(crab).with_color(tint),
        Vel(Vec2::from_angle(angle) * speed),
        Life(LIFETIME),
    ));
}

examples/ants.rs (line 329)

fn spawn_ant(cmds: &mut Commands, sprite: Option<Texture>, home: Entity, at: Vec2, heading: f32) {
    let ant = Ant {
        home,
        home_at: at,
        heading,
        carrying: false,
        since: 0.0,
        energy: LIFESPAN,
        event: Event::None,
    };
    let t = Transform2D::at(at).rotated(heading);
    match sprite {
        Some(tex) => cmds.spawn((t, ant, Sprite::new(tex).with_color(Color::hex(0xD4553A)))),
        None => cmds.spawn((t, ant)),
    }
}

fn spawn_food(cmds: &mut Commands, rng: &mut Rng, bounds: Vec2, nests: &[Vec2]) {
    // Not too close to any nest, so trails have to form.
    let p = loop {
        let p = vec2(rng.range(20.0, bounds.x - 20.0), rng.range(20.0, bounds.y - 20.0));
        if nests.iter().all(|n| p.distance(*n) > 180.0) {
            break p;
        }
    };
    cmds.spawn((Transform2D::at(p), Food { amount: 400 }));
}

/// The simulation, shared by the windowed and headless runs.
fn colonies(game: Game, bounds: Vec2) -> Game {
    game.sim_system(steer(bounds))
        .sim_system(lay_trails)
        .sim_system(forage)
        .sim_system_every(4, evaporate)
        .sim_system_every(30, grow(bounds))
}

/// Nests on a grid, one per `NEST_AREA`; ants and food around them.
fn setup(ctx: &mut Ctx, bounds: Vec2, ants: usize, sprite: Option<Texture>) {
    ctx.world.reflect::<Ant>();
    ctx.world.reflect::<Nest>();
    ctx.world.reflect::<Food>();
    ctx.world.insert_resource(Field::new(bounds));
    ctx.world.insert_resource(AntLook(sprite));
    let mut rng = ctx.random().stream(1);
    let (cols, rows) = ((bounds.x / NEST_AREA.x) as usize, (bounds.y / NEST_AREA.y) as usize);
    let (cols, rows) = (cols.max(1), rows.max(1));
    let per_nest = (ants / (cols * rows)).max(1);
    let mut homes = Vec::new();
    for row in 0..rows {
        for col in 0..cols {
            let at = (vec2(col as f32, row as f32) + 0.5) * bounds / vec2(cols as f32, rows as f32);
            let nest = Nest {
                stored: 0,
                delivered: 0,
                max_ants: per_nest as u32 * 2,
                ants: per_nest as u32,
            };
            let home = ctx.world.spawn((Transform2D::at(at), nest));
            homes.push(at);
            for _ in 0..per_nest {
                spawn_ant(&mut ctx.commands, sprite, home, at, rng.angle());
            }
        }
    }
    for _ in 0..food_piles(bounds) {
        spawn_food(&mut ctx.commands, &mut rng, bounds, &homes);
    }
}

examples/hotpatch.rs (line 57)

fn main() {
    Game::new("Crabby Engine: hot patching", 1280, 720)
        .sim_system(spin)
        .sim_system(wobble)
        .sim_system(report)
        .run(|ctx| {
            let crab = ctx.load_texture("crab.png");
            for i in 0..12 {
                let at = vec2(160.0 + (i % 6) as f32 * 190.0, 220.0 + (i / 6) as f32 * 280.0);
                ctx.world
                    .spawn((Transform2D::at(at), Sprite::new(crab), Crab(i as f32 * 0.7)));
            }
        });
}

examples/lockstep.rs (line 154)

fn play(net: Net) {
    Game::new("Lockstep", 800, 600)
        .lockstep(net)
        .system(read_keys) // frame system: input out
        .sim_system(move_crabs) // sim system: everyone's input in
        .system(draw)
        .run(|ctx| {
            ctx.world.reflect::<Crab>(); // compared between peers
            for player in 0..2 {
                ctx.world.spawn((
                    Transform2D::at(vec2(250.0 + 300.0 * player as f32, 300.0)),
                    Crab {
                        player,
                        push: Vec2::ZERO,
                    },
                ));
            }
        });
    // ANCHOR_END: session
}

examples/bunnymark_ecs.rs (line 59)

fn spawn(ctx: &mut Ctx, n: usize, at: Vec2) {
    let b = ctx.world.resource_mut::<Bench>();
    let crab = b.crab;
    let mut batch = Vec::with_capacity(n);
    for _ in 0..n {
        let r = &mut b.rng;
        let vel = vec2(r.next_f32() * 400.0 - 200.0, r.next_f32() * 400.0 - 300.0);
        let color = Color::rgb(
            0.6 + r.next_f32() * 0.4,
            0.6 + r.next_f32() * 0.4,
            0.6 + r.next_f32() * 0.4,
        );
        batch.push((
            Transform2D {
                scale: Vec2::splat(b.scale),
                ..Transform2D::at(at)
            },
            Sprite::new(crab).with_color(color),
            Vel(vel),
        ));
    }
    ctx.world.spawn_batch(batch);
}

Additional examples can be found in:

• examples/boids.rs
• examples/editor.rs
• examples/tiles.rs
• examples/gamepad.rs
• examples/flow.rs
• examples/physics.rs
• examples/headless.rs
• examples/ui.rs

pub fn rotated(self, rotation: f32) -> Self

Same transform, rotated to rotation radians.

Examples found in repository

examples/ants.rs (line 329)

fn spawn_ant(cmds: &mut Commands, sprite: Option<Texture>, home: Entity, at: Vec2, heading: f32) {
    let ant = Ant {
        home,
        home_at: at,
        heading,
        carrying: false,
        since: 0.0,
        energy: LIFESPAN,
        event: Event::None,
    };
    let t = Transform2D::at(at).rotated(heading);
    match sprite {
        Some(tex) => cmds.spawn((t, ant, Sprite::new(tex).with_color(Color::hex(0xD4553A)))),
        None => cmds.spawn((t, ant)),
    }
}

pub fn scaled(self, scale: Vec2) -> Self

Same transform, scaled by scale.

Examples found in repository

examples/boids.rs (line 103)

fn spawn_boids(ctx: &mut Ctx, n: usize, bounds: Vec2) {
    ctx.world.reflect::<Vel>();
    let tex = ctx.load_texture("crab.png");
    let mut s = 0x9E37_79B9_7F4A_7C15u64;
    let mut rand = move || {
        s ^= s << 13;
        s ^= s >> 7;
        s ^= s << 17;
        (s >> 40) as f32 / (1u64 << 24) as f32
    };
    let mut batch = Vec::with_capacity(n);
    for _ in 0..n {
        let pos = vec2(rand(), rand()) * bounds;
        let vel = Vec2::from_angle(rand() * std::f32::consts::TAU) * MIN_SPEED;
        let tint = Color::rgb(0.5 + rand() * 0.5, 0.7 + rand() * 0.3, 0.9);
        batch.push((
            Transform2D::at(pos).scaled(Vec2::splat(0.5)),
            Sprite::new(tex).with_color(tint),
            Vel(vel),
        ));
    }
    ctx.world.spawn_batch(batch);
}

Trait Implementations

impl Clone for Transform2D

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Transform2D

impl Debug for Transform2D

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

Formats the value using the given formatter.

impl Default for Transform2D

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Transform2D

where Transform2D: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Transform2D

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Transform2D

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Transform2D