Struct Rect 

#[repr(C)]
pub struct Rect {
    pub min: Vec2,
    pub max: Vec2,
}

An axis-aligned rectangle: min is the top-left corner, max the bottom-right (y grows downward, like window pixels).

let r = Rect::new(10.0, 20.0, 100.0, 50.0); // x, y, width, height
assert_eq!(r.size(), vec2(100.0, 50.0));
assert!(r.contains(vec2(50.0, 40.0)));

Fields

min: Vec2

Top-left corner (smallest x and y).

max: Vec2

Bottom-right corner (largest x and y).

Implementations

impl Rect

pub fn new(x: f32, y: f32, width: f32, height: f32) -> Self

A rectangle from its top-left corner and its size.

let button = Rect::new(20.0, 20.0, 120.0, 32.0);

Examples found in repository

examples/flow.rs (line 226)

fn hud(ctx: &mut Ctx) {
    let panel = Rect::new(12.0, 12.0, 260.0, 104.0);
    ctx.ui_panel(panel);
    let at = panel.min + ctx.ui_style.padding;
    let agents = ctx.world.query::<&Agent>().count();
    let ms = ctx.world.resource::<Paths>().compute_ms;
    let text = format!(
        "{agents} agents, {:.0} FPS\nfield: {}x{} cells, {ms:.2} ms\nclick: new goal   H: distances",
        ctx.fps(),
        MAP.x,
        MAP.y
    );
    ctx.ui_label(at, &text);
}

examples/tiles.rs (line 148)

fn hud(ctx: &mut Ctx) {
    let r = ctx.render_stats();
    let text = format!(
        "{} sprites drawn ({} draw calls)\nzoom {:.2}x, {:.0} FPS\nleft mouse: paint, right drag: pan, wheel: zoom",
        r.sprites,
        r.draw_calls,
        ctx.camera.zoom,
        ctx.fps()
    );
    let size = ctx.measure_text(&text, ctx.ui_style.text_size) + 2.0 * ctx.ui_style.padding;
    let panel = Rect::new(12.0, 12.0, size.x, size.y);
    ctx.ui_panel(panel);
    ctx.ui_label(panel.min + ctx.ui_style.padding, &text);
}

examples/ants.rs (line 417)

fn hud(ctx: &mut Ctx) {
    let ants = ctx.world.query::<&Ant>().count();
    let nests = ctx.world.query::<&Nest>().count();
    let food = delivered(&mut ctx.world);
    let panel = Rect::new(12.0, 12.0, 260.0, 156.0);
    ctx.ui_panel(panel);
    let mut at = panel.min + ctx.ui_style.padding;
    let speed = if ctx.is_paused() {
        "paused".to_string()
    } else {
        format!("{}x", ctx.sim_speed())
    };
    let stats = format!(
        "{ants} ants in {nests} colonies\n{food} food delivered\nspeed {speed}, {:.0} FPS",
        ctx.fps()
    );
    at.y += ctx.ui_label(at, &stats).y + 8.0;
    let pause = if ctx.is_paused() { "Run" } else { "Pause" };
    if ctx.ui_button(Rect::new(at.x, at.y, 72.0, 30.0), pause) {
        if ctx.is_paused() { ctx.resume() } else { ctx.pause() }
    }
    for (i, speed) in [1.0f32, 4.0, 16.0].into_iter().enumerate() {
        let r = Rect::new(at.x + 80.0 + i as f32 * 54.0, at.y, 48.0, 30.0);
        if ctx.ui_button(r, &format!("{speed}x")) {
            ctx.set_sim_speed(speed);
            ctx.resume();
        }
    }
}

examples/ui.rs (line 27)

