Struct rin::scene::scene::SceneBuilder

pub struct SceneBuilder { /* fields omitted */ }

Creates a new scene from a renderer and an events dispatcher

Also register the most basic components that are usually always used on any mutiny application and the main systems.

Implementations

impl SceneBuilder

pub fn new(events_poll: EventsPoll) -> SceneBuilder

pub fn add_resource<T>(&mut self, resource: T) where
    T: 'static + Send, 

pub fn add_resource_thread_local<T>(&mut self, resource: T) where
    T: 'static, 

pub fn add_resource_as_trait<T, U, F, FMut>(&mut self, resource: (T, F, FMut)) where
    T: 'static + Send,
    F: Fn(&T) -> &U + 'static,
    U: 'static + Send + ?Sized,
    FMut: Fn(&mut T) -> &mut U + 'static, 

pub fn window_events<S>(&mut self, events: S) -> &mut SceneBuilder where
    S: StreamExt<'static, Event>, 

pub fn update_dynamic_transformations_only(&mut self) -> &mut SceneBuilder

pub fn update_all_transformations(&mut self) -> &mut SceneBuilder

pub fn add_bundle<B>(&mut self, bundle: B) -> bool where
    B: 'static + Bundle, 

pub fn add_bundle_to_group<B>(&mut self, bundle: B, group: &str) -> bool where
    B: 'static + Bundle, 

pub fn add_system<S>(&mut self, system: S) where
    S: System + 'static, 

Adds a Send System that will be run in the order it was added.

Send systems will run in parallel with other Send systems and with thread local systems added in between barriers.

pub fn add_system_thread_local<S>(&mut self, system: S) where
    S: SystemThreadLocal + 'static, 

Adds a non Send System that will be run in the order it was added.

SystemThreadLocal will always run in the main thread but can run in parallel with Send systems.

pub fn add_creation_system<S>(&mut self, system: S) where
    S: CreationSystem + 'static, 

Adds a CreationSystem that will be run in the order it was added.

CreationSystems run alone with no other system running in parallel.

pub fn add_debug_system<S>(&mut self, system: S) where
    S: SystemDebug + 'static, 

Adds a SystemDebug that will be run in the order it was added.

SystemDebug run alone with no other system running in parallel.

pub fn add_system_with<S>(&mut self, system: S) -> Builder<'_, '_, S> where
    S: System + 'static, 

Adds a Send System with a Builder that allows to set some of the system properties like the name it’ll show up with in stats, or run conditions.

Send systems will run in parallel with other Send systems and with thread local systems added in between barriers.

pub fn add_system_thread_local_with<S>(
    &mut self,
    system: S
) -> BuilderThreadLocal<'_, '_, S> where
    S: SystemThreadLocal + 'static, 

Adds a SystemThreadLocal with a Builder that allows to set some of the system properties like the name it’ll show up with in stats, if it has gpu stats or it’s run conditions.

SystemThreadLocal will always run in the main thread but can run in parallel with Send systems.

pub fn add_creation_system_with<S>(
    &mut self,
    system: S
) -> BuilderCreation<'_, '_, S> where
    S: CreationSystem + 'static, 

Adds a CreationSystem with a Builder that allows to set some of the system properties like the name it’ll show up with in stats, if it has gpu stats or it’s run conditions.

CreationSystems run alone with no other system running in parallel.

pub fn add_update_system<U>(&mut self, system: U) where
    U: UpdateSystem + 'static, 

pub fn add_update_system_thread_local<U>(&mut self, system: U) where
    U: UpdateSystemThreadLocal + 'static, 

pub fn add_render_system<R>(&mut self, system: R) where
    R: RenderSystem + 'static, 

pub fn add_barrier<B>(&mut self) where
    B: 'static + Barrier, 

Delimits all the systems that will run in parallel.

Only systems between barriers (or creation and debug systems) will run in parallel with each other.

Barriers allow to create groups of systems that run in parallel including thread local systems that run one by one in the main thread but in parallel with Send systems.

pub fn send_stream<T>(&mut self) -> (Sender<T>, Stream<'static, T>) where
    T: 'static + Clone + Debug, 

Creates an mpsc:::Sender, events::Stream pair

When sending data through the mpsc sender the stream will be notified

This allows to use the sender from any thread while using a stream that can be used from ringui or anything else that requires a stream or derivates like Property or similar

pub fn with_renderer<R>(self, renderer: R) -> SceneBuilderWithRenderer where
    R: 'static + RendererBundle,