Struct Object 

pub struct Object {

    pub name: Arc<str>,
    pub vertices: Vec<Vertex>,
    pub indices: Vec<u16>,
    pub uniform_layout: BindGroupLayout,
    pub pipeline: Pipeline,
    pub instances: Vec<Instance>,
    pub instance_buffer: Buffer,
    pub size: Vec3,
    pub position: Vec3,
    pub rotation: Vec3,
    pub translation_matrix: Mat4,
    pub scale_matrix: Mat4,
    pub rotation_quaternion: Quat,
    pub inverse_transformation_matrix: Mat4,
    pub color: Vec4,
    pub shader_builder: ShaderBuilder,
    pub shader_settings: ShaderSettings,
    pub camera_effect: Option<Arc<str>>,
    pub uniform_buffers: Vec<Buffer>,
    pub is_visible: bool,
    pub render_order: usize,
    /* private fields */
}

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!

Fields

name: Arc<str>

Give your object a name, which can help later on for debugging.

vertices: Vec<Vertex>

A list of Vertex

indices: Vec<u16>

A list of indices that dictates the order that vertices appear

uniform_layout: BindGroupLayout

Describes how to uniform buffer is structures

pipeline: Pipeline

Pipeline holds all the data that is sent to GPU, including shaders and textures

instances: Vec<Instance>

List of instances of this object

instance_buffer: Buffer

instance buffer

size: Vec3

Dictates the size of your object in relation to the world

position: Vec3

Dictates the position of your object in pixels

rotation: Vec3

Dictates the rotation of your object

translation_matrix: Mat4

Transformation matrices helps to apply changes to your object, including position, orientation, … Best choice is to let the Object system handle it

scale_matrix: Mat4

Transformation matrices helps to apply changes to your object, including position, orientation, … Best choice is to let the Object system handle it

rotation_quaternion: Quat

Transformation matrices helps to apply changes to your object, including position, orientation, … Best choice is to let the Object system handle it

inverse_transformation_matrix: Mat4

Transformation matrix, but inversed

color: Vec4

The main color of your object

shader_builder: ShaderBuilder

A struct making it easier to manipulate specific parts of shader

shader_settings: ShaderSettings

Shader settings

camera_effect: Option<Arc<str>>

Camera have any effect on the object?

uniform_buffers: Vec<Buffer>

Uniform Buffers to be sent to GPU. These are raw and not compiled for GPU yet

is_visible: bool

Should be rendered or not

render_order: usize

Objects with higher number get rendered later and appear “on top” when occupying the same space

Implementations

impl Object

pub fn set_name(&mut self, name: impl AsRef<str>) -> &mut Object

Sets the name of the object

pub fn set_scale(&mut self, scale: impl Into<Vec3>) -> &mut Object

Scales an object. e.g. 2.0 doubles the size and 0.5 halves

pub fn resize(&mut self, size: impl Into<Vec3>) -> &mut Object

Resizes an object in pixels which are relative to the window

pub fn set_rotation(&mut self, rotation: impl Into<Vec3>) -> &mut Object

Sets the rotation of the object in the axis you specify

This function does NOT normalize the rotation.

pub fn rotate(&mut self, amount: RotateAmount, axis: RotateAxis) -> &mut Object

Rotates the object in the axis you specify

pub fn set_translation(&mut self, new_pos: impl Into<Vec3>) -> &mut Object

👎Deprecated

Moves the object by the amount you specify in the axis you specify

pub fn translate(&mut self, new_pos: impl Into<Vec3>) -> &mut Object

Moves the object by the amount you specify in the axis you specify

pub fn set_position(&mut self, new_pos: impl Into<Vec3>) -> &mut Object

Moves the object by the amount you specify in the axis you specify Sets the position of the object in 3D space relative to the window

pub fn set_color( &mut self, red: f32, green: f32, blue: f32, alpha: f32, ) -> &mut Object

Changes the color of the object. If textures exist, the color of textures will change

pub fn set_render_order(&mut self, render_order: usize) -> &mut Object

Changes the render order of the Object.

Objects with higher number get rendered later and appear “on top” when occupying the same space

pub fn set_texture( &mut self, name: impl AsRef<str>, texture_data: TextureData, texture_mode: TextureMode, renderer: &mut Renderer, ) -> Result<&mut Object, Error>

Replaces the object’s texture with provided one

This function previously served the role of crate::Object::set_texture_raw

pub fn set_texture_raw(&mut self, texture: BindGroup) -> &mut Object

Replaces the object’s texture with provided one

pub fn flag_as_changed(&mut self, is_changed: bool)

This will flag object as changed and altered, leading to rebuilding parts, or entirety on next frame. Best used if you directly altered fields of the object. The functions normally flag the object as changed on every call anyways. But this function is to manually flag it yourself.

pub fn set_visibility(&mut self, is_visible: bool)

Sets if the object will be rendered or not

pub fn inverse_matrices(&mut self)

build an inverse of the transformation matrix to be sent to the gpu for lighting and other things.

impl Object

pub fn reference_vertices(&mut self, object_id: impl AsRef<str>) -> &mut Object

References another object’s vertices

pub fn reference_shader(&mut self, object_id: impl AsRef<str>) -> &mut Object

References another object’s shader

pub fn reference_texture(&mut self, object_id: impl AsRef<str>) -> &mut Object

References another object’s texture

pub fn reference_uniform_buffer( &mut self, object_id: impl AsRef<str>, ) -> &mut Object

References another object’s uniform buffer

pub fn add_instance(&mut self, instance: Instance) -> &mut Object

Add an instance to the object

impl Object

pub fn update(&mut self, renderer: &mut Renderer)

Update and apply changes done to an object

pub fn update_and_return( &mut self, renderer: &mut Renderer, ) -> (VertexBuffers, BindGroup, RenderPipeline)

Update and apply changes done to an object and returns a pipeline

pub fn update_vertex_buffer(&mut self, renderer: &mut Renderer)

Update and apply changes done to the vertex buffer

pub fn update_vertex_buffer_and_return( &mut self, renderer: &mut Renderer, ) -> VertexBuffers

Returns the buffer with ownership

pub fn update_shader(&mut self, renderer: &mut Renderer)

Update and apply changes done to the shader

pub fn update_shader_and_return( &mut self, renderer: &mut Renderer, ) -> RenderPipeline

Returns the buffer with ownership

pub fn update_uniform_buffer(&mut self, renderer: &mut Renderer)

Update and apply changes done to the uniform buffer

pub fn update_uniform_buffer_and_return( &mut self, renderer: &mut Renderer, ) -> BindGroup

Update and apply changes done to the uniform buffer and returns it

pub fn update_instance_buffer(&mut self, renderer: &mut Renderer)

Updates the instance buffer

pub fn update_instance_buffer_and_return( &mut self, renderer: &mut Renderer, ) -> Buffer

Returns the buffer with ownership

impl Object

pub fn new( name: impl AsRef<str>, vertices: Vec<Vertex>, indices: Vec<u16>, settings: ObjectSettings, renderer: &mut Renderer, ) -> Result<Object, Error>

Creates a new object

Is used to define a new object and add it to the storage. This offers full customizability and a framework for in-engine shapes to be developed.

Trait Implementations

impl Send for Object

impl Sync for Object