Struct FrameStarted 

pub struct FrameStarted {
    pub frame: u64,
    pub delta: f32,
    pub total_time: f64,
}

Emitted at the beginning of each frame.

This event provides timing information for the new frame. Use it to update game logic, animations, and physics with consistent delta time.

Timing Fields

• frame: Monotonically increasing frame counter (starts at 0)
• delta: Time elapsed since the previous frame in seconds
• total_time: Total time elapsed since engine start in seconds

Example

use goud_engine::core::events::FrameStarted;
use goud_engine::core::event::Events;

fn update_game(events: &Events<FrameStarted>) {
    let mut reader = events.reader();
    for event in reader.read() {
        // Update physics with delta time
        let velocity_change = 9.8 * event.delta; // gravity

        // Check if it's a new second for FPS display
        let prev_second = (event.total_time - event.delta as f64) as u64;
        let curr_second = event.total_time as u64;
        if curr_second > prev_second {
            println!("Frame {} - Total time: {:.1}s", event.frame, event.total_time);
        }
    }
}

Fields

frame: u64

The frame number (0-indexed, monotonically increasing).

delta: f32

Time elapsed since the previous frame, in seconds.

total_time: f64

Total time elapsed since engine start, in seconds.

Implementations

impl FrameStarted

pub fn new(frame: u64, delta: f32, total_time: f64) -> Self

Creates a new FrameStarted event.

pub fn fps(&self) -> f32

Returns the current frames per second based on delta time.

Returns f32::INFINITY if delta is 0 (to avoid division by zero).

Trait Implementations

impl Clone for FrameStarted

fn clone(&self) -> FrameStarted

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FrameStarted

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

Formats the value using the given formatter.

impl Default for FrameStarted

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for FrameStarted

fn eq(&self, other: &FrameStarted) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for FrameStarted

impl StructuralPartialEq for FrameStarted