fn scene(ctx: &mut Ctx) {
    let t = ctx.time() as f32;

    // The world: a grid of tiles, a few shapes, a crab in orbit.
    for y in 0..20 {
        for x in 0..20 {
            let shade = if (x + y) % 2 == 0 { 0.16 } else { 0.19 };
            let tile = Rect::new(x as f32 * 64.0, y as f32 * 64.0, 64.0, 64.0);
            ctx.draw_rect(tile, Color::rgb(shade, shade + 0.03, shade));
        }
    }
    let center = vec2(640.0, 640.0);
    ctx.draw_circle(center, 180.0, Color::hex(0x3a86ff).with_alpha(0.15));
    let orbit = center + Vec2::from_angle(t * 0.6) * 180.0;
    ctx.draw_line(center, orbit, 3.0, Color::hex(0xffbe0b));
    let crab = ctx.world.resource::<Scene>().crab;
    ctx.draw_ex(
        &crab,
        orbit,
        DrawParams {
            rotation: t,
            ..Default::default()
        },
    );

    // A label that sticks to the crab: world position -> window pixels.
    let above = ctx.camera.world_to_screen(orbit) + vec2(-28.0, -40.0);
    ctx.draw_text("orbiter", above, 16.0, Color::hex(0xffbe0b));

    if ctx.world.resource::<Scene>().follow {
        ctx.camera.look_at(orbit);
    }
    if ctx.mouse_pressed(MouseButton::Left) && !ctx.mouse_over_ui() {
        let at = ctx.mouse_world();
        ctx.world.spawn((Transform2D::at(at), Sprite::new(crab)));
        let plop = ctx.world.resource::<Scene>().plop;
        let speed = 0.8 + ctx.random().stream(0).f32() * 0.4;
        ctx.play_sound_ex(
            &plop,
            SoundParams {
                speed,
                ..Default::default()
            },
        );
        ctx.world.resource_mut::<Scene>().dropped += 1;
    }
}
// ANCHOR_END: scene

// ANCHOR: hud
fn hud(ctx: &mut Ctx) {
    let panel = Rect::new(12.0, 12.0, 230.0, 172.0);
    ctx.ui_panel(panel);
    let mut at = panel.min + ctx.ui_style.padding;
    let (zoom, dropped) = (ctx.camera.zoom, ctx.world.resource::<Scene>().dropped);
    let lines = format!("zoom {zoom:.2}x\ncrabs dropped: {dropped}\n{:.0} FPS", ctx.fps());
    at.y += ctx.ui_label(at, &lines).y + 8.0;

    let follow = ctx.world.resource::<Scene>().follow;
    let label = if follow { "Stop following" } else { "Follow orbiter" };
    if ctx.ui_button(Rect::new(at.x, at.y, 210.0, 30.0), label) {
        ctx.world.resource_mut::<Scene>().follow = !follow;
    }
    at.y += 38.0;
    if ctx.ui_button(Rect::new(at.x, at.y, 210.0, 30.0), "Reset camera") {
        ctx.camera.zoom = 1.0;
        ctx.camera.position = Vec2::ZERO;
        ctx.world.resource_mut::<Scene>().follow = false;
    }
}

examples/battle.rs (line 592)

fn draw_map(ctx: &mut Ctx) -> impl FnMut(&mut Ctx) + use<> {
    let size = ctx.world.resource::<Battle>().nav.size();
    let mut pixels = vec![0u8; (size.x * size.y * 4) as usize];
    {
        let nav = &ctx.world.resource::<Battle>().nav;
        for y in 0..size.y {
            for x in 0..size.x {
                // A little per-cell noise so the ground doesn't look flat.
                let n = ((x.wrapping_mul(73_856_093) ^ y.wrapping_mul(19_349_663)) % 9) as u8;
                let px = match nav.cost(x, y).unwrap() {
                    NavGrid::WALL => [52 + n, 56 + n, 66 + n, 255],
                    MUD => [74 + n, 56 + n, 34, 255],
                    _ => [30 + n, 46 + n, 32, 255],
                };
                pixels[((y * size.x + x) * 4) as usize..][..4].copy_from_slice(&px);
            }
        }
    }
    let tex = ctx.create_texture(size.x, size.y, &pixels);
    ctx.set_texture_filter(&tex, TextureFilter::Nearest);
    move |ctx: &mut Ctx| {
        ctx.clear(Color::BLACK);
        let world = size.as_vec2() * CELL;
        ctx.draw_ex(
            &tex,
            world / 2.0,
            DrawParams {
                scale: Vec2::splat(CELL),
                z: -10.0,
                ..Default::default()
            },
        );
        let rally = ctx.world.resource::<Battle>().rally[0];
        let mut bases = [(Vec2::ZERO, 0.0, Team::Red); 2];
        ctx.world.query::<(&Transform2D, &Base)>().for_each(|(t, b)| {
            bases[b.team.index()] = (t.position, b.hp / b.max_hp, b.team);
        });
        for (at, health, team) in bases {
            ctx.draw_circle(at, BASE_RADIUS, team.color().with_alpha(0.35));
            ctx.draw_circle(at, BASE_RADIUS * 0.4, team.color());
            let bar = Rect::new(at.x - BASE_RADIUS, at.y - BASE_RADIUS - 8.0, BASE_RADIUS * 2.0, 3.0);
            ctx.draw_rect(bar, Color::rgba(0.0, 0.0, 0.0, 0.6));
            ctx.draw_rect(
                Rect::new(bar.min.x, bar.min.y, bar.size().x * health, 3.0),
                team.color(),
            );
        }
        ctx.draw_circle(rally, 5.0, Color::rgba(1.0, 0.9, 0.3, 0.9));
    }
}

fn hud(ctx: &mut Ctx) {
    let field_ms = ctx.world.resource::<Battle>().field_ms;
    let s = ctx.world.resource::<Score>();
    let (alive, won, winner) = (s.alive, s.rounds_won, s.winner);
    let sim_ms: f32 = ctx.system_timings().iter().filter(|t| t.sim).map(|t| t.avg_ms).sum();
    let speed = if ctx.is_paused() {
        "paused".to_string()
    } else {
        format!("{}x", ctx.sim_speed())
    };
    let panel = Rect::new(12.0, 12.0, 300.0, 150.0);
    ctx.ui_panel(panel);
    let at = panel.min + ctx.ui_style.padding;
    let text = format!(
        "red {} vs blue {}   (rounds {}-{})\nsim {sim_ms:.2} ms/tick, {:.0} FPS, {speed}\nfield {field_ms:.2} ms\nclick: rally  A: attack  D: defend\nR: restart  1-3: speed",
        alive[0],
        alive[1],
        won[0],
        won[1],
        ctx.fps()
    );
    ctx.ui_label(at, &text);
    if let Some(team) = winner {
        let msg = if team == Team::Red {
            "Red wins! R for another round"
        } else {
            "Blue wins. R to try again"
        };
        let center = ctx.window_size() / 2.0;
        let size = ctx.measure_text(msg, 32.0);
        ctx.draw_text(msg, center - size / 2.0, 32.0, team.color());
    }
}

examples/physics.rs (line 164)

fn draw(ctx: &mut Ctx) {
    ctx.clear(Color::hex(0x1d2330));
    let shapes: Vec<(Transform2D, Collider, bool, f32)> = ctx
        .world
        .query::<(&Transform2D, &Collider, &RigidBody, Option<&Bell>)>()
        .iter()
        .map(|(t, c, b, bell)| (*t, *c, b.kind == BodyKind::Fixed, bell.map_or(0.0, |b| b.rang)))
        .collect();
    for (t, c, fixed, rang) in shapes {
        let color = if c.sensor {
            Color::rgba(1.0, 0.3 + 0.7 * (1.0 - rang), 0.3, 0.35)
        } else if fixed {
            Color::hex(0x4a5568)
        } else {
            Color::hex(0xf6ad55)
        };
        match c.shape {
            Shape::Circle { radius } => {
                ctx.draw_circle(t.position, radius, color);
                // A spoke shows the spin.
                let spoke = t.position + Vec2::from_angle(t.rotation) * radius;
                ctx.draw_line(t.position, spoke, 2.0, Color::hex(0x1d2330));
            }
            Shape::Rect { size } => {
                // Four corners turned with the body, drawn as edges.
                let (sin, cos) = t.rotation.sin_cos();
                let turn = |v: Vec2| t.position + vec2(v.x * cos - v.y * sin, v.x * sin + v.y * cos);
                let h = size / 2.0;
                let corners = [vec2(-h.x, -h.y), vec2(h.x, -h.y), vec2(h.x, h.y), vec2(-h.x, h.y)].map(turn);
                if fixed || c.sensor {
                    ctx.draw_rect(Rect::new(t.position.x - h.x, t.position.y - h.y, size.x, size.y), color);
                } else {
                    for i in 0..4 {
                        ctx.draw_line(corners[i], corners[(i + 1) % 4], 3.0, color);
                    }
                }
            }
            Shape::Capsule { height, radius } => {
                let up = Vec2::from_angle(t.rotation + std::f32::consts::FRAC_PI_2) * height / 2.0;
                ctx.draw_line(t.position - up, t.position + up, radius * 2.0, color);
            }
            Shape::Polygon { .. } => {
                let (sin, cos) = t.rotation.sin_cos();
                let turn = |v: Vec2| t.position + vec2(v.x * cos - v.y * sin, v.x * sin + v.y * cos);
                let corners: Vec<Vec2> = c.shape.points().iter().map(|&p| turn(p + c.offset)).collect();
                for i in 0..corners.len() {
                    ctx.draw_line(corners[i], corners[(i + 1) % corners.len()], 3.0, color);
                }
            }
            _ => {} // shapes added in later versions
        }
    }
    if let Some(hit) = laser(ctx) {
        ctx.draw_line(ctx.mouse_world(), hit.point, 1.0, Color::rgba(1.0, 0.2, 0.2, 0.8));
        ctx.draw_circle(hit.point, 4.0, Color::rgb(1.0, 0.2, 0.2));
    }
    let bodies = ctx.physics.body_count();
    ctx.draw_text(
        &format!(
            "{bodies} bodies  |  left click: crate  right click: ball  middle click: rock  space: blast  R: reset"
        ),
        vec2(30.0, 30.0),
        18.0,
        Color::WHITE,
    );
}

