Function make_offset_box 

pub fn make_offset_box(
    half_width: f32,
    half_height: f32,
    center: Vec2,
    rotation: Rot,
) -> Polygon

Make an offset box, bypassing the need for a convex hull. (b2MakeOffsetBox)

Examples found in repository

examples/benchmark/scenes/rain.rs (line 85)

pub fn create_rain(world: &mut World) {
    RAIN_DATA.with(|rd| rd.borrow_mut().reset());

    let grid_size = 0.5;
    let grid_count = if BENCHMARK_DEBUG { 200 } else { 500 };
    RAIN_DATA.with(|rd| {
        let mut rd = rd.borrow_mut();
        rd.grid_size = grid_size;
        rd.grid_count = grid_count;
    });

    {
        let body_def = default_body_def();
        let ground_id = create_body(world, &body_def);

        let shape_def = default_shape_def();
        let mut y = 0.0;
        let width = grid_size;
        let height = grid_size;

        for _ in 0..RAIN_ROW_COUNT {
            let mut x = -0.5 * grid_count as f32 * grid_size;
            for _ in 0..=grid_count {
                let box_shape =
                    make_offset_box(0.5 * width, 0.5 * height, Vec2 { x, y }, ROT_IDENTITY);
                create_polygon_shape(world, ground_id, &shape_def, &box_shape);

                x += grid_size;
            }

            y += 45.0;
        }
    }

    RAIN_DATA.with(|rd| {
        let mut rd = rd.borrow_mut();
        rd.column_count = 0;
        rd.column_index = 0;
    });
}

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

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;
    }
}

// (CreateWasher)
pub fn create_washer(world: &mut World) {
    let kinematic = true;

    {
        let body_def = default_body_def();
        // groundId is only used to anchor the (disabled) revolute joint branch.
        let _ground_id = create_body(world, &body_def);
    }

    {
        let motor_speed = 25.0;

        let mut body_def = default_body_def();
        body_def.position = to_pos(Vec2 { x: 0.0, y: 10.0 });

        if kinematic {
            body_def.type_ = BodyType::Kinematic;
            body_def.angular_velocity = (PI / 180.0) * motor_speed;
            body_def.linear_velocity = Vec2 {
                x: 0.001,
                y: -0.002,
            };
        } else {
            body_def.type_ = BodyType::Dynamic;
        }

        let body_id = create_body(world, &body_def);

        let shape_def = default_shape_def();

        let r0 = 14.0;
        let r1 = 16.0;
        let r2 = 18.0;

        let angle = PI / 18.0;
        let q = Rot {
            c: angle.cos(),
            s: angle.sin(),
        };
        let qo = Rot {
            c: (0.1 * angle).cos(),
            s: (0.1 * angle).sin(),
        };
        let mut u1 = Vec2 { x: 1.0, y: 0.0 };
        for i in 0..36 {
            let u2 = if i == 35 {
                Vec2 { x: 1.0, y: 0.0 }
            } else {
                rotate_vector(q, u1)
            };

            {
                let a1 = inv_rotate_vector(qo, u1);
                let a2 = rotate_vector(qo, u2);

                let p1 = mul_sv(r1, a1);
                let p2 = mul_sv(r2, a1);
                let p3 = mul_sv(r1, a2);
                let p4 = mul_sv(r2, a2);

                let points = [p1, p2, p3, p4];
                let hull = compute_hull(&points);

                let polygon = make_polygon(&hull, 0.0);
                create_polygon_shape(world, body_id, &shape_def, &polygon);
            }

            if i % 9 == 0 {
                let p1 = mul_sv(r0, u1);
                let p2 = mul_sv(r1, u1);
                let p3 = mul_sv(r0, u2);
                let p4 = mul_sv(r1, u2);

                let points = [p1, p2, p3, p4];
                let hull = compute_hull(&points);

                let polygon = make_polygon(&hull, 0.0);
                create_polygon_shape(world, body_id, &shape_def, &polygon);
            }

            u1 = u2;
        }
    }

    let grid_count: i32 = if BENCHMARK_DEBUG { 20 } else { 90 };
    let a = 0.1;

    let polygon = make_square(a);
    let mut body_def = default_body_def();
    body_def.type_ = BodyType::Dynamic;
    let mut shape_def = default_shape_def();
    shape_def.enable_hit_events = true;

    let mut y = -1.1 * a * grid_count as f32 + 10.0;
    for _ in 0..grid_count {
        let mut x = -1.1 * a * 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 += 2.1 * a;
        }

        y += 2.1 * a;
    }
}

