main.rs

use bevy::prelude::*;
use bevy::render::camera::{Camera, OrthographicProjection, PerspectiveProjection};
use bevy_rapier3d::prelude::*;

use bevy::render::pass::ClearColor;
use bevy_flycam::{FlyCam, PlayerPlugin};


fn main() {
    App::build()
        .insert_resource(ClearColor(Color::rgb(
            0xF9 as f32 / 255.0,
            0xF9 as f32 / 255.0,
            0xFF as f32 / 255.0,
        )))
        .add_plugins(DefaultPlugins)
        .add_plugin(PlayerPlugin)
        .add_plugin(RapierPhysicsPlugin::<NoUserData>::default())
        .add_plugin(RapierRenderPlugin)
        .add_startup_system(setup_graphics.system())
        .add_startup_system(setup_physics.system())
        .add_system(update_text_system.system())
        .run();
}

fn setup_graphics(mut commands: Commands, asset_server: Res<AssetServer>) {
    commands.spawn_bundle(LightBundle {
        transform: Transform::from_translation(Vec3::new(100.0, 10.0, 200.0)),
        light: Light {
            intensity: 100_000.0,
            range: 3000.0,
            ..Default::default()
        },
        ..Default::default()
    });

    commands.spawn_bundle(UiCameraBundle::default());

    let font = asset_server.load("fonts/roboto.ttf");
    println!("{:?}", font);

    commands.spawn_bundle(
        TextBundle {
            style: Style {
                align_self: AlignSelf::FlexEnd,
                position_type: PositionType::Relative,
                position: Rect {
                    bottom: Val::Px(5.0),
                    right: Val::Px(15.0),
                    ..Default::default()
                },
                ..Default::default()
            },
            text: Text::with_section(
                // Accepts a `String` or any type that converts into a `String`, such as `&str`
                "hello\nbevy!",
                TextStyle {
                    font: font,
                    font_size: 100.0,
                    color: Color::WHITE,
                },
                // Note: You can use `Default::default()` in place of the `TextAlignment`
                TextAlignment {
                    horizontal: HorizontalAlign::Center,
                    ..Default::default()
                },
            ),
            ..Default::default()
        }
    );
}

fn create_ball_joints(commands: &mut Commands, num: usize) {
    let rad = 0.05;
    let track_width = 2.5;
    let track_depth = 0.05;
    let track_drop = 1.25;
    let track_lead = 3.0;
    let track_angle = 0.1;
    let shift = track_width / (num as f32 + 2.0);

    let mut body_entities = Vec::new();
    let mut color = 0;

    for index in 0..5 {
        let block_body = RigidBodyBundle {
            body_type: RigidBodyType::Static,
            position: (Vec3::new(0.0, -track_drop - track_drop * index as f32,
                                 if index % 2 == 0 { 0.0 } else { track_lead }),
                       Quat::from_rotation_x(
                           if index % 2 == 0 { track_angle } else { -track_angle })).into(),

            ..Default::default()
        };
        let block_collider = ColliderBundle {
            shape: ColliderShape::cuboid(track_width, track_depth, track_width),
            ..Default::default()
        };
        commands.spawn_bundle(
            block_collider
        ).insert_bundle(
            block_body
        ).insert(
            ColliderDebugRender::with_id(5)
        )
            .insert(
                ColliderPositionSync::Discrete);

        for railing_x in [-track_width / 1.0, track_width / 1.0].iter() {
            commands.spawn_bundle(
                RigidBodyBundle {
                    body_type: RigidBodyType::Static,

                    position: (Vec3::new(*railing_x, -track_drop - track_drop * index as f32,
                                         if index % 2 == 0 { 0.0 } else { track_lead }),
                               Quat::from_rotation_x(
                                   if index % 2 == 0 { track_angle } else { -track_angle })).into(),
                    ..Default::default()
                }
            ).insert_bundle(
                ColliderBundle {
                    shape: ColliderShape::cuboid(8.0 * track_depth, 8.0 * track_depth, track_width),
                    ..Default::default()
                }
            ).insert(
                ColliderDebugRender::with_id(4)
            )
                .insert(
                    ColliderPositionSync::Discrete);
        }
    }

    for k in 0..num {
        for i in 0..num {
            let fk = k as f32;
            let fi = i as f32;
            color += 1;

            let body_type = if i == 0 && (k % 4 == 0 || k == num - 1) {
                RigidBodyType::Static
            } else {
                RigidBodyType::Dynamic
            };

            let rigid_body = RigidBodyBundle {
                body_type,
                position: [-track_width / 2.0 + fk * shift + fi * 0.001, fi * shift, 0.0].into(),
                ..Default::default()
            };

            let collider = if (i + k) % 6 != 0 {
                ColliderBundle {
                    shape: ColliderShape::ball(rad),
                    ..Default::default()
                }
            } else {
                ColliderBundle {
                    shape: ColliderShape::cuboid(rad / 2.0, rad / 2.0, rad / 2.0),
                    ..Default::default()
                }
            };

            let child_entity = commands
                .spawn_bundle(collider)
                .insert_bundle(rigid_body)
                .insert(ColliderDebugRender::with_id(color))
                .insert(ColliderPositionSync::Discrete)
                .id();

            body_entities.push(child_entity);
        }
    }
}

fn update_text_system(mut query: Query<(&mut Text, &mut Transform)>, balls: Query<&ColliderPosition>, camera: Query<(&GlobalTransform, &Camera), With<PerspectiveProjection>>,
                      window: Res<Windows>) {
    let cam = camera.single().unwrap();

    //let t = PerspectiveCameraBundle {}

    for ((mut text, mut text_transform), ball) in query.iter_mut().zip(balls.iter()) {

        text_transform.translation = Vec3::from(
            (cam.1.world_to_screen(&window, cam.0, Vec3::from(ball.translation)).unwrap(), 1.0));
        text.sections[0].value = "0.5".to_string();
    }
}

pub fn setup_physics(mut commands: Commands) {
    create_ball_joints(&mut commands, 20);
}