Struct despero::ecs::event::EventHandler

pub struct EventHandler<E: Clone + Send + Sync> { /* private fields */ }

Implementations

impl<E: Clone + Send + Sync> EventHandler<E>

pub fn new() -> Self

pub fn send(&mut self, event: E)

pub fn read(&self) -> Option<E>

Examples found in repository

examples/pbr.rs (line 97)

fn process_scene(
    camera_world: SubWorld<(&Camera, &mut CameraConfiguration, &mut Transform)>,
    gui_events: Read<EventHandler<GuiContext>>,
    time: Read<Time>,
){
    if let Some(ctx) = gui_events.read() {
        if let Some(current) = ctx.pointer_hover_pos() {
            for (_, (_, mut conf, mut t)) in &mut camera_world.query::<(&Camera, &mut CameraConfiguration, &mut Transform)>(){       
                let (delta_x, delta_y) = {
                    if conf.latest_pos == Point2::origin() {
                        (0.0, 0.0)
                    } else {
                        (current.x - conf.latest_pos.x, current.y - conf.latest_pos.y)
                    }
                };
                
                conf.latest_pos = Point2::new(current.x, current.y);
                
                let local_x = t.local_x();
                
                let (tx, ty) = (conf.target_x.clone(), conf.target_y.clone());
                
                conf.target_x += delta_y * 0.0005 * time.delta_time().as_millis() as f32;
                conf.target_y -= delta_x * 0.0005 * time.delta_time().as_millis() as f32;
                
                conf.target_x = conf.target_x.clamp(to_radian(conf.limit.0), to_radian(conf.limit.1));

                t.rotation *= 
                    UnitQuaternion::from_axis_angle(&local_x, conf.target_x - tx) * 
                    UnitQuaternion::from_axis_angle(&Vector3::y_axis(), conf.target_y - ty);
            }
        }
    }
}

examples/serde.rs (line 73)

fn gui_system(
    gui_events: Read<EventHandler<GuiContext>>,
    world: Read<World>,
    mut cmd: Write<CommandBuffer>,
    mut asset_manager: Write<AssetManager>,
    model_world: SubWorld<Without<&mut Transform, &Camera>>,
    scene_world: SubWorld<(&u32, &Transform)>,
){
    for (_, mut t) in &mut model_world.query::<Without<&mut Transform, &Camera>>(){
        t.rotation *= UnitQuaternion::from_axis_angle(&Unit::new_normalize(Vector3::new(1.0, 1.0, 1.0)), to_radian(1.0));
    }
    
    if let Some(ctx) = gui_events.read() {
        
        gui::SidePanel::left("my_panel").show(&ctx, |ui| {
            ui.label("World (de-)serialization test");
            
            let mut ws = WorldSaver::new();
            
            if ui.button("Save world").clicked() {
                match ws.save("assets/world.ron", &world) {
                    Ok(()) => info!("World saved!"),
                    Err(e) => error!("World not saved: {:?}", e),
                };
            }
            
            if ui.button("Load world").clicked() {
                cmd.write(move |world: &mut World| {
                    match ws.load("assets/world.ron", world) {
                        Ok(()) => info!("World loaded!"),
                        Err(e) => error!("World not loaded: {:?}", e),
                    }
                })
            }
            
            ui.separator();
            
            ui.label("Serializable scene structure:");
            
            if ui.button("Save scene to file").clicked() {
                let scene = Scene {
                    assets: AssetManager::default(),
                    entities: vec![
                        SerializableEntity {
                            components: vec![
                                Arc::new(16u32),
                                Arc::new(Transform::default())
                            ],
                        },
                    ],
                };
                
                scene.save("assets/my_scene.ron").expect("Cannot save the scene");
            }
            
            if ui.button("Load scene from file").clicked() {
                let scene = Scene::load("assets/my_scene.ron").expect("Cannot load the scene");
                
                cmd.spawn_scene(scene, &mut asset_manager);
            }
            
            ui.separator();
            
            for (_, (_, _)) in &mut scene_world.query::<(&u32, &Transform)>(){
                ui.label("Scene successfully loaded!");
            }
            
        });
    }
}

pub fn clear(&mut self)