run/
main.rs

1use std::{f32::consts::PI, time::Instant};
2
3use matrix_engine::{
4    engine::{
5        component_iters::IntoWrapper,
6        entity::Entity,
7        events::MatrixEventable,
8        plugins::{window_plugin::WindowPlugin, Plugin},
9        query::{ReadC, ReadE, ReadSystemID, WriteC, WriteE, WriteR},
10        runtimes::single_threaded::SingleThreaded,
11        transform::Transform,
12        Engine, EngineArgs,
13    },
14    math::matrix::Vector3,
15    renderer::{
16        camera::Camera, pipelines::models::cube::Cube, render_object::RenderObject,
17        renderer_plugin::RendererPlugin,
18    },
19};
20use num_traits::Signed;
21use rayon::iter::{IntoParallelIterator, ParallelBridge, ParallelIterator};
22use winit::keyboard::KeyCode;
23
24struct Example1;
25
26impl<CustomEvents: MatrixEventable> Plugin<CustomEvents> for Example1 {
27    fn build(&self, scene: &mut matrix_engine::engine::scene::Scene<CustomEvents>) {
28        let mut latest = Instant::now();
29        let mut v = Vec::<f32>::new();
30        let mut latest_second = Instant::now();
31        scene.add_send_system(
32            move |(events, write_events, id): &mut (
33                ReadE<CustomEvents>,
34                WriteE<CustomEvents>,
35                ReadSystemID,
36            )| {
37                let now = Instant::now();
38
39                v.push(1.0 / (now - latest).as_secs_f32());
40
41                if (now - latest_second).as_secs() > 0 {
42                    let fps = v.iter().sum::<f32>() / v.len() as f32;
43                    println!("fps: {:10.5}, {:10.5}", fps, 1.0 / fps);
44                    latest_second = now;
45                }
46                latest = now;
47            },
48        );
49        scene.add_send_startup_system(
50            |render_objs: &mut WriteC<RenderObject>,
51             transforms: &mut WriteC<Transform>,
52             camera: &mut WriteR<Camera, CustomEvents>| {
53                for i in 0..100 {
54                    for y in 0..100 {
55                        for z in 0..10 {
56                            let e = Entity::new();
57                            render_objs.insert(e, RenderObject::new(Cube, "./img.jpg".to_string()));
58                            transforms.insert(
59                                e,
60                                Transform::new_position(Vector3::new(
61                                    5. * i as f32,
62                                    5. * y as f32,
63                                    5. * z as f32,
64                                )),
65                            );
66                        }
67                    }
68                }
69
70                camera.insert_and_notify(Camera {
71                    eye: Vector3::new(0.0, 0.0, -1.),
72                    dir: Vector3::new(1., 0., 0.),
73                    up: Vector3::new(0., 1., 0.),
74                    aspect: 1.,
75                    fovy: PI / 4.,
76                    znear: 0.1,
77                    zfar: 1000.,
78                });
79            },
80        );
81
82        let mut yaw: f32 = 0.0; // Horizontal rotation around the y-axis
83        let mut pitch: f32 = 0.0; // Vertical rotation
84        scene.add_send_system(
85            move |camera: &mut WriteR<Camera, CustomEvents>, events: &mut ReadE<CustomEvents>| {
86                if let Some(camera) = camera.get_mut() {
87                    let dt = events.dt();
88                    let move_speed = dt * 10.;
89                    let rotation_speed = 4. * dt * camera.fovy / PI;
90
91                    // Get forward (z-axis), right (x-axis), and up (y-axis) direction vectors
92                    let forward = camera.dir.normalized();
93                    let right = forward.cross(&Vector3::unit_y()).normalized();
94                    let up = right.cross(&forward);
95
96                    if events.keyboard().is_pressed(KeyCode::KeyW) {
97                        camera.eye += &forward * move_speed;
98                    }
99                    if events.keyboard().is_pressed(KeyCode::KeyS) {
100                        camera.eye -= &forward * move_speed;
101                    }
102                    if events.keyboard().is_pressed(KeyCode::KeyA) {
103                        camera.eye -= &right * move_speed;
104                    }
105                    if events.keyboard().is_pressed(KeyCode::KeyD) {
106                        camera.eye += &right * move_speed;
107                    }
108                    if events.keyboard().is_pressed(KeyCode::Space) {
109                        camera.eye += &up * move_speed;
110                    }
111                    if events.keyboard().is_pressed(KeyCode::ControlLeft) {
112                        camera.eye -= &up * move_speed;
113                    }
114
115                    match events.mouse_wheel_delta() {
116                        dx if dx != 0. => {
117                            camera.fovy *= if dx.is_positive() { 0.5 } else { 2. };
118                        }
119                        _ => (),
120                    }
121
122                    let (x, y) = events.mouse_dx();
123                    yaw += x * rotation_speed;
124                    pitch -= y * rotation_speed;
125
126                    // Update the camera's direction (yaw and pitch)
127                    let (sin_yaw, cos_yaw) = yaw.sin_cos();
128                    let (sin_pitch, cos_pitch) = pitch.sin_cos();
129
130                    // Calculate the new forward direction after applying yaw and pitch
131                    let new_forward =
132                        Vector3::new(cos_pitch * cos_yaw, sin_pitch, cos_pitch * sin_yaw);
133
134                    camera.dir = new_forward.normalized();
135                }
136            },
137        );
138        let mut is_on = false;
139        scene.add_send_system(
140            move |transforms: &mut WriteC<Transform>,
141                  obj: &mut ReadC<RenderObject>,
142                  events: &mut ReadE<CustomEvents>| {
143                if events.keyboard().is_just_pressed(KeyCode::KeyG) {
144                    is_on = !is_on;
145                    println!("started {}", is_on);
146                }
147                if is_on {
148                    let dt = events.dt();
149                    (transforms.iter_mut(), obj.iter())
150                        .into_wrapper()
151                        .for_each(|(_, (t, _))| {
152                            *t.rotation.x_mut() += dt * 5.;
153                            t.update_raw();
154                        });
155                }
156            },
157        );
158    }
159}
160
161fn main() {
162    let mut engine = <Engine>::new(EngineArgs::new(SingleThreaded, SingleThreaded));
163
164    engine.add_scene_plugin(WindowPlugin::new("hello example!"));
165
166    engine.add_scene_plugin(RendererPlugin);
167
168    engine.add_scene_plugin(Example1);
169
170    engine.run().unwrap();
171}
run/main.rs

run/
main.rs
