Crate blue_engine

Blue Engine

Blue Engine is an easy to use, portable, and extendable/customizable graphics engine. Here lives the documentation for the engine.

Setup

The setup and installation details live in the project’s guide. A basic program in Blue Engine is as follow:

Example

use blue_engine::{
    header::{ Engine, ObjectSettings },
    primitive_shapes::triangle
};

fn main() {
    // initialize the engine
    let mut engine = Engine::new().expect("engine couldn't be initialized");

    // create a triangle
    triangle("my triangle", ObjectSettings::default(), &mut engine.renderer, &mut engine.objects).unwrap();

   // run the engine
   engine
       .update_loop(move |_, _, _, _, _, _| {})
       .expect("Error during update loop");
}

Utilities

This crate is the core of the engine, but there is also utilities crate which have a lot of utilities for the engine such as lighting, physics, etc.

Guide for code navigation

The code of the engine is organized in a rather different manner than traditional in the language. There are inspirations from other languages to make it easier to navigate the project.

Re-exports

• pub use imports::*;
• pub use uniform_buffer::*;

Modules

• header
  contains all the declarations such as structs, exports, enums, …
• imports
  re-exports from dependencies that are useful
• objects
  contains the definition for Object type, which is a type that make it easier to manage data for rendering.
• primitive_shapes
  contains definition for some 2D and 3D shapes. They are basic shapes and can be used as examples of how to create your own content.
• render
  contains definition for rendering part of the engine.
• uniform_buffer
  few commonly used uniform buffer structures
• utils
  Utilities for the engine (soon moving to it’s own crate).
• window
  contains definition for creation of window and instance creation.

Structs

• Camera
  Container for the camera feature. The settings here are needed for algebra equations needed for camera vision and movement. Please leave it to the renderer to handle
• Engine
  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.
• Instance
  Instance buffer data storage
• InstanceRaw
  Instance buffer data that is sent to GPU
• Object
  Objects make it easier to work with Blue Engine, it automates most of work needed for creating 3D objects and showing them on screen. A range of default objects are available as well as ability to customize each of them and even create your own! You can also customize almost everything there is about them!
• ObjectSettings
  Extra settings to customize objects on time of creation
• ObjectStorage
  A unified way to handle objects
• Pipeline
  Container for pipeline values. Each pipeline takes only 1 vertex shader, 1 fragment shader, 1 texture data, and optionally a vector of uniform data.
• Renderer
  Main renderer class. this will contain all methods and data related to the renderer
• ShaderSettings
  These definitions are taken from wgpu API docs
• SignalStorage
  Handles the live events in the engine
• Vertex
  Will contain all details about a vertex and will be sent to GPU
• VertexBuffers
  Container for vertex and index buffer
• WindowDescriptor
  Descriptor and settings for a window.

Enums

• ExecuteOrder
  Handles the order in which a functionality in the engine should be executed
• PipelineData
  Container for pipeline data. Allows for sharing resources with other objects
• Projection
  Container for the projection used by the camera
• RotateAxis
  Defines how the rotation axis is
• TextureData
  Defines how the texture data is
• TextureMode
  Defines how the borders of texture would look like

Constants

• DEPTH_FORMAT
  Depth format

Traits

• Signal
  Allows all events to be fetched directly, making it easier to add custom additions to the engine.
• StringBuffer
  A unified way to handle strings
• StringBufferTrait
  A trait for StringBuffer

Functions

• pixel_to_cartesian
  This function helps in converting pixel value to the value that is between -1 and +1