Struct Canvas 

pub struct Canvas<'res, T: Timeline<'res>, C: Camera> {
    pub size: (u32, u32),
    pub camera: C,
    pub on_window_event: Box<dyn FnMut(&ActiveEventLoop, &WindowEvent, &mut C)>,
    pub timeline: T,
    pub playhead: f32,
    pub scene: Rc<RefCell<Scene>>,
    pub mesh_pool: Rc<RefCell<MeshPool>>,
    pub update_flags: HashMap<MraphicsID, bool>,
    pub clear_color: Color<f64>,
    /* private fields */
}

Fields

size: (u32, u32)

camera: C

on_window_event: Box<dyn FnMut(&ActiveEventLoop, &WindowEvent, &mut C)>

timeline: T

playhead: f32

scene: Rc<RefCell<Scene>>

The underlying scene for this canvas. Wrapped in Rc to enable shared ownership across timeline actions.

mesh_pool: Rc<RefCell<MeshPool>>

Manages all meshes of this canvas. Wrapped in Rc to enable shared ownership across timeline actions.

update_flags: HashMap<MraphicsID, bool>

Tracks which meshes need to be updated.

The Canvas automatically manages these flags. You can manually set a flag to true to force a mesh update, though this is rarely needed.

clear_color: Color<f64>

Implementations

impl<'res, T: Timeline<'res>, C: Camera> Canvas<'res, T, C>

pub fn new(timeline: T, camera: C) -> Self

pub fn queue_animation<Ani: Animation<'res>>( &mut self, animation: Ani, duration: &Duration, )

Queues a new animation and advances the playhead by its duration.

pub fn advance_playhead(&mut self, step: &Duration)

Advanced the playhead manually.

pub fn add_mesh<Mesh: MeshLike + 'static>( &mut self, mesh: Mesh, ) -> MeshHandle<Mesh>

pub fn update_meshes(&mut self)

Updates all meshes marked as needing update and clears their dirty flags.

This method processes all meshes with true in Self::update_flags, performs necessary updates (triggers MeshLike::update and then [InstanceUpdater::update_instance]) and then resets their flags to false.

This is automatically called by Canvas during rendering, but you can manually invoke it to force immediate updates when needed.

pub fn mark_for_update<Mesh: MeshLike + 'static>( &mut self, mesh_handle: &MeshHandle<Mesh>, )

Marks a mesh for update.

pub fn with_instance<F: FnMut(Option<&mut RenderInstance>), Mesh: MeshLike>( &self, mesh_handle: &MeshHandle<Mesh>, closure: F, )

pub fn with_instance_unchecked<F: FnMut(&mut RenderInstance), Mesh: MeshLike>( &self, mesh_handle: &MeshHandle<Mesh>, closure: F, )

pub fn with_mesh<Mesh: MeshLike + 'static, F: FnMut(Option<&mut Mesh>)>( &mut self, mesh_handle: &MeshHandle<Mesh>, closure: F, )

pub fn with_mesh_unchecked<Mesh: MeshLike + 'static, F: FnMut(&mut Mesh)>( &mut self, mesh_handle: &MeshHandle<Mesh>, closure: F, )

pub fn resize(&mut self, size: (u32, u32))

pub fn run(&mut self)

pub fn snapshot(&mut self, time: f32, path: &str)

pub fn render_offscreen(&mut self)

Trait Implementations

impl<'res, T: Timeline<'res>, C: Camera> ApplicationHandler for Canvas<'res, T, C>

fn resumed(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has been resumed.

fn window_event( &mut self, event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent, )

Emitted when the OS sends an event to a winit window.

fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause)

Emitted when new events arrive from the OS to be processed.

fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T)

Emitted when an event is sent from EventLoopProxy::send_event.

fn device_event( &mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent, )

Emitted when the OS sends an event to a device.

fn about_to_wait(&mut self, event_loop: &ActiveEventLoop)

Emitted when the event loop is about to block and wait for new events.

fn suspended(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has been suspended.

fn exiting(&mut self, event_loop: &ActiveEventLoop)

Emitted when the event loop is being shut down.

fn memory_warning(&mut self, event_loop: &ActiveEventLoop)

Emitted when the application has received a memory warning.