pub fn size(&self) -> Vec2

Width and height.

assert_eq!(Rect::new(0.0, 0.0, 4.0, 3.0).size(), vec2(4.0, 3.0));

Examples found in repository

examples/battle.rs (line 595)

fn draw_map(ctx: &mut Ctx) -> impl FnMut(&mut Ctx) + use<> {
    let size = ctx.world.resource::<Battle>().nav.size();
    let mut pixels = vec![0u8; (size.x * size.y * 4) as usize];
    {
        let nav = &ctx.world.resource::<Battle>().nav;
        for y in 0..size.y {
            for x in 0..size.x {
                // A little per-cell noise so the ground doesn't look flat.
                let n = ((x.wrapping_mul(73_856_093) ^ y.wrapping_mul(19_349_663)) % 9) as u8;
                let px = match nav.cost(x, y).unwrap() {
                    NavGrid::WALL => [52 + n, 56 + n, 66 + n, 255],
                    MUD => [74 + n, 56 + n, 34, 255],
                    _ => [30 + n, 46 + n, 32, 255],
                };
                pixels[((y * size.x + x) * 4) as usize..][..4].copy_from_slice(&px);
            }
        }
    }
    let tex = ctx.create_texture(size.x, size.y, &pixels);
    ctx.set_texture_filter(&tex, TextureFilter::Nearest);
    move |ctx: &mut Ctx| {
        ctx.clear(Color::BLACK);
        let world = size.as_vec2() * CELL;
        ctx.draw_ex(
            &tex,
            world / 2.0,
            DrawParams {
                scale: Vec2::splat(CELL),
                z: -10.0,
                ..Default::default()
            },
        );
        let rally = ctx.world.resource::<Battle>().rally[0];
        let mut bases = [(Vec2::ZERO, 0.0, Team::Red); 2];
        ctx.world.query::<(&Transform2D, &Base)>().for_each(|(t, b)| {
            bases[b.team.index()] = (t.position, b.hp / b.max_hp, b.team);
        });
        for (at, health, team) in bases {
            ctx.draw_circle(at, BASE_RADIUS, team.color().with_alpha(0.35));
            ctx.draw_circle(at, BASE_RADIUS * 0.4, team.color());
            let bar = Rect::new(at.x - BASE_RADIUS, at.y - BASE_RADIUS - 8.0, BASE_RADIUS * 2.0, 3.0);
            ctx.draw_rect(bar, Color::rgba(0.0, 0.0, 0.0, 0.6));
            ctx.draw_rect(
                Rect::new(bar.min.x, bar.min.y, bar.size().x * health, 3.0),
                team.color(),
            );
        }
        ctx.draw_circle(rally, 5.0, Color::rgba(1.0, 0.9, 0.3, 0.9));
    }
}

pub fn center(&self) -> Vec2

The middle point.

assert_eq!(Rect::new(0.0, 0.0, 4.0, 2.0).center(), vec2(2.0, 1.0));

pub fn contains(&self, point: Vec2) -> bool

true if point is inside (edges included).

let hovered = button.contains(ctx.mouse_pos());

pub fn expand(&self, by: f32) -> Self

The same rectangle grown by by on every side (shrunk if negative).

let inner = Rect::new(0.0, 0.0, 100.0, 100.0).expand(-8.0);
assert_eq!(inner.min, vec2(8.0, 8.0));

Trait Implementations

impl Clone for Rect

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 Rect

impl Debug for Rect

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

Formats the value using the given formatter.

impl Default for Rect

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Rect

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Rect

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Rect

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 Rect