Struct Components

pub struct Components<C: Component> { /* private fields */ }

Implementations

impl<C: Component> Components<C>

pub fn new() -> Self

pub fn iter(&self) -> Iter<'_, C>

pub fn iter_mut(&mut self) -> IterMut<'_, C>

pub fn insert(&mut self, e: Entity, c: C)

Examples found in repository

examples/run/main.rs (line 59)

    fn build(&self, scene: &mut matrix_engine::engine::scene::Scene<CustomEvents>) {
        let mut latest = Instant::now();
        let mut v = Vec::<f32>::new();
        let mut latest_second = Instant::now();
        scene.add_send_system(
            move |(events, write_events, id): &mut (
                ReadE<CustomEvents>,
                WriteE<CustomEvents>,
                ReadSystemID,
            )| {
                let now = Instant::now();

                v.push(1.0 / (now - latest).as_secs_f32());

                if (now - latest_second).as_secs() > 0 {
                    let fps = v.iter().sum::<f32>() / v.len() as f32;
                    println!("fps: {:10.5}, {:10.5}", fps, 1.0 / fps);
                    latest_second = now;
                }
                latest = now;

                if events.is_just_pressed(KeyCode::KeyW) {
                    write_events.send(MatrixEvent::DestroySystem(**id)).unwrap();
                }
            },
        );
        scene.add_send_startup_system(
            |render_objs: &mut WriteC<RenderObject>,
             transforms: &mut WriteC<Transform>,
             camera: &mut WriteR<Camera, CustomEvents>| {
                for i in 0..100 {
                    for y in 0..100 {
                        for z in 0..100 {
                            let e = Entity::new();
                            render_objs
                                .insert(e, RenderObject::new(Cube, "./img.jpg".to_string()));
                            transforms.insert(
                                e,
                                Transform::new_position(Vector3::new(
                                    5.0 * i as f32,
                                    5.0 * y as f32,
                                    5.0 * z as f32,
                                )),
                            );
                        }
                    }
                }

                camera.insert_and_notify(Camera {
                    eye: Vector3::new(0.0, 0.0, -1.),
                    dir: Vector3::new(1., 0., 0.),
                    up: Vector3::new(0., 1., 0.),
                    aspect: 1.,
                    fovy: PI / 4.,
                    znear: 0.1,
                    zfar: 1000.,
                });
            },
        );

        let mut yaw = 0.0; // Horizontal rotation around the y-axis
        let mut pitch = 0.0; // Vertical rotation
        scene.add_send_system(
            move |camera: &mut WriteR<Camera, CustomEvents>, events: &mut ReadE<CustomEvents>| {
                if let Some(camera) = camera.get_mut() {
                    let dt = events.dt();
                    let move_speed = dt * 3.;
                    let rotation_speed = dt * camera.fovy / PI;

                    // Get forward (z-axis), right (x-axis), and up (y-axis) direction vectors
                    let forward = camera.dir.normalized();
                    let right = forward.cross(&Vector3::unit_y()).normalized();
                    let up = Vector3::unit_y();

                    if events.is_pressed(KeyCode::KeyW) {
                        camera.eye += &forward * move_speed;
                    }
                    if events.is_pressed(KeyCode::KeyS) {
                        camera.eye -= &forward * move_speed;
                    }
                    if events.is_pressed(KeyCode::KeyA) {
                        camera.eye -= &right * move_speed;
                    }
                    if events.is_pressed(KeyCode::KeyD) {
                        camera.eye += &right * move_speed;
                    }
                    if events.is_pressed(KeyCode::Space) {
                        camera.eye += &up * move_speed;
                    }
                    if events.is_pressed(KeyCode::ControlLeft) {
                        camera.eye -= &up * move_speed;
                    }

                    if events.is_pressed(KeyCode::ArrowLeft) {
                        yaw -= rotation_speed; // Rotate left
                    }
                    if events.is_pressed(KeyCode::ArrowRight) {
                        yaw += rotation_speed; // Rotate right
                    }
                    if events.is_pressed(KeyCode::ArrowUp) {
                        pitch += rotation_speed; // Look up
                    }
                    if events.is_pressed(KeyCode::ArrowDown) {
                        pitch -= rotation_speed; // Look down
                    }

                    if events.is_just_pressed(KeyCode::KeyE) {
                        camera.fovy *= 2.0;
                    }
                    if events.is_just_pressed(KeyCode::KeyQ) {
                        camera.fovy /= 2.0;
                    }

                    // Update the camera's direction (yaw and pitch)
                    let (sin_yaw, cos_yaw) = yaw.sin_cos();
                    let (sin_pitch, cos_pitch) = pitch.sin_cos();

                    // Calculate the new forward direction after applying yaw and pitch
                    let new_forward =
                        Vector3::new(cos_pitch * cos_yaw, sin_pitch, cos_pitch * sin_yaw);

                    camera.dir = new_forward.normalized();
                }
            },
        );
    }

pub fn get(&self, e: &Entity) -> Option<&C>

pub fn get_mut(&mut self, e: &Entity) -> Option<&mut C>

Trait Implementations

impl<C: Debug + Component> Debug for Components<C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C: Component> Default for Components<C>

fn default() -> Self

Returns the “default value” for a type.