Struct rin::scene::Scene[−][src]

pub struct Scene { /* fields omitted */ }

The scene is the container for everything else in mutiny

Through it you can create other elements like models, lights… or add systems that will update those elements over time

To create a scene you need to first create a renderer and an events dispatcher. The scene will take ownership of them and run them later.

Once you have a scene you can use it to create all the entities in the application and their components.

Implementations

`impl Scene`[src]

`pub fn window(&self) -> ReadGuardRef<'_, Window>`[src]

`pub fn window_mut(&self) -> WriteGuardRef<'_, Window, ()>`[src]

`pub fn gl_renderer(&self) -> ReadGuardRef<'_, Renderer<'static, Screen>>`[src]

`pub fn gl_renderer_mut( &self ) -> WriteGuardRef<'_, Renderer<'static, Screen>, ()>`[src]

`pub fn render_surface(&self) -> Option<ReadGuardRef<'_, ScreenRenderBuffer>>`[src]

`pub fn viewport(&self) -> Rect<i32>`[src]

`pub fn event_stream(&mut self) -> StreamRc<'static, Event>`[src]

`pub fn priority_stream(&mut self, priority: usize) -> StreamRc<'static, Event>`[src]

`pub fn set_non_attended( &mut self, priority: usize, stream: StreamRc<'static, Event> )`[src]

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

`pub fn events(&self) -> WriteGuardRef<'_, EventsDispatcher, ()>`[src]

`pub fn set_camera<C>(&mut self, camera: C) where C: 'static + CameraExt + Send,` [src]

Add a camera to the scene

Right now there can only be one camera in the scene and adding a new one will replace the old one

`pub fn register_vertex_type<T>(&mut self) where T: 'static + VertexFormat + Send + Clone + Copy + Debug,` [src]

Explicitly register a vertex type

Vertex types are usually registered the first time we add a Geometry of that vertex type to the scene using register_mesh but in some special cases we might want to add geometries directly to an entity. In those cases it’s necesary to call this method in order to register the corresponding components and create the renderer systems that allow to render this type of geometry

`pub fn register_builder<'a, B>(&mut self) where B: Builder<'a>,` [src]

Register a mutiny Builder

It’s only necesary to call this method if a builder type is to be used from a creation system

`pub fn add<'a, B>(&'a mut self, settings: >::Settings) -> B where B: Builder<'a>,` [src]

Add an element to the scene through it’s Builder and settings

Some modules implement the Builder trait and specify a settings struct that allows to add them to the scene using this method.

For example to add load a blender file you can use:

scene.add::<mutiny::blender::Blender>()
    .load("file_path.blend")
    .unwrap();

`pub fn add_model(&mut self, name: &str) -> ModelBuilder<'_>`[src]

Add a new model to the scene

This method returns a ModelBuilder that allows to set the geometry, transformation and other components of the model.

To add geometry and materials to the model they have to be registered in the scene first and the handle that we get when registering them is really what use to set that geometry or material to a model, instead of the geometry and material themselves

This allows renderers to optimize drawing by instancing models with the same geometry and to batch geometries with the same properties

`pub fn add_child_model( &mut self, name: &str, parent: Entity ) -> ModelBuilder<'_>`[src]

Add a new model to the scene, as child of an exisiting entity

This method returns a ModelBuilder that allows to set the geometry, transformation and other components of the model.

To add geometry and materials to the model they have to be registered in the scene first and the handle that we get when registering them is really what use to set that geometry or material to a model, instead of the geometry and material themselves

This allows renderers to optimize drawing by instancing models with the same geometry and to batch geometries with the same properties

The transformation of this model will be a child of the entity passed as parameter

`pub fn add_empty(&mut self, name: &str) -> EmptyBuilder<'_>`[src]

Add an empty node to the scene

Other objects like models, lights… can be created as children of an empty

`pub fn add_child_empty( &mut self, name: &str, parent: Entity ) -> EmptyBuilder<'_>`[src]

Add an empty node to the scene parented to another entity with a Transorfmation

Other objects like models, lights… can be created as children of an empty

`pub fn register_mesh<T>(&mut self, geom: Mesh<T>) -> GeometryRef where T: 'static + VertexFormat + Send + Clone + Copy + Debug,` [src]

Adds a mesh to the system and returns a handle to the geometry

The returned GeometryRef can be used as geometry for models.

`pub fn register_named_mesh<T>( &mut self, geom: Mesh<T>, name: &str ) -> GeometryRef where T: 'static + VertexFormat + Send + Clone + Copy + Debug,` [src]

Adds a mesh with a name to the system and returns a handle to the geometry

The returned GeometryRef can be used as geometry for models.

Names are mostly useful for debugging and not considered an ID of the model