spottedcat 0.9.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
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
119
120
121
122
123
124
125
126
127
128
129
130

use spottedcat::{Context, DrawOption3D, Model, Pt, Spot, WindowConfig};

struct ModelTest {
    cube: Model,
    axis_x: Model,
    axis_y: Model,
    axis_z: Model,
    rotation: f32,
}

impl Spot for ModelTest {
    fn initialize(ctx: &mut Context) -> Self {
        spottedcat::set_camera_pos(ctx, [0.0, 2.0, 8.0]);
        spottedcat::set_camera_target(ctx, 0.0, 0.0, 0.0);
        spottedcat::set_camera_up(ctx, 0.0, 1.0, 0.0);
        spottedcat::set_camera_fovy(ctx, 45.0);

        // Create a simple 2x2 texture
        let rgba = vec![
            255, 0, 0, 255, // Red
            0, 255, 0, 255, // Green
            0, 0, 255, 255, // Blue
            255, 255, 0, 255, // Yellow
        ];
        let texture = spottedcat::Image::new(ctx, Pt::from(2.0), Pt::from(2.0), &rgba).unwrap();
        let axis_x_tex =
            spottedcat::Image::new(ctx, Pt::from(1.0), Pt::from(1.0), &[255, 64, 64, 255]).unwrap();
        let axis_y_tex =
            spottedcat::Image::new(ctx, Pt::from(1.0), Pt::from(1.0), &[64, 255, 64, 255]).unwrap();
        let axis_z_tex =
            spottedcat::Image::new(ctx, Pt::from(1.0), Pt::from(1.0), &[64, 128, 255, 255])
                .unwrap();

        // Create a 3D cube model and apply the texture
        let cube = spottedcat::model::create_cube(ctx, 1.0)
            .unwrap()
            .with_material(texture);
        let axis_x = spottedcat::model::create_cube(ctx, 1.0)
            .unwrap()
            .with_material(axis_x_tex);
        let axis_y = spottedcat::model::create_cube(ctx, 1.0)
            .unwrap()
            .with_material(axis_y_tex);
        let axis_z = spottedcat::model::create_cube(ctx, 1.0)
            .unwrap()
            .with_material(axis_z_tex);

        Self {
            cube,
            axis_x,
            axis_y,
            axis_z,
            rotation: 0.0,
        }
    }

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

        // Camera control demo
        let mut pos = spottedcat::camera_position(ctx);
        if spottedcat::key_down(ctx, spottedcat::Key::W) {
            pos[2] -= 5.0 * dt_secs;
        }
        if spottedcat::key_down(ctx, spottedcat::Key::S) {
            pos[2] += 5.0 * dt_secs;
        }
        if spottedcat::key_down(ctx, spottedcat::Key::A) {
            pos[0] -= 5.0 * dt_secs;
        }
        if spottedcat::key_down(ctx, spottedcat::Key::D) {
            pos[0] += 5.0 * dt_secs;
        }
        spottedcat::set_camera_pos(ctx, pos);

        // FOV control demo (using Q/E)
        static mut CURRENT_FOV: f32 = 45.0;
        unsafe {
            if spottedcat::key_down(ctx, spottedcat::Key::Q) {
                CURRENT_FOV = (CURRENT_FOV - 30.0 * dt_secs).max(10.0);
                spottedcat::set_camera_fovy(ctx, CURRENT_FOV);
            }
            if spottedcat::key_down(ctx, spottedcat::Key::E) {
                CURRENT_FOV = (CURRENT_FOV + 30.0 * dt_secs).min(120.0);
                spottedcat::set_camera_fovy(ctx, CURRENT_FOV);
            }
        }
    }

    fn draw(&mut self, ctx: &mut Context, screen: spottedcat::Image) {
        // Draw the main cube at the origin.
        let cube_opts = DrawOption3D::default()
            .with_position([0.0, 0.0, 0.0])
            .with_rotation([self.rotation, self.rotation * 0.5, 0.0]);
        screen.draw(ctx, &self.cube, cube_opts);

        // Draw colored axes so front-face culling and orientation are easy to inspect.
        screen.draw(
            ctx,
            &self.axis_x,
            DrawOption3D::default()
                .with_position([1.3, 0.0, 0.0])
                .with_scale([2.2, 0.06, 0.06]),
        );
        screen.draw(
            ctx,
            &self.axis_y,
            DrawOption3D::default()
                .with_position([0.0, 1.3, 0.0])
                .with_scale([0.06, 2.2, 0.06]),
        );
        screen.draw(
            ctx,
            &self.axis_z,
            DrawOption3D::default()
                .with_position([0.0, 0.0, 1.3])
                .with_scale([0.06, 0.06, 2.2]),
        );
    }

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

fn main() {
    spottedcat::run::<ModelTest>(WindowConfig {
        title: "3D Model Test".to_string(),
        ..Default::default()
    });
}