Function compute_cos_sin 

pub fn compute_cos_sin(radians: f32) -> CosSin

Compute the cosine and sine of an angle in radians. Implemented for cross-platform determinism.

Examples found in repository

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

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

// (StepJunkyard)
pub fn step_junkyard(world: &mut World, step_count: i32) -> f32 {
    let time_step = 1.0 / 60.0;
    let time = time_step * step_count as f32;
    let cs = compute_cos_sin(0.2 * time);
    let target = WorldTransform {
        p: to_pos(Vec2 {
            x: 60.0 * cs.sine,
            y: 0.0,
        }),
        q: ROT_IDENTITY,
    };
    let pusher_id = JUNKYARD_PUSHER_ID.with(|id| id.get());
    body_set_target_transform(world, pusher_id, target, time_step, true);
    0.0
}