// (CreateJunkyard)
pub fn create_junkyard(world: &mut World) {
    {
        let grid_size = 1.0;

        let body_def = default_body_def();
        let ground_id = create_body(world, &body_def);

        let shape_def = default_shape_def();

        let y = 0.0;
        let mut x = -80.0 * grid_size;
        for _ in 0..161 {
            let box_shape = make_offset_box(
                0.55 * grid_size,
                0.5 * grid_size,
                Vec2 { x, y },
                ROT_IDENTITY,
            );
            create_polygon_shape(world, ground_id, &shape_def, &box_shape);
            x += grid_size;
        }

        let mut y = grid_size;
        let x = -80.0 * grid_size;
        for _ in 0..50 {
            let box_shape = make_offset_box(
                0.5 * grid_size,
                0.55 * grid_size,
                Vec2 { x, y },
                ROT_IDENTITY,
            );
            create_polygon_shape(world, ground_id, &shape_def, &box_shape);
            y += grid_size;
        }

        let mut y = grid_size;
        let x = 80.0 * grid_size;
        for _ in 0..50 {
            let box_shape = make_offset_box(
                0.5 * grid_size,
                0.55 * grid_size,
                Vec2 { x, y },
                ROT_IDENTITY,
            );
            create_polygon_shape(world, ground_id, &shape_def, &box_shape);
            y += grid_size;
        }
    }

    let column_count = 200;
    let row_count: i32 = if BENCHMARK_DEBUG { 2 } else { 40 };

    let radius = 0.25;
    let polygon;
    {
        // Fibonacci sphere algorithm
        let phi = PI * (5.0f32.sqrt() - 1.0);
        let mut points = [Vec2 { x: 0.0, y: 0.0 }; 5];

        for (i, point) in points.iter_mut().enumerate() {
            let theta = phi * i as f32;
            let cs = compute_cos_sin(theta);
            point.x = radius * cs.cosine;
            point.y = radius * cs.sine;
        }

        let hull = compute_hull(&points);
        polygon = make_polygon(&hull, 0.0);
    }

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

    let mut side = -0.1;
    let y_start = 15.0;

    for i in 0..column_count {
        let x = 1.5 * (2.0 * i as f32 - column_count as f32) * radius;

        for j in 0..row_count {
            let y = 4.0 * j as f32 * radius + y_start;

            body_def.position = to_pos(Vec2 { x: x + side, y });
            side = -side;

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

    body_def.type_ = BodyType::Kinematic;
    body_def.position = to_pos(VEC2_ZERO);
    let pusher_id = create_body(world, &body_def);
    JUNKYARD_PUSHER_ID.with(|id| id.set(pusher_id));
    let box_shape = make_offset_box(2.0, 4.0, Vec2 { x: 0.0, y: 4.0 }, ROT_IDENTITY);
    create_polygon_shape(world, pusher_id, &shape_def, &box_shape);
}

examples/benchmark/scenes/pyramids.rs (lines 212-217)

pub fn create_compounds(world: &mut World) {
    {
        let grid_size = 1.0;

        let body_def = default_body_def();
        let ground_id = create_body(world, &body_def);

        let shape_def = default_shape_def();

        let y = 0.0;
        let mut x = -40.0 * grid_size;
        for _ in 0..81 {
            let box_shape = make_offset_box(
                0.55 * grid_size,
                0.5 * grid_size,
                Vec2 { x, y },
                ROT_IDENTITY,
            );
            create_polygon_shape(world, ground_id, &shape_def, &box_shape);
            x += grid_size;
        }

        let mut y = grid_size;
        let x = -40.0 * grid_size;
        for _ in 0..100 {
            let box_shape = make_offset_box(
                0.5 * grid_size,
                0.55 * grid_size,
                Vec2 { x, y },
                ROT_IDENTITY,
            );
            create_polygon_shape(world, ground_id, &shape_def, &box_shape);
            y += grid_size;
        }

        let mut y = grid_size;
        let x = 40.0 * grid_size;
        for _ in 0..100 {
            let box_shape = make_offset_box(
                0.5 * grid_size,
                0.55 * grid_size,
                Vec2 { x, y },
                ROT_IDENTITY,
            );
            create_polygon_shape(world, ground_id, &shape_def, &box_shape);
            y += grid_size;
        }

        let segment = Segment {
            point1: Vec2 {
                x: -800.0,
                y: -80.0,
            },
            point2: Vec2 { x: 800.0, y: -80.0 },
        };
        create_segment_shape(world, ground_id, &shape_def, &segment);
    }

    let column_count: i32 = if BENCHMARK_DEBUG { 10 } else { 20 };
    let row_count: i32 = if BENCHMARK_DEBUG { 40 } else { 150 };

    let left_points = [
        Vec2 { x: -1.0, y: 0.0 },
        Vec2 { x: 0.5, y: 1.0 },
        Vec2 { x: 0.0, y: 2.0 },
    ];
    let left_hull = compute_hull(&left_points);
    let left = make_polygon(&left_hull, 0.0);

    let right_points = [
        Vec2 { x: 1.0, y: 0.0 },
        Vec2 { x: -0.5, y: 1.0 },
        Vec2 { x: 0.0, y: 2.0 },
    ];
    let right_hull = compute_hull(&right_points);
    let right = make_polygon(&right_hull, 0.0);

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

    let mut shape_def = default_shape_def();
    shape_def.density = 1.0;
    shape_def.material.friction = 0.5;

    // Match the sample exactly: centery is computed before shift is reset for
    // the compound branch.
    let shift = 2.0;
    let extray = 0.25;
    let mut side = 0.25;
    let centerx = shift * column_count as f32 / 2.0 - 1.0;
    let centery = 1.15 / 2.0;
    let y_start = 5.0;

    for i in 0..column_count {
        let x = i as f32 * shift - centerx;

        for j in 0..row_count {
            let y = j as f32 * (shift + extray) + centery + y_start;

            body_def.position = to_pos(Vec2 { x: x + side, y });
            side = -side;

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