Struct AsyncSceneLoader

pub struct AsyncSceneLoader { /* private fields */ }

A helper that is used to load scenes asynchronously.

Examples

use fyrox_impl::{
    core::{color::Color, visitor::prelude::*, reflect::prelude::*, log::Log, pool::Handle},
    plugin::{Plugin, PluginContext},
    scene::Scene,
};
use std::path::Path;

#[derive(Visit, Reflect, Debug)]
struct MyGame {
    scene: Handle<Scene>,
}

impl MyGame {
    pub fn new(scene_path: Option<&str>, context: PluginContext) -> Self {
        context
            .async_scene_loader
            .request(scene_path.unwrap_or("data/scene.rgs"));

        Self {
            scene: Handle::NONE,
        }
    }
}

impl Plugin for MyGame {
    fn on_scene_begin_loading(&mut self, path: &Path, _context: &mut PluginContext) {
        Log::info(format!("{} scene has started loading.", path.display()));

        // Use this method if you need to so something when a scene started loading.
    }

    fn on_scene_loaded(
        &mut self,
        path: &Path,
        scene: Handle<Scene>,
        data: &[u8],
        context: &mut PluginContext,
    ) {
        // Optionally remove previous scene.
        if self.scene.is_some() {
            context.scenes.remove(self.scene);
        }

        // Remember new scene handle.
        self.scene = scene;

        Log::info(format!("{} scene was loaded!", path.display()));

        // Do something with a newly loaded scene.
        let scene_ref = &mut context.scenes[scene];

        scene_ref.rendering_options.ambient_lighting_color = Color::opaque(20, 20, 20);
    }
}

This example shows a typical usage of the loader, an instance of which is available in the plugin context. Game::new requests a new scene, which internally asks a resource manager to load the scene. Then, when the scene is fully loaded, the engine calls Plugin::on_scene_loaded method which allows you to do something with the newly loaded scene by taking a reference of it.

Implementations

impl AsyncSceneLoader

pub fn request<P: AsRef<Path>>(&mut self, path: P)

Requests a scene for loading as derived scene. See AsyncSceneLoader for usage example.

Raw vs Derived Scene

Derived scene means its nodes will derive their properties from the nodes from the source scene. Derived scene is useful for saved games - you can serialize your scene as usual and it will only contain a “difference” between the original scene and yours. To load the same scene as raw scene use Self::request_raw method.

Raw scene, on other hand, loads the scene as-is without any additional markings for the scene nodes. It could be useful to load saved games.

pub fn request_raw<P: AsRef<Path>>(&mut self, path: P)

Requests a scene for loading in raw mode. See Self::request docs for more info.