caper 0.13.0

Minimalist game framework
Documentation 
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

extern crate caper;
extern crate time;

use caper::game::*;
use caper::imgui::Ui;
use caper::input::Key;
use caper::types::{DefaultTag, MaterialBuilder, RenderItemBuilder, TransformBuilder};
use caper::utils::handle_fp_inputs;
use caper::utils::load_wavefront;

fn main() {
    let (mut game, event_loop) = Game::<DefaultTag>::new();

    // generate the instance positions
    let transforms = (0..200)
        .map(|i| {
            TransformBuilder::default()
                .pos(((i as f32 % 10f32) * 2f32, 0.0f32, (i as f32 / 10f32) * 2f32))
                .rot((0f32, 0f32, 0f32, 1f32))
                .scale((1f32, 1f32, 1f32))
                .build()
                .unwrap()
        })
        .collect::<Vec<_>>();

    // create a vector of render items
    game.add_render_item(
        RenderItemBuilder::default()
            .vertices(load_wavefront(include_bytes!("assets/sphere.obj")))
            .material(
                MaterialBuilder::default()
                    .shader_name("height")
                    .build()
                    .unwrap(),
            )
            .instance_transforms(transforms)
            .build()
            .unwrap(),
    );

    start_loop(event_loop, move |events| {
        // run the engine update
        game.update(
            |_: &Ui| {},
            |g: &mut Game<DefaultTag>| -> UpdateStatus {
                // update the first person inputs
                handle_fp_inputs(&mut g.input, &mut g.cams[0]);

                // update some items
                let update_time = time::precise_time_s();

                for t in g.get_render_item(0).instance_transforms.iter_mut() {
                    t.pos = (
                        t.pos.0,
                        ((t.pos.0 / 5f32).sin()
                            * (t.pos.2 / 5f32).cos()
                            * update_time.sin() as f32)
                            * 2f32,
                        t.pos.2,
                    );
                    t.scale = (
                        update_time.sin() as f32,
                        update_time.sin() as f32,
                        update_time.sin() as f32,
                    );
                }

                // quit
                if g.input.keys_down.contains(&Key::Escape) {
                    return UpdateStatus::Finish;
                }

                UpdateStatus::Continue
            },
            events,
        )
    });
}