Struct rin_scene::SceneBuilder [−][src]
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
[src]
impl SceneBuilder
[src]pub fn new(events_poll: EventsPoll) -> SceneBuilder
[src]
pub fn add_resource<T: Send + 'static>(&mut self, resource: T)
[src]
pub fn add_resource_thread_local<T: 'static>(&mut self, resource: T)
[src]
pub fn add_resource_as_trait<T, U: ?Sized, F, FMut>(
&mut self,
resource: (T, F, FMut)
) where
T: 'static + Send,
U: 'static + Send,
F: Fn(&T) -> &U + 'static,
FMut: Fn(&mut T) -> &mut U + 'static,
[src]
&mut self,
resource: (T, F, FMut)
) where
T: 'static + Send,
U: 'static + Send,
F: Fn(&T) -> &U + 'static,
FMut: Fn(&mut T) -> &mut U + 'static,
pub fn window_events<S>(&mut self, events: S) -> &mut SceneBuilder where
S: StreamExt<'static, Event>,
[src]
S: StreamExt<'static, Event>,
pub fn update_dynamic_transformations_only(&mut self) -> &mut SceneBuilder
[src]
pub fn update_all_transformations(&mut self) -> &mut SceneBuilder
[src]
pub fn add_bundle<B: Bundle + 'static>(&mut self, bundle: B) -> bool
[src]
pub fn add_bundle_to_group<B: Bundle + 'static>(
&mut self,
bundle: B,
group: &str
) -> bool
[src]
&mut self,
bundle: B,
group: &str
) -> bool
pub fn add_system<S>(&mut self, system: S) where
S: System + 'static,
[src]
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,
[src]
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,
[src]
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,
[src]
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) -> SystemBuilder<'_, '_, S> where
S: System + 'static,
[src]
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
) -> SystemBuilderThreadLocal<'_, '_, S> where
S: SystemThreadLocal + 'static,
[src]
&mut self,
system: S
) -> SystemBuilderThreadLocal<'_, '_, 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
) -> SystemBuilderCreation<'_, '_, S> where
S: CreationSystem + 'static,
[src]
&mut self,
system: S
) -> SystemBuilderCreation<'_, '_, 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,
[src]
U: UpdateSystem + 'static,
pub fn add_update_system_thread_local<U>(&mut self, system: U) where
U: UpdateSystemThreadLocal + 'static,
[src]
U: UpdateSystemThreadLocal + 'static,
pub fn add_render_system<R>(&mut self, system: R) where
R: RenderSystem + 'static,
[src]
R: RenderSystem + 'static,
pub fn add_barrier<B: Barrier + 'static>(&mut self)
[src]
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: Clone + Debug + 'static>(
&mut self
) -> (Sender<T>, Stream<'static, T>)
[src]
&mut self
) -> (Sender<T>, Stream<'static, T>)
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: RendererBundle + 'static>(
self,
renderer: R
) -> SceneBuilderWithRenderer
[src]
self,
renderer: R
) -> SceneBuilderWithRenderer
Auto Trait Implementations
impl !RefUnwindSafe for SceneBuilder
impl !Send for SceneBuilder
impl !Sync for SceneBuilder
impl Unpin for SceneBuilder
impl !UnwindSafe for SceneBuilder
Blanket Implementations
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]pub fn to_subset(&self) -> Option<SS>
[src]
pub fn is_in_subset(&self) -> bool
[src]
pub fn to_subset_unchecked(&self) -> SS
[src]
pub fn from_subset(element: &SS) -> SP
[src]
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]
impl<SS, SP> SupersetOf<SS> for SP where
SS: SubsetOf<SP>,
[src]