Function make_polygon 

pub fn make_polygon(hull: &Hull, radius: f32) -> Polygon

Make a convex polygon from a convex hull. This will assert if the hull is not valid. (b2MakePolygon)

@warning Do not manually fill in the hull data, it must come directly from compute_hull.

Examples found in repository

examples/benchmark/utils.rs (line 93)

pub fn random_polygon(extent: f32) -> Polygon {
    let count = 3 + random_int() % 6;
    let mut points = Vec::with_capacity(count as usize);
    for _ in 0..count {
        points.push(random_vec2(-extent, extent));
    }

    let hull = compute_hull(&points);
    if hull.count > 0 {
        return make_polygon(&hull, 0.0);
    }

    make_square(extent)
}

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

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 (line 267)

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

examples/benchmark/human/create.rs (line 304)

pub fn create_human(
    human: &mut Human,
    world: &mut World,
    position: Pos,
    scale: f32,
    friction_torque: f32,
    hertz: f32,
    damping_ratio: f32,
    group_index: i32,
    user_data: u64,
    colorize: bool,
) {
    debug_assert!(!human.is_spawned);

    for bone in human.bones.iter_mut() {
        bone.body_id = BodyId::default();
        bone.joint_id = JointId::default();
        bone.friction_scale = 1.0;
        bone.parent_index = -1;
    }

    human.original_scale = scale;
    human.scale = scale;
    human.friction_torque = friction_torque;

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

    let mut shape_def = default_shape_def();
    shape_def.material.friction = 0.2;
    shape_def.filter.group_index = -group_index;
    shape_def.filter.category_bits = 2;
    shape_def.filter.mask_bits = 1 | 2;

    let mut foot_shape_def = shape_def;
    foot_shape_def.material.friction = 0.05;
    // feet don't collide with ragdolls
    foot_shape_def.filter.category_bits = 2;
    foot_shape_def.filter.mask_bits = 1;

    if colorize {
        foot_shape_def.material.custom_color = HexColor::SADDLE_BROWN.0;
    }

    let s = scale;
    let max_torque = friction_torque * s;
    let enable_motor = true;
    let enable_limit = true;
    let draw_size = 0.05;

    let shirt_color = HexColor::MEDIUM_TURQUOISE;
    let pant_color = HexColor::DODGER_BLUE;

    let skin_colors = [
        HexColor::NAVAJO_WHITE,
        HexColor::LIGHT_YELLOW,
        HexColor::PERU,
        HexColor::TAN,
    ];
    let skin_color = skin_colors[(group_index % 4) as usize];

    // hip
    {
        human.bones[BONE_HIP].parent_index = -1;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 0.95 * s,
            },
        );
        body_def.linear_damping = 0.0;
        body_def.name = "hip".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_HIP].body_id = body_id;

        if colorize {
            shape_def.material.custom_color = pant_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.02 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.02 * s,
            },
            radius: 0.095 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);
    }

    // torso
    {
        human.bones[BONE_TORSO].parent_index = BONE_HIP as i32;

        body_def.position = offset_pos(position, Vec2 { x: 0.0, y: 1.2 * s });
        body_def.linear_damping = 0.0;
        body_def.name = "torso".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_TORSO].body_id = body_id;
        human.bones[BONE_TORSO].friction_scale = 0.5;
        body_def.type_ = BodyType::Dynamic;

        if colorize {
            shape_def.material.custom_color = shirt_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.135 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.135 * s,
            },
            radius: 0.09 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        let pivot = offset_pos(position, Vec2 { x: 0.0, y: 1.0 * s });
        let parent = human.bones[BONE_HIP].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.25 * PI,
            0.0,
            enable_limit,
            enable_motor,
            human.bones[BONE_TORSO].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            None,
        );
        human.bones[BONE_TORSO].joint_id = joint_id;
    }

    // head
    {
        human.bones[BONE_HEAD].parent_index = BONE_TORSO as i32;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0 * s,
                y: 1.475 * s,
            },
        );
        body_def.linear_damping = 0.1;
        body_def.name = "head".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_HEAD].body_id = body_id;
        human.bones[BONE_HEAD].friction_scale = 0.25;

        if colorize {
            shape_def.material.custom_color = skin_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.038 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.039 * s,
            },
            radius: 0.075 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        let pivot = offset_pos(position, Vec2 { x: 0.0, y: 1.4 * s });
        let parent = human.bones[BONE_TORSO].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.3 * PI,
            0.1 * PI,
            enable_limit,
            enable_motor,
            human.bones[BONE_HEAD].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            None,
        );
        human.bones[BONE_HEAD].joint_id = joint_id;
    }

    // upper left leg
    {
        human.bones[BONE_UPPER_LEFT_LEG].parent_index = BONE_HIP as i32;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 0.775 * s,
            },
        );
        body_def.linear_damping = 0.0;
        body_def.name = "upper_left_leg".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_UPPER_LEFT_LEG].body_id = body_id;
        human.bones[BONE_UPPER_LEFT_LEG].friction_scale = 1.0;

        if colorize {
            shape_def.material.custom_color = pant_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.125 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.125 * s,
            },
            radius: 0.06 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        let pivot = offset_pos(position, Vec2 { x: 0.0, y: 0.9 * s });
        let parent = human.bones[BONE_HIP].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.05 * PI,
            0.4 * PI,
            enable_limit,
            enable_motor,
            human.bones[BONE_UPPER_LEFT_LEG].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            None,
        );
        human.bones[BONE_UPPER_LEFT_LEG].joint_id = joint_id;
    }

    let foot_points = [
        Vec2 {
            x: -0.03 * s,
            y: -0.185 * s,
        },
        Vec2 {
            x: 0.11 * s,
            y: -0.185 * s,
        },
        Vec2 {
            x: 0.11 * s,
            y: -0.16 * s,
        },
        Vec2 {
            x: -0.03 * s,
            y: -0.14 * s,
        },
    ];
    let foot_hull = compute_hull(&foot_points);
    let foot_polygon = make_polygon(&foot_hull, 0.015 * s);

    // lower left leg
    {
        human.bones[BONE_LOWER_LEFT_LEG].parent_index = BONE_UPPER_LEFT_LEG as i32;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 0.475 * s,
            },
        );
        body_def.linear_damping = 0.0;
        body_def.name = "lower_left_leg".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_LOWER_LEFT_LEG].body_id = body_id;
        human.bones[BONE_LOWER_LEFT_LEG].friction_scale = 0.5;

        if colorize {
            shape_def.material.custom_color = pant_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.155 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.125 * s,
            },
            radius: 0.045 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        create_polygon_shape(world, body_id, &foot_shape_def, &foot_polygon);

        let pivot = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 0.625 * s,
            },
        );
        let parent = human.bones[BONE_UPPER_LEFT_LEG].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.5 * PI,
            -0.02 * PI,
            enable_limit,
            enable_motor,
            human.bones[BONE_LOWER_LEFT_LEG].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            None,
        );
        human.bones[BONE_LOWER_LEFT_LEG].joint_id = joint_id;
    }

    // upper right leg
    {
        human.bones[BONE_UPPER_RIGHT_LEG].parent_index = BONE_HIP as i32;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 0.775 * s,
            },
        );
        body_def.linear_damping = 0.0;
        body_def.name = "upper_right_leg".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_UPPER_RIGHT_LEG].body_id = body_id;
        human.bones[BONE_UPPER_RIGHT_LEG].friction_scale = 1.0;

        if colorize {
            shape_def.material.custom_color = pant_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.125 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.125 * s,
            },
            radius: 0.06 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        let pivot = offset_pos(position, Vec2 { x: 0.0, y: 0.9 * s });
        let parent = human.bones[BONE_HIP].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.05 * PI,
            0.4 * PI,
            enable_limit,
            enable_motor,
            human.bones[BONE_UPPER_RIGHT_LEG].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            None,
        );
        human.bones[BONE_UPPER_RIGHT_LEG].joint_id = joint_id;
    }

    // lower right leg
    {
        human.bones[BONE_LOWER_RIGHT_LEG].parent_index = BONE_UPPER_RIGHT_LEG as i32;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 0.475 * s,
            },
        );
        body_def.linear_damping = 0.0;
        body_def.name = "lower_right_leg".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_LOWER_RIGHT_LEG].body_id = body_id;
        human.bones[BONE_LOWER_RIGHT_LEG].friction_scale = 0.5;

        if colorize {
            shape_def.material.custom_color = pant_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.155 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.125 * s,
            },
            radius: 0.045 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        create_polygon_shape(world, body_id, &foot_shape_def, &foot_polygon);

        let pivot = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 0.625 * s,
            },
        );
        let parent = human.bones[BONE_UPPER_RIGHT_LEG].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.5 * PI,
            -0.02 * PI,
            enable_limit,
            enable_motor,
            human.bones[BONE_LOWER_RIGHT_LEG].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            None,
        );
        human.bones[BONE_LOWER_RIGHT_LEG].joint_id = joint_id;
    }

    // upper left arm
    {
        human.bones[BONE_UPPER_LEFT_ARM].parent_index = BONE_TORSO as i32;
        human.bones[BONE_UPPER_LEFT_ARM].friction_scale = 0.5;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 1.225 * s,
            },
        );
        body_def.linear_damping = 0.0;
        body_def.name = "upper_left_arm".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_UPPER_LEFT_ARM].body_id = body_id;

        if colorize {
            shape_def.material.custom_color = shirt_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.125 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.125 * s,
            },
            radius: 0.035 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        let pivot = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 1.35 * s,
            },
        );
        let parent = human.bones[BONE_TORSO].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.1 * PI,
            0.8 * PI,
            enable_limit,
            enable_motor,
            human.bones[BONE_UPPER_LEFT_ARM].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            None,
        );
        human.bones[BONE_UPPER_LEFT_ARM].joint_id = joint_id;
    }

    // lower left arm
    {
        human.bones[BONE_LOWER_LEFT_ARM].parent_index = BONE_UPPER_LEFT_ARM as i32;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 0.975 * s,
            },
        );
        body_def.linear_damping = 0.1;
        body_def.name = "lower_left_arm".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_LOWER_LEFT_ARM].body_id = body_id;
        human.bones[BONE_LOWER_LEFT_ARM].friction_scale = 0.1;

        if colorize {
            shape_def.material.custom_color = skin_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.125 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.125 * s,
            },
            radius: 0.03 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        let pivot = offset_pos(position, Vec2 { x: 0.0, y: 1.1 * s });
        let parent = human.bones[BONE_UPPER_LEFT_ARM].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.2 * PI,
            0.3 * PI,
            enable_limit,
            enable_motor,
            human.bones[BONE_LOWER_LEFT_ARM].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            Some(make_rot(0.25 * PI)),
        );
        human.bones[BONE_LOWER_LEFT_ARM].joint_id = joint_id;
    }

    // upper right arm
    {
        human.bones[BONE_UPPER_RIGHT_ARM].parent_index = BONE_TORSO as i32;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 1.225 * s,
            },
        );
        body_def.linear_damping = 0.0;
        body_def.name = "upper_right_arm".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_UPPER_RIGHT_ARM].body_id = body_id;
        human.bones[BONE_UPPER_RIGHT_ARM].friction_scale = 0.5;

        if colorize {
            shape_def.material.custom_color = shirt_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.125 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.125 * s,
            },
            radius: 0.035 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        let pivot = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 1.35 * s,
            },
        );
        let parent = human.bones[BONE_TORSO].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.1 * PI,
            0.8 * PI,
            enable_limit,
            enable_motor,
            human.bones[BONE_UPPER_RIGHT_ARM].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            None,
        );
        human.bones[BONE_UPPER_RIGHT_ARM].joint_id = joint_id;
    }

    // lower right arm
    {
        human.bones[BONE_LOWER_RIGHT_ARM].parent_index = BONE_UPPER_RIGHT_ARM as i32;

        body_def.position = offset_pos(
            position,
            Vec2 {
                x: 0.0,
                y: 0.975 * s,
            },
        );
        body_def.linear_damping = 0.1;
        body_def.name = "lower_right_arm".to_string();

        let body_id = create_body(world, &body_def);
        human.bones[BONE_LOWER_RIGHT_ARM].body_id = body_id;
        human.bones[BONE_LOWER_RIGHT_ARM].friction_scale = 0.1;

        if colorize {
            shape_def.material.custom_color = skin_color.0;
        }

        let capsule = Capsule {
            center1: Vec2 {
                x: 0.0,
                y: -0.125 * s,
            },
            center2: Vec2 {
                x: 0.0,
                y: 0.125 * s,
            },
            radius: 0.03 * s,
        };
        create_capsule_shape(world, body_id, &shape_def, &capsule);

        let pivot = offset_pos(position, Vec2 { x: 0.0, y: 1.1 * s });
        let parent = human.bones[BONE_UPPER_RIGHT_ARM].body_id;
        let joint_id = attach_revolute_joint(
            world,
            parent,
            body_id,
            pivot,
            -0.2 * PI,
            0.3 * PI,
            enable_limit,
            enable_motor,
            human.bones[BONE_LOWER_RIGHT_ARM].friction_scale * max_torque,
            hertz > 0.0,
            hertz,
            damping_ratio,
            draw_size,
            Some(make_rot(0.25 * PI)),
        );
        human.bones[BONE_LOWER_RIGHT_ARM].joint_id = joint_id;
    }

    human.is_spawned = true;
}