Struct blue_engine::Instance

pub struct Instance {
    pub position: Vec3,
    pub rotation: Vec3,
    pub scale: Vec3,
}

Instance buffer data storage

Fields

position: Vec3

The position of the instance

rotation: Vec3

The rotation of the instance

scale: Vec3

The scale of the instance

Implementations

impl Instance

pub fn new(position: Vec3, rotation: Vec3, scale: Vec3) -> Self

Creates a new instance

Examples found in repository

examples/utils/instancing.rs (lines 35-39)

pub fn main() {
    // start the engine
    let mut engine = Engine::new().expect("window not created");

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

    // update the triangle
    engine.objects.update_object("Triangle", |object| {
        // set the position of the main triangle
        object.set_position(0f32, 0f32, -3f32);

        // a function to make instance creation easier
        let create_instance = |x: f32, y: f32, z: f32| {
            Instance::new(
                [x, y, z].into(),
                [0f32, 0f32, 0f32].into(),
                [1f32, 1f32, 1f32].into(),
            )
        };

        // add an instance
        object.add_instance(create_instance(2f32, 1f32, -2f32));
        object.add_instance(create_instance(2f32, -1f32, -2f32));
        object.add_instance(create_instance(-2f32, 1f32, -2f32));
        object.add_instance(create_instance(-2f32, -1f32, -2f32));
    });

    // we manually update the instance buffer before the next frame starts
    // this is due to the object updates happening after every frame, hence
    // for the first frame, we need to update it ourselves.
    engine
        .objects
        .get_mut("Triangle")
        .expect("Couldn't get the triangle")
        .update_instance_buffer(&mut engine.renderer)
        .expect("Couldn't update instance buffer");

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

pub fn to_raw(&self) -> InstanceRaw

Gathers all information and builds a Raw Instance to be sent to GPU

pub fn set_position(&mut self, position: Vec3)

Sets the position

pub fn set_rotation(&mut self, rotation: Vec3)

Sets the rotation

pub fn set_scale(&mut self, scale: Vec3)

Sets the scale

Trait Implementations

impl Clone for Instance

fn clone(&self) -> Instance

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Instance

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

Formats the value using the given formatter.

impl Default for Instance

fn default() -> Self

Returns the “default value” for a type.

impl Copy for Instance