spottedcat 0.6.2

Rusty SpottedCat simple game engine
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
79
80
81
82
83
84
85
86
87
88
89
90
91

use spottedcat::{Context, DrawOption3D, Model, Spot, WindowConfig};
use std::time::Duration;

struct InstancingTest {
    cube: Model,
    transforms: Vec<[[f32; 4]; 4]>,
    time: f32,
}

impl Spot for InstancingTest {
    fn initialize(ctx: &mut Context) -> Self {
        let cube = Model::cube(ctx, 0.5).unwrap();

        let mut transforms = Vec::with_capacity(10000);
        for x in -50..50 {
            for y in -50..50 {
                // Initial baseline transforms
                let px = x as f32 * 1.5;
                let py = y as f32 * 1.5;
                let pz = (x as f32 * 0.1).sin() * 2.0 + (y as f32 * 0.1).cos() * 2.0;

                transforms.push([
                    [1.0, 0.0, 0.0, 0.0],
                    [0.0, 1.0, 0.0, 0.0],
                    [0.0, 0.0, 1.0, 0.0],
                    [px, py, pz, 1.0],
                ]);
            }
        }

        Self {
            cube,
            transforms,
            time: 0.0,
        }
    }

    fn update(&mut self, _ctx: &mut Context, dt: Duration) {
        let dt_secs = dt.as_secs_f32();
        self.time += dt_secs;

        // Dynamically update 10,000 matrices on CPU as an extreme test
        let mut idx = 0;
        for x in -50..50 {
            for y in -50..50 {
                let px = x as f32 * 1.5;
                let py = y as f32 * 1.5;
                let dist = (px * px + py * py).sqrt();
                let pz = (dist - self.time * 5.0).sin() * 2.0;

                // Rotation
                let rot = self.time + (x as f32 * y as f32 * 0.01);
                let cx = rot.cos();
                let sx = rot.sin();

                self.transforms[idx] = [
                    [cx, 0.0, -sx, 0.0],
                    [0.0, 1.0, 0.0, 0.0],
                    [sx, 0.0, cx, 0.0],
                    [px, py, pz, 1.0],
                ];
                idx += 1;
            }
        }
    }

    fn draw(&mut self, ctx: &mut Context) {
        // Draw 10000 cubes in 1 call!
        self.cube.draw_instanced(
            ctx,
            DrawOption3D::default()
                .with_position([0.0, -10.0, -80.0])
                .with_rotation([1.0, self.time * 0.1, 0.0]),
            &self.transforms,
        );
    }

    fn remove(&mut self, _ctx: &mut Context) {}
}

fn main() {
    unsafe {
        std::env::set_var("SPOT_PROFILE_RENDER", "1");
    } // Print render stats
    spottedcat::run::<InstancingTest>(WindowConfig {
        title: "Instancing Test (10000 Cubes)".to_string(),
        width: spottedcat::Pt::from(1280.0),
        height: spottedcat::Pt::from(720.0),
        ..Default::default()
    });
}