Struct Game 

pub struct Game {
    pub renderer: GPU,
    pub camera: Camera,
    pub events: Events,
    pub time: Time,
    pub window: Window,
    /* private fields */
}

The primary game object — aggregates the renderer, camera, window, events, timing, gamepad, and user-provided Runtime.

Create via Game::new and start via Game::run. All fields are public so that Runtime methods can access them directly.

Fields

renderer: GPU

camera: Camera

events: Events

time: Time

window: Window

Implementations

impl Game

pub fn new<R: Runtime + 'static>(runtime: R) -> OpticResult<Game>

Creates a new game with a 500×500 window and a crimson background.

Initialises:

• A GPU with VSync enabled and the given background colour
• A perspective Camera
• Gamepad input via gilrs
• The user’s Runtime implementation

Errors

Returns an error if the window, EGL/GLX surface, or gamepad cannot be initialised.

let game = Game::new(MyRuntime)?;

pub fn run<R: Runtime + 'static>(runtime: R)

Convenience entry point: creates a Game and runs the event loop.

On success exits with SUCCESS; on failure logs and exits with ERROR.

This is the simplest way to start an Optic application:

Game::run(MyRuntime);

pub fn exit(&mut self)

Signals the game loop to exit gracefully on the next frame.

After calling this, Runtime::end will be invoked and the process will exit with SUCCESS.

// In your runtime:
fn update(&mut self, game: &mut Game) {
    if game.events.key_down(VirtualKeyCode::Escape) {
        game.exit();
    }
}

Trait Implementations

impl ApplicationHandler for Game

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

Emitted when the application has been resumed.

fn window_event( &mut self, _el: &ActiveEventLoop, id: WindowId, event: WindowEvent, )

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

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

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

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 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.