Ambient est un environnement d'exécution visant à simplifier la création de jeux multijoueurs et d'applications 3D hautes performances

Optimisé par WebAssembly, Rust et WebGPU

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
use ambient_api::{ 
    components::core::{ 
        game_objects::player_camera, 
        player::player, 
        primitives::cube, 
        rendering::color, 
        transform::{lookat_center, translation}, 
    }, 
    concepts::{make_perspective_infinite_reverse_camera, make_transformable}, 
    prelude::*, 
}; 
 
#[main] 
pub async fn main() -> EventResult { 
    Entity::new() 
        .with_merge(make_perspective_infinite_reverse_camera()) 
        .with_default(player_camera()) 
        .with(translation(), Vec3::ONE * 5.) 
        .with(lookat_center(), vec3(0., 0., 0.)) 
        .spawn(); 
 
    spawn_query(player()).bind(move |players| { 
        // For each player joining, spawn a random colored box somewhere 
        for _ in players { 
            Entity::new() 
                .with_merge(make_transformable()) 
                .with_default(cube()) 
                .with(translation(), rand::random()) 
                .with(color(), rand::random()) 
                .spawn(); 
        } 
    }); 
 
    EventOk 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
use ambient_api::{ 
    components::core::{ 
        ecs::ids, 
        game_objects::player_camera, 
        physics::{ 
            angular_velocity, box_collider, dynamic, linear_velocity, physics_controlled, 
            visualizing, 
        }, 
        prefab::prefab_from_url, 
        primitives::cube, 
        rendering::{cast_shadows, color}, 
        transform::{lookat_center, rotation, scale, translation}, 
    }, 
    concepts::{make_perspective_infinite_reverse_camera, make_transformable}, 
    physics::raycast, 
    prelude::*, 
}; 
  
#[main] 
pub async fn main() -> EventResult { 
    Entity::new() 
        .with_merge(make_perspective_infinite_reverse_camera()) 
        .with_default(player_camera()) 
        .with(translation(), vec3(5., 5., 4.)) 
        .with(lookat_center(), vec3(0., 0., 0.)) 
        .spawn(); 
  
    let cube = Entity::new() 
        .with_merge(make_transformable()) 
        .with_default(cube()) 
        .with_default(visualizing()) 
        .with(box_collider(), Vec3::ONE) 
        .with(dynamic(), true) 
        .with_default(physics_controlled()) 
        .with_default(cast_shadows()) 
        .with(translation(), vec3(0., 0., 5.)) 
        .with(scale(), vec3(0.5, 0.5, 0.5)) 
        .with(color(), Vec4::ONE) 
        .spawn(); 
  
    Entity::new() 
        .with_merge(make_transformable()) 
        .with(prefab_from_url(), asset_url("assets/Shape.glb").unwrap()) 
        .spawn(); 
  
    on(event::COLLISION, |c| { 
        // TODO: play a sound instead 
        println!("Bonk! {:?} collided", c.get(ids()).unwrap()); 
        EventOk 
    }); 
  
    on(event::FRAME, move |_| { 
        for hit in raycast(Vec3::Z * 20., -Vec3::Z) { 
            if hit.entity == cube { 
                println!("The raycast hit the cube: {hit:?}"); 
            } 
        } 
        EventOk 
    }); 
  
    loop { 
        let max_linear_velocity = 2.5; 
        let max_angular_velocity = 360.0f32.to_radians(); 
  
        sleep(5.).await; 
  
        let new_linear_velocity = (random::<Vec3>() - 0.5) * 2. * max_linear_velocity; 
        let new_angular_velocity = (random::<Vec3>() - 0.5) * 2. * max_angular_velocity; 
        println!("And again! Linear velocity: {new_linear_velocity:?} | Angular velocity: {new_angular_velocity:?}"); 
        entity::set_components( 
            cube, 
            Entity::new() 
                .with(translation(), vec3(0., 0., 5.)) 
                .with(rotation(), Quat::IDENTITY) 
                .with(linear_velocity(), new_linear_velocity) 
                .with(angular_velocity(), new_angular_velocity) 
                .with(color(), random::<Vec3>().extend(1.)), 
        ); 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
use ambient_api::{ 
    components::core::{ 
        game_objects::player_camera, 
        player::player, 
        prefab::prefab_from_url, 
        primitives::quad, 
        rendering::color, 
        transform::{lookat_center, scale, translation}, 
    }, 
    concepts::{make_perspective_infinite_reverse_camera, make_transformable}, 
    entity::{AnimationAction, AnimationController}, 
    player::KeyCode, 
    prelude::*, 
}; 
  
#[main] 
pub async fn main() -> EventResult { 
    Entity::new() 
        .with_merge(make_perspective_infinite_reverse_camera()) 
        .with_default(player_camera()) 
        .with(translation(), vec3(2., 2., 3.0)) 
        .with(lookat_center(), vec3(0., 0., 1.)) 
        .spawn(); 
  
    Entity::new() 
        .with_merge(make_transformable()) 
        .with_default(quad()) 
        .with(scale(), Vec3::ONE * 10.) 
        .with(color(), vec4(0.5, 0.5, 0.5, 1.)) 
        .spawn(); 
  
    let unit_id = Entity::new() 
        .with_merge(make_transformable()) 
        .with( 
            prefab_from_url(), 
            asset_url("assets/Peasant Man.fbx").unwrap(), 
        ) 
        .spawn(); 
  
    entity::set_animation_controller( 
        unit_id, 
        AnimationController { 
            actions: &[AnimationAction { 
                clip_url: &asset_url("assets/Capoeira.fbx/animations/mixamo.com.anim").unwrap(), 
                looping: true, 
                weight: 1., 
            }], 
            apply_base_pose: false, 
        }, 
    ); 
  
    query(player()).build().each_frame(move |players| { 
        for (player, _) in players { 
            let Some((delta, _)) = player::get_raw_input_delta(player) else { continue; }; 
  
            if delta.keys.contains(&KeyCode::Key1) { 
                entity::set_animation_controller( 
                    unit_id, 
                    AnimationController { 
                        actions: &[AnimationAction { 
                            clip_url: &asset_url( 
                                "assets/Robot Hip Hop Dance.fbx/animations/mixamo.com.anim", 
                            ) 
                            .unwrap(), 
                            looping: true, 
                            weight: 1., 
                        }], 
                        apply_base_pose: false, 
                    }, 
                ); 
            } 
  
            if delta.keys.contains(&KeyCode::Key2) { 
                entity::set_animation_controller( 
                    unit_id, 
                    AnimationController { 
                        actions: &[AnimationAction { 
                            clip_url: &asset_url("assets/Capoeira.fbx/animations/mixamo.com.anim") 
                                .unwrap(), 
                            looping: true, 
                            weight: 1., 
                        }], 
                        apply_base_pose: false, 
                    }, 
                ); 
            } 
  
            if delta.keys.contains(&KeyCode::Key3) { 
                entity::set_animation_controller( 
                    unit_id, 
                    AnimationController { 
                        actions: &[ 
                            AnimationAction { 
                                clip_url: &asset_url( 
                                    "assets/Robot Hip Hop Dance.fbx/animations/mixamo.com.anim", 
                                ) 
                                .unwrap(), 
                                looping: true, 
                                weight: 0.5, 
                            }, 
                            AnimationAction { 
                                clip_url: &asset_url( 
                                    "assets/Capoeira.fbx/animations/mixamo.com.anim", 
                                ) 
                                .unwrap(), 
                                looping: true, 
                                weight: 0.5, 
                            }, 
                        ], 
                        apply_base_pose: false, 
                    }, 
                ); 
            } 
        } 
    }); 
  
    EventOk 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
use ambient_api::{ 
    components::core::{ 
        self, 
        game_objects::player_camera, 
        player::player, 
        primitives::cube, 
        rendering::{color, outline}, 
        transform::{lookat_center, scale, translation}, 
    }, 
    concepts::{make_perspective_infinite_reverse_camera, make_transformable}, 
}; 
use ambient_api::{player::KeyCode, prelude::*}; 
use components::cell; 
use palette::{FromColor, Hsl, Srgb}; 
  
#[main] 
pub async fn main() -> EventResult { 
    Entity::new() 
        .with_merge(make_perspective_infinite_reverse_camera()) 
        .with_default(player_camera()) 
        .with(translation(), vec3(3., 3., 2.5)) 
        .with(lookat_center(), vec3(1.5, 1.5, 0.)) 
        .spawn(); 
  
    let mut cells = Vec::new(); 
    for y in 0..3 { 
        for x in 0..3 { 
            let id = Entity::new() 
                .with_merge(make_transformable()) 
                .with_default(cube()) 
                .with(translation(), vec3(x as f32, y as f32, 0.)) 
                .with(scale(), vec3(0.6, 0.6, 0.6)) 
                .with(color(), vec4(0.1, 0.1, 0.1, 1.)) 
                .spawn(); 
            cells.push(id); 
        } 
    } 
  
    spawn_query(core::player::player()).bind(|ids| { 
        for (id, _) in ids { 
            entity::add_component(id, cell(), 0); 
        } 
    }); 
  
    on(event::FRAME, move |_| { 
        for cell in &cells { 
            entity::remove_component(*cell, outline()); 
        } 
  
        let players = entity::get_all(player()); 
        let n_players = players.len(); 
        for (i, player) in players.into_iter().enumerate() { 
            let player_color = Srgb::from_color(Hsl::from_components(( 
                360. * i as f32 / n_players as f32, 
                1., 
                0.5, 
            ))); 
            let player_color = vec4(player_color.red, player_color.green, player_color.blue, 1.); 
            let cell = entity::get_component(player, components::cell()).unwrap(); 
            let Some((delta, _)) = player::get_raw_input_delta(player) else { continue; }; 
  
            let mut x = cell % 3; 
            let mut y = cell / 3; 
  
            let keys = &delta.keys; 
            if keys.contains(&KeyCode::Left) || keys.contains(&KeyCode::A) { 
                x = (x + 3 - 1) % 3; 
            } 
            if keys.contains(&KeyCode::Right) || keys.contains(&KeyCode::D) { 
                x = (x + 1) % 3; 
            } 
            if keys.contains(&KeyCode::Up) || keys.contains(&KeyCode::W) { 
                y = (y + 3 - 1) % 3; 
            } 
            if keys.contains(&KeyCode::Down) || keys.contains(&KeyCode::S) { 
                y = (y + 1) % 3; 
            } 
            let cell = y * 3 + x; 
            entity::add_component_if_required(cells[cell as usize], outline(), player_color); 
            entity::set_component(player, components::cell(), cell); 
  
            if delta.keys.contains(&KeyCode::Space) { 
                entity::set_component(cells[cell as usize], color(), player_color); 
            } 
        } 
        EventOk 
    }); 
  
    EventOk 
}