Struct Scene

pub struct Scene {
    pub graph: Graph,
    pub rendering_options: InheritableVariable<SceneRenderingOptions>,
    pub drawing_context: SceneDrawingContext,
    pub performance_statistics: PerformanceStatistics,
    pub enabled: InheritableVariable<bool>,
}

See module docs.

Fields

graph: Graph

Graph is main container for all scene nodes. It calculates global transforms for nodes, updates them and performs all other important work. See graph module docs for more info.

rendering_options: InheritableVariable<SceneRenderingOptions>

Rendering options of a scene. See SceneRenderingOptions docs for more info.

drawing_context: SceneDrawingContext

Drawing context for simple graphics.

performance_statistics: PerformanceStatistics

Performance statistics from last update call.

enabled: InheritableVariable<bool>

Whether the scene will be updated and rendered or not. Default is true. This flag allowing you to build a scene manager for your game. For example, you may have a scene for menu and one per level. Menu’s scene is persistent, however you don’t want it to be updated and renderer while you have a level loaded and playing a game. When you’re start playing, just set enabled flag to false for menu’s scene and when you need to open a menu - set it to true and set enabled flag to false for level’s scene.

Implementations

impl Scene

pub const GRAPH: &'static str = "graph"

pub const RENDERING_OPTIONS: &'static str = "rendering_options"

pub const ENABLED: &'static str = "enabled"

impl Scene

pub fn new() -> Self

Creates new scene with single root node.

Notes

This method differs from Default trait implementation! Scene::default() creates empty graph with no nodes.

pub fn resolve(&mut self)

Synchronizes the state of the scene with external resources.

pub fn collect_used_resources(&self) -> FxHashSet<UntypedResource>

Collects all resources used by the scene. It uses reflection to “scan” the contents of the scene, so if some fields marked with #[reflect(hidden)] attribute, then such field will be ignored!

pub fn update( &mut self, frame_size: Vector2<f32>, dt: f32, switches: GraphUpdateSwitches, )

Performs single update tick with given delta time from last frame. Internally it updates physics, animations, and each graph node. In most cases there is no need to call it directly, engine automatically updates all available scenes.

pub fn clone<F, Pre, Post>( &self, root: Handle<Node>, filter: &mut F, pre_process_callback: &mut Pre, post_process_callback: &mut Post, ) -> (Self, NodeHandleMap<Node>)

where F: FnMut(Handle<Node>, &Node) -> bool, Pre: FnMut(Handle<Node>, &mut Node), Post: FnMut(Handle<Node>, Handle<Node>, &mut Node),

Creates deep copy of a scene, filter predicate allows you to filter out nodes by your criteria.

pub fn clone_one_to_one(&self) -> (Self, NodeHandleMap<Node>)

Creates deep copy of a scene. Same as Self::clone, but does 1:1 cloning.

pub fn save(&mut self, region_name: &str, visitor: &mut Visitor) -> VisitResult

Tries to serialize the scene using the specified serializer. The serializer must be in write mode, otherwise serialization will fail. The region_name argument must be Scene (scene loader expects this value, you can use any other if you don’t plan to load scenes using the standard mechanism).. Keep in mind, that this method does not write anything to a file, instead it just fills in the serializer.

Example

use fyrox_resource::untyped::ResourceKind;
// Create a scene.
let mut scene = Scene::new();

MeshBuilder::new(BaseBuilder::new())
    .with_surfaces(vec![SurfaceBuilder::new(SurfaceResource::new_ok( ResourceKind::Embedded,
        SurfaceData::make_cube(Default::default()),
    ))
    .build()])
    .build(&mut scene.graph);

// Serialize the content.
let mut visitor = Visitor::new();
scene.save("Scene", &mut visitor).unwrap();

// Write the data to a file.
visitor.save_binary("path/to/a/scene.rgs").unwrap();

Trait Implementations

impl Debug for Scene

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Scene

fn default() -> Self

Returns the “default value” for a type.

impl Reflect for Scene

where Self: 'static, Graph: Reflect, InheritableVariable<SceneRenderingOptions>: Reflect, InheritableVariable<bool>: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<Self>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&dyn Any))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut dyn Any))

fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect))

fn fields(&self, func: &mut dyn FnMut(&[&dyn Reflect]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [&mut dyn Reflect]))

fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>))

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )