Struct PluginContext

pub struct PluginContext<'a, 'b> {

    pub scenes: &'a mut SceneContainer,
    pub resource_manager: &'a ResourceManager,
    pub user_interfaces: &'a mut UiContainer,
    pub graphics_context: &'a mut GraphicsContext,
    pub dt: f32,
    pub lag: &'b mut f32,
    pub serialization_context: &'a Arc<SerializationContext>,
    pub widget_constructors: &'a Arc<WidgetConstructorContainer>,
    pub performance_statistics: &'a PerformanceStatistics,
    pub elapsed_time: f32,
    pub script_processor: &'a ScriptProcessor,
    pub async_scene_loader: &'a mut AsyncSceneLoader,
    pub window_target: Option<&'b EventLoopWindowTarget<()>>,
    pub task_pool: &'a mut TaskPoolHandler,
}

Contains plugin environment.

Fields

scenes: &'a mut SceneContainer

A reference to scene container of the engine. You can add new scenes from Plugin methods by using SceneContainer::add.

resource_manager: &'a ResourceManager

A reference to the resource manager, it can be used to load various resources and manage them. See ResourceManager docs for more info.

user_interfaces: &'a mut UiContainer

A reference to user interface container of the engine. The engine guarantees that there’s at least one user interface exists. Use context.user_interfaces.first()/first_mut() to get a reference to it.

graphics_context: &'a mut GraphicsContext

A reference to the graphics_context, it contains a reference to the window and the current renderer. It could be GraphicsContext::Uninitialized if your application is suspended (possible only on Android; it is safe to call GraphicsContext::as_initialized_ref or GraphicsContext::as_initialized_mut on every other platform).

dt: f32

The time (in seconds) that passed since last call of a method in which the context was passed. It has fixed value that is defined by a caller (in most cases it is Executor).

lag: &'b mut f32

A reference to time accumulator, that holds remaining amount of time that should be used to update a plugin. A caller splits lag into multiple sub-steps using dt and thus stabilizes update rate. The main use of this variable, is to be able to reset lag when you doing some heavy calculations in a your game loop (i.e. loading a new level) so the engine won’t try to “catch up” with all the time that was spent in heavy calculation.

serialization_context: &'a Arc<SerializationContext>

A reference to serialization context of the engine. See SerializationContext for more info.

widget_constructors: &'a Arc<WidgetConstructorContainer>

A reference to serialization context of the engine. See WidgetConstructorContainer for more info.

performance_statistics: &'a PerformanceStatistics

Performance statistics from the last frame.

elapsed_time: f32

Amount of time (in seconds) that passed from creation of the engine. Keep in mind, that this value is not guaranteed to match real time. A user can change delta time with which the engine “ticks” and this delta time affects elapsed time.

script_processor: &'a ScriptProcessor

Script processor is used to run script methods in a strict order.

async_scene_loader: &'a mut AsyncSceneLoader

Asynchronous scene loader. It is used to request scene loading. See AsyncSceneLoader docs for usage example.

window_target: Option<&'b EventLoopWindowTarget<()>>

Special field that associates main application event loop (not game loop) with OS-specific windows. It also can be used to alternate control flow of the application.

task_pool: &'a mut TaskPoolHandler

Task pool for asynchronous task management.