Function make_box 

pub fn make_box(half_width: f32, half_height: f32) -> Polygon

Make a box (rectangle) polygon, bypassing the need for a convex hull. (b2MakeBox)

Examples found in repository

examples/demo_scenes.rs (line 15)

fn add_static_box(world: &mut World, x: f32, y: f32, hx: f32, hy: f32) -> i32 {
    let mut body_def = default_body_def();
    body_def.position = m::to_pos(m::Vec2 { x, y });
    let id = create_body(world, &body_def);
    let def = default_shape_def();
    let poly = make_box(hx, hy);
    create_polygon_shape(world, id, &def, &poly);
    get_body_full_id(world, id)
}

fn add_box(world: &mut World, x: f32, y: f32, hx: f32, hy: f32) -> i32 {
    let mut body_def = default_body_def();
    body_def.type_ = BodyType::Dynamic;
    body_def.position = m::to_pos(m::Vec2 { x, y });
    let id = create_body(world, &body_def);
    let mut def = default_shape_def();
    def.density = 1.0;
    def.material.friction = 0.3;
    let poly = make_box(hx, hy);
    create_polygon_shape(world, id, &def, &poly);
    get_body_full_id(world, id)
}

examples/benchmark/scenes/pyramids.rs (line 92)

pub fn create_large_pyramid(world: &mut World) {
    world_enable_sleeping(world, false);

    let base_count: i32 = if BENCHMARK_DEBUG { 20 } else { 100 };

    {
        let mut body_def = default_body_def();
        body_def.position = to_pos(Vec2 { x: 0.0, y: -1.0 });
        let ground_id = create_body(world, &body_def);

        let box_shape = make_box(100.0, 1.0);
        let shape_def = default_shape_def();
        create_polygon_shape(world, ground_id, &shape_def, &box_shape);
    }

    let mut body_def = default_body_def();
    body_def.type_ = BodyType::Dynamic;

    let mut shape_def = default_shape_def();
    shape_def.density = 1.0;

    let a = 0.5;
    let box_shape = make_square(a);

    let shift = 1.0 * a;

    for i in 0..base_count {
        let y = (2.0 * i as f32 + 1.0) * shift;

        for j in i..base_count {
            let x = (i as f32 + 1.0) * shift + 2.0 * (j - i) as f32 * shift - a * base_count as f32;

            body_def.position = to_pos(Vec2 { x, y });

            let body_id = create_body(world, &body_def);
            create_polygon_shape(world, body_id, &shape_def, &box_shape);
        }
    }
}

examples/benchmark/scenes/machines.rs (line 156)

pub fn create_smash(world: &mut World) {
    world_set_gravity(world, VEC2_ZERO);

    {
        let box_shape = make_box(4.0, 4.0);

        let mut body_def = default_body_def();
        body_def.type_ = BodyType::Dynamic;
        body_def.position = to_pos(Vec2 { x: -20.0, y: 0.0 });
        body_def.linear_velocity = Vec2 { x: 40.0, y: 0.0 };
        let body_id = create_body(world, &body_def);

        let mut shape_def = default_shape_def();
        shape_def.density = 8.0;
        create_polygon_shape(world, body_id, &shape_def, &box_shape);
    }

    let d = 0.4;
    let box_shape = make_square(0.5 * d);

    let mut body_def = default_body_def();
    body_def.type_ = BodyType::Dynamic;
    body_def.is_awake = false;

    let shape_def = default_shape_def();

    let columns: i32 = if BENCHMARK_DEBUG { 20 } else { 120 };
    let rows: i32 = if BENCHMARK_DEBUG { 10 } else { 80 };

    for i in 0..columns {
        for j in 0..rows {
            body_def.position = to_pos(Vec2 {
                x: i as f32 * d + 30.0,
                y: (j as f32 - rows as f32 / 2.0) * d,
            });
            let body_id = create_body(world, &body_def);
            create_polygon_shape(world, body_id, &shape_def, &box_shape);
        }
    }
}

// (CreateTumbler)
pub fn create_tumbler(world: &mut World) {
    let ground_id;
    {
        let body_def = default_body_def();
        ground_id = create_body(world, &body_def);
    }

    {
        let mut body_def = default_body_def();
        body_def.type_ = BodyType::Dynamic;
        body_def.position = to_pos(Vec2 { x: 0.0, y: 10.0 });
        let body_id = create_body(world, &body_def);

        let mut shape_def = default_shape_def();
        shape_def.density = 50.0;

        let polygon = make_offset_box(0.5, 10.0, Vec2 { x: 10.0, y: 0.0 }, ROT_IDENTITY);
        create_polygon_shape(world, body_id, &shape_def, &polygon);
        let polygon = make_offset_box(0.5, 10.0, Vec2 { x: -10.0, y: 0.0 }, ROT_IDENTITY);
        create_polygon_shape(world, body_id, &shape_def, &polygon);
        let polygon = make_offset_box(10.0, 0.5, Vec2 { x: 0.0, y: 10.0 }, ROT_IDENTITY);
        create_polygon_shape(world, body_id, &shape_def, &polygon);
        let polygon = make_offset_box(10.0, 0.5, Vec2 { x: 0.0, y: -10.0 }, ROT_IDENTITY);
        create_polygon_shape(world, body_id, &shape_def, &polygon);

        let motor_speed = 25.0;

        let mut joint_def = default_revolute_joint_def();
        joint_def.base.body_id_a = ground_id;
        joint_def.base.body_id_b = body_id;
        joint_def.base.local_frame_a.p = Vec2 { x: 0.0, y: 10.0 };
        joint_def.base.local_frame_b.p = Vec2 { x: 0.0, y: 0.0 };
        joint_def.motor_speed = (PI / 180.0) * motor_speed;
        joint_def.max_motor_torque = 1e8;
        joint_def.enable_motor = true;

        create_revolute_joint(world, &joint_def);
    }

    let grid_count: i32 = if BENCHMARK_DEBUG { 20 } else { 45 };

    let polygon = make_box(0.125, 0.125);
    let mut body_def = default_body_def();
    body_def.type_ = BodyType::Dynamic;
    let shape_def = default_shape_def();

    let mut y = -0.2 * grid_count as f32 + 10.0;
    for _ in 0..grid_count {
        let mut x = -0.2 * grid_count as f32;

        for _ in 0..grid_count {
            body_def.position = to_pos(Vec2 { x, y });
            let body_id = create_body(world, &body_def);

            create_polygon_shape(world, body_id, &shape_def, &polygon);

            x += 0.4;
        }

        y += 0.4;
    }
}