Struct Engine

pub struct Engine {
    pub renderer: Renderer,
    pub event_loop_control_flow: ControlFlow,
    pub window: Window,
    pub objects: ObjectStorage,
    pub camera: CameraContainer,
    pub signals: SignalStorage,
    pub update_loop: Option<Box<dyn FnMut(&mut Renderer, &mut Window, &mut ObjectStorage, &WinitInputHelper, &mut CameraContainer, &mut SignalStorage) + 'static>>,
    pub input_events: WinitInputHelper,
}

The engine is the main starting point of using the Blue Engine. Everything that runs on Blue Engine will be under this struct. The structure of engine is monolithic, but the underlying data and the way it works is not. It gives a set of default data to work with, but also allow you to go beyond that and work as low level as you wish to.

You can also use the Engine to build you own custom structure the way you wish for it to be. Possibilities are endless!

To start using the Blue Engine, you can start by creating a new Engine like follows:

use blue_engine::header::{Engine, WindowDescriptor};

fn main() {
    let engine = Engine::new().expect("Couldn't create the engine");
}

The WindowDescriptor simply holds what features you would like for your window. If you are reading this on later version of the engine, you might be able to even run the engine in headless mode meaning there would not be a need for a window and the renders would come as image files.

If you so wish to have a window, you would need to start a window update loop. The update loop of window runs a frame every few millisecond, and gives you details of what is happening during this time, like input events. You can also modify existing parts of the engine during this update loop, such as changing camera to look differently, or creating a new object on the scene, or even changing window details!

The update loop is just a method of the Engine struct that have one argument which is a callback function.

[THE DATA HERE IS WORK IN PROGRESS!]

Fields

renderer: Renderer

The renderer does exactly what it is called. It works with the GPU to render frames according to the data you gave it.

event_loop_control_flow: ControlFlow

The event_loop handles the events of the window and inputs.

USED INTERNALLY

window: Window

The window handles everything about window and inputs. This includes ability to modify window and listen toinput devices for changes.

The window is not available before update_loop.

objects: ObjectStorage

The object system is a way to make it easier to work with the engine. Obviously you can work without it, but it’s for those who do not have the know-how, or wish to handle all the work of rendering data manually.

camera: CameraContainer

The camera handles the way the scene looks when rendered. You can modify everything there is to camera through this.

signals: SignalStorage

Handles all engine plugins

update_loop: Option<Box<dyn FnMut(&mut Renderer, &mut Window, &mut ObjectStorage, &WinitInputHelper, &mut CameraContainer, &mut SignalStorage) + 'static>>

holds the update_loop function

USED INTERNALLY

input_events: WinitInputHelper

input events

USED INTERNALLY

Implementations

impl Engine

pub fn new() -> Result<Self, Error>

Creates a new window in current thread using default settings.

pub fn new_config(settings: WindowDescriptor) -> Result<Self, Error>

Creates a new window in current thread using provided settings.

pub fn update_loop( &mut self, update_function: impl 'static + FnMut(&mut Renderer, &mut Window, &mut ObjectStorage, &WinitInputHelper, &mut CameraContainer, &mut SignalStorage), ) -> Result<(), Error>

Runs the block of code that you pass to it every frame. The update code is used to modify the engine on the fly thus creating interactive graphics and making things happy in the engine!

Renderer, window, vec of objects, events, and camera are passed to the update code.

Trait Implementations

impl ApplicationHandler for Engine

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

Emitted when the application has been resumed.

fn device_event( &mut self, _event_loop: &ActiveEventLoop, _device_id: DeviceId, event: DeviceEvent, )

Emitted when the OS sends an event to a device.

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

impl Send for Engine

impl Sync for Engine