Struct DataList 

pub struct DataList<'a> { /* private fields */ }

list with additional entitiy packs from data aspect

Strongly recommends not use this ever, only for macroses!

Implementations

impl<'b> DataList<'b>

pub fn unwrap_entity<'a>(&'a self) -> &'a Entity

Examples found in repository

examples/render_gui_system.rs (line 75)

    fn process_d(&mut self, _ : &mut Entity, data : &mut DataList) {
        let render_data = data.unwrap_entity().get_component::<RenderData>();
        let _gui_data   = data.unwrap_entity().get_component::<HeavyGuiData>();
        render_data.facade.borrow_mut().draw_something("gui gui gui");
    }

examples/process_types.rs (line 35)

    fn process_d(&mut self, entity : &mut Entity, data : &mut DataList) {
        let cam = data.unwrap_entity();
        let cam = cam.get_component::<Camera>();

        let pos = entity.get_component::<Position>();
        let mesh = entity.get_component::<Mesh>();

        println!("{}, {}, seen from camera pos: {:?}", mesh.mesh, pos.pos[0], cam.pos);
    }
}

pub struct DeferRenderSystem;

impl System for DeferRenderSystem {
    fn aspect(&self) -> Aspect {
        Aspect::all2::<Position, Mesh>()
    }
    fn data_aspects(&self) -> Vec<Aspect> {
        vec![Aspect::all::<Camera>()]
    }
    fn process_all(&mut self,
                   entities : &mut Vec<&mut Entity>,
                   _   : &mut WorldHandle,
                   data   : &mut DataList) {
        entities.sort_by(|e1, e2| {
            let defer1 = e1.get_component::<DeferMesh>();
            let defer2 = e2.get_component::<DeferMesh>();
            defer1.order.cmp(&defer2.order)
        });
        for entity in entities {
            let cam = data.unwrap_entity();
            let cam = cam.get_component::<Camera>();

            let mesh = entity.get_component::<Mesh>();

            println!("{}, seen from camera pos: {:?}", mesh.mesh, cam.pos);
        }
    }

pub fn unwrap_entity_nth<'a>(&'a self, n: usize) -> &'a Entity

pub fn unwrap_entity_mut<'a>(&'a mut self) -> &'a mut Entity

pub fn unwrap_all<'a>(&'a mut self) -> &'a mut Vec<&'b mut Entity>

pub fn unwrap_nth<'a>(&'a self, n: usize) -> &'a Vec<&'b mut Entity>

pub fn unwrap_mut_nth<'a>(&'a mut self, n: usize) -> &'a mut Vec<&'b mut Entity>

pub fn new( entity_manager: &mut EntityManager<'_>, ids: &Vec<HashSet<i32>>, ) -> DataList<'b>