Struct blue_engine::header::Object

source · 
pub struct Object {
Show 23 fields
    pub name: String,
    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 scale: Vec3,
    pub position: Vec3,
    pub rotation: Vec3,
    pub position_matrix: Mat4,
    pub scale_matrix: Mat4,
    pub rotation_matrix: Mat4,
    pub inverse_transformation_matrix: Matrix,
    pub uniform_color: Array4,
    pub color: Array4,
    pub shader_builder: ShaderBuilder,
    pub shader_settings: ShaderSettings,
    pub camera_effect: bool,
    pub uniform_buffers: Vec<Buffer>,
    pub is_visible: bool,
    pub render_order: usize,
    /* private fields */

}
Expand description

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: String

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 pixels

§scale: Vec3

Dictates the scale of your object. Which by default it’s 1,1,1 where the screen is size of 2

§position: Vec3

Dictates the position of your object in pixels

§rotation: Vec3

Dictates the rotation of your object

§position_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_matrix: Mat4

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: Matrix

Transformation matrix, but inversed

§uniform_color: Array4

The main color of your object

§color: Array4

The color of your object that is sent to gpu

§shader_builder: ShaderBuilder

A struct making it easier to manipulate specific parts of shader

§shader_settings: ShaderSettings

Shader settings

§camera_effect: bool

Camera have any effect on the object?

§uniform_buffers: Vec<Buffer>

Uniform Buffers to be sent to GPU

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

source§

impl Object

source

pub fn set_name(&mut self, name: impl StringBuffer)

Sets the name of the object

source

pub fn set_scale(&mut self, x: f32, y: f32, z: f32)

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

source

pub fn resize( &mut self, width: f32, height: f32, depth: f32, window_size: PhysicalSize<u32>, )

Resizes an object in pixels which are relative to the window

source

pub fn set_rotatation(&mut self, angle: f32, axis: RotateAxis)

Rotates the object in the axis you specify

source

pub fn set_translation(&mut self, x: f32, y: f32, z: f32)

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

source

pub fn set_position(&mut self, x: f32, y: f32, z: f32)

Sets the position of the object in 3D space relative to the window

Examples found in repository?
examples/utils/instancing.rs (line 31)
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

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");
}
More examples
Hide additional examples
examples/utils/resource_sharing.rs (line 45)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

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

    // build a texture as an example of resource to be shared
    let texture = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    // build your main object with the texture
    square(
        "main",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("Error during creation of main square");

    // add the texture to the main object as normally would
    engine
        .objects
        .get_mut("main")
        .unwrap()
        .set_texture(texture)
        .expect("Error during inserting texture to the main square");
    // set position to make it visible
    engine
        .objects
        .get_mut("main")
        .expect("Error during setting the position of the main square")
        .set_position(-1.5f32, 0f32, 0f32);

    // create another object where you want to get resources shared with
    square(
        "alt",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("Error during creation of alt square");

    // here you can use `reference_texture` to reference the texture from the main object
    engine
        .objects
        .get_mut("alt")
        .expect("Error during copying texture of the main square")
        .reference_texture("main");
    // setting position again to make it visible
    engine
        .objects
        .get_mut("alt")
        .expect("Error during setting the position of the alt square")
        .set_position(1.5f32, 0f32, 0f32);

    engine
        .update_loop(move |_, _, _, _, _, _| {})
        .expect("Error during update loop");
}
examples/utils/render_order.rs (line 42)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

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

    // make the first layer
    square(
        "layer1",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("failed to create square");

    // make the second layer
    square(
        "layer2",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("failed to create square");

    // Get layer 1 object
    let layer1 = engine
        .objects
        .get_mut("layer1")
        .expect("failed to gete object");
    // set a color to differentiate it
    layer1
        .set_uniform_color(1f32, 0.5, 0f32, 1f32)
        .expect("failed to set color");
    // move it to left a bit
    layer1.set_position(-0.5, 0f32, 0f32);
    // set render order to 0th
    layer1.set_render_order(0).unwrap();

    // Get layer 2 object
    let layer2 = engine
        .objects
        .get_mut("layer2")
        .expect("failed to gete object");
    // set a color to differentiate it
    layer2
        .set_uniform_color(0f32, 0f32, 1f32, 1f32)
        .expect("failed to set color");
    // move it to right a bit
    layer2.set_position(0.5, 0f32, 0f32);
    // set render order to 1st
    layer2.set_render_order(1).unwrap();

    // get a timer for order change
    let start = std::time::SystemTime::now();

    // start the update loop
    engine
        .update_loop(move |_, _, object_storage, _, _, _| {
            // get the target layer to change order of
            let target = object_storage.get_mut("layer1").unwrap();

            // on ever 2 seconds change order
            if start.elapsed().unwrap().as_secs() % 2 == 0 {
                target.set_render_order(2).unwrap();
            } else {
                // change back to default
                target.set_render_order(0).unwrap();
            }
        })
        .expect("Error during update loop");
}
examples/dev/dev.rs (line 61)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

fn main() {
    let mut engine = Engine::new_config(blue_engine::WindowDescriptor {
        power_preference: blue_engine::PowerPreference::None,
        present_mode: blue_engine::wgpu::PresentMode::Mailbox,
        limits: blue_engine::wgpu::Limits::downlevel_defaults(),
        ..Default::default()
    })
    .expect("win");

    //let test_instance = Instance::default();
    //println!("{:?}", test_instance.to_raw());

    let texture = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();
    let texture2 = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    let texture3 = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    square(
        "main",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    );

    engine.objects.get_mut("main").unwrap().set_texture(texture);
    engine
        .objects
        .get_mut("main")
        .unwrap()
        .set_position(-1f32, 0f32, 0f32);

    square(
        "alt",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    );
    engine.objects.get_mut("alt").unwrap().set_texture(texture2);
    engine
        .objects
        .get_mut("alt")
        .unwrap()
        .set_position(0.2f32, 0f32, 0.001f32);

    square(
        "alt2",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    );
    engine
        .objects
        .get_mut("alt2")
        .unwrap()
        .set_texture(texture3);
    engine
        .objects
        .get_mut("alt2")
        .unwrap()
        .set_position(-0.2f32, 0f32, 0.001f32);

    let speed = -0.05;

    let mut last_time = std::time::Instant::now();
    let mut frames = 0;
    engine
        .update_loop(move |renderer, _window, objects, input, camera, plugins| {
            // calculate FPS
            let current_time = std::time::Instant::now();
            frames += 1;
            if current_time - last_time >= std::time::Duration::from_secs(1) {
                println!("{}ms/frame", 1000f32 / frames as f32);
                frames = 0;
                last_time = current_time;
            }

            let sprite = objects.get_mut("alt").unwrap();

            if input.key_held(blue_engine::KeyCode::Escape) {
                _window.close_engine();
            }
            if input.key_held(blue_engine::KeyCode::ArrowUp) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y - speed,
                    sprite.position.z,
                );
                //lm.ambient_color.data = [1f32, 1f32, 1f32, 1f32];
            }
            if input.key_held(blue_engine::KeyCode::ArrowDown) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y + speed,
                    sprite.position.z,
                );
                //lm.ambient_color.data = [0.1f32, 0.1f32, 0.1f32, 1f32];
            }

            if input.key_held(blue_engine::KeyCode::ArrowLeft) {
                sprite.set_position(
                    sprite.position.x + speed,
                    sprite.position.y,
                    sprite.position.z,
                );
            }
            if input.key_held(blue_engine::KeyCode::ArrowRight) {
                sprite.set_position(
                    sprite.position.x - speed,
                    sprite.position.y,
                    sprite.position.z,
                );
            }

            if input.key_held(blue_engine::KeyCode::KeyE) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y,
                    sprite.position.z + speed,
                );
            }
            if input.key_held(blue_engine::KeyCode::KeyQ) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y,
                    sprite.position.z - speed,
                );
            }
        })
        .expect("Error during update loop");

    println!("Engine have been closed")
}
source

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

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

Examples found in repository?
examples/shapes/cube.rs (line 17)
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

fn main() {
    let mut engine = Engine::new().expect("win");

    cube("Cube", &mut engine.renderer, &mut engine.objects).unwrap();
    engine
        .objects
        .get_mut("Cube")
        .unwrap()
        .set_color(0f32, 0f32, 1f32, 1f32)
        .unwrap();

    let radius = 5f32;
    let start = std::time::SystemTime::now();
    engine
        .update_loop(move |_, _, _, _, camera, _| {
            let camx = start.elapsed().unwrap().as_secs_f32().sin() * radius;
            let camy = start.elapsed().unwrap().as_secs_f32().sin() * radius;
            let camz = start.elapsed().unwrap().as_secs_f32().cos() * radius;
            camera
                .set_position(camx, camy, camz)
                .expect("Couldn't update the camera eye");
        })
        .expect("Error during update loop");
}
source

pub fn set_uniform_color( &mut self, red: f32, green: f32, blue: f32, alpha: f32, ) -> Result<()>

Changes the main color of the object hat is sent to GPU. If textures exist, the color of textures will change

Examples found in repository?
examples/utils/render_order.rs (line 39)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

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

    // make the first layer
    square(
        "layer1",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("failed to create square");

    // make the second layer
    square(
        "layer2",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("failed to create square");

    // Get layer 1 object
    let layer1 = engine
        .objects
        .get_mut("layer1")
        .expect("failed to gete object");
    // set a color to differentiate it
    layer1
        .set_uniform_color(1f32, 0.5, 0f32, 1f32)
        .expect("failed to set color");
    // move it to left a bit
    layer1.set_position(-0.5, 0f32, 0f32);
    // set render order to 0th
    layer1.set_render_order(0).unwrap();

    // Get layer 2 object
    let layer2 = engine
        .objects
        .get_mut("layer2")
        .expect("failed to gete object");
    // set a color to differentiate it
    layer2
        .set_uniform_color(0f32, 0f32, 1f32, 1f32)
        .expect("failed to set color");
    // move it to right a bit
    layer2.set_position(0.5, 0f32, 0f32);
    // set render order to 1st
    layer2.set_render_order(1).unwrap();

    // get a timer for order change
    let start = std::time::SystemTime::now();

    // start the update loop
    engine
        .update_loop(move |_, _, object_storage, _, _, _| {
            // get the target layer to change order of
            let target = object_storage.get_mut("layer1").unwrap();

            // on ever 2 seconds change order
            if start.elapsed().unwrap().as_secs() % 2 == 0 {
                target.set_render_order(2).unwrap();
            } else {
                // change back to default
                target.set_render_order(0).unwrap();
            }
        })
        .expect("Error during update loop");
}
source

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

Changes the render order of the Object.

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

Examples found in repository?
examples/utils/render_order.rs (line 44)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

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

    // make the first layer
    square(
        "layer1",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("failed to create square");

    // make the second layer
    square(
        "layer2",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("failed to create square");

    // Get layer 1 object
    let layer1 = engine
        .objects
        .get_mut("layer1")
        .expect("failed to gete object");
    // set a color to differentiate it
    layer1
        .set_uniform_color(1f32, 0.5, 0f32, 1f32)
        .expect("failed to set color");
    // move it to left a bit
    layer1.set_position(-0.5, 0f32, 0f32);
    // set render order to 0th
    layer1.set_render_order(0).unwrap();

    // Get layer 2 object
    let layer2 = engine
        .objects
        .get_mut("layer2")
        .expect("failed to gete object");
    // set a color to differentiate it
    layer2
        .set_uniform_color(0f32, 0f32, 1f32, 1f32)
        .expect("failed to set color");
    // move it to right a bit
    layer2.set_position(0.5, 0f32, 0f32);
    // set render order to 1st
    layer2.set_render_order(1).unwrap();

    // get a timer for order change
    let start = std::time::SystemTime::now();

    // start the update loop
    engine
        .update_loop(move |_, _, object_storage, _, _, _| {
            // get the target layer to change order of
            let target = object_storage.get_mut("layer1").unwrap();

            // on ever 2 seconds change order
            if start.elapsed().unwrap().as_secs() % 2 == 0 {
                target.set_render_order(2).unwrap();
            } else {
                // change back to default
                target.set_render_order(0).unwrap();
            }
        })
        .expect("Error during update loop");
}
source

pub fn set_texture(&mut self, texture: Textures) -> Result<()>

Replaces the object’s texture with provided one

Examples found in repository?
examples/utils/resource_sharing.rs (line 38)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

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

    // build a texture as an example of resource to be shared
    let texture = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    // build your main object with the texture
    square(
        "main",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("Error during creation of main square");

    // add the texture to the main object as normally would
    engine
        .objects
        .get_mut("main")
        .unwrap()
        .set_texture(texture)
        .expect("Error during inserting texture to the main square");
    // set position to make it visible
    engine
        .objects
        .get_mut("main")
        .expect("Error during setting the position of the main square")
        .set_position(-1.5f32, 0f32, 0f32);

    // create another object where you want to get resources shared with
    square(
        "alt",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("Error during creation of alt square");

    // here you can use `reference_texture` to reference the texture from the main object
    engine
        .objects
        .get_mut("alt")
        .expect("Error during copying texture of the main square")
        .reference_texture("main");
    // setting position again to make it visible
    engine
        .objects
        .get_mut("alt")
        .expect("Error during setting the position of the alt square")
        .set_position(1.5f32, 0f32, 0f32);

    engine
        .update_loop(move |_, _, _, _, _, _| {})
        .expect("Error during update loop");
}
More examples
Hide additional examples
examples/dev/dev.rs (line 56)
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

fn main() {
    let mut engine = Engine::new_config(blue_engine::WindowDescriptor {
        power_preference: blue_engine::PowerPreference::None,
        present_mode: blue_engine::wgpu::PresentMode::Mailbox,
        limits: blue_engine::wgpu::Limits::downlevel_defaults(),
        ..Default::default()
    })
    .expect("win");

    //let test_instance = Instance::default();
    //println!("{:?}", test_instance.to_raw());

    let texture = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();
    let texture2 = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    let texture3 = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    square(
        "main",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    );

    engine.objects.get_mut("main").unwrap().set_texture(texture);
    engine
        .objects
        .get_mut("main")
        .unwrap()
        .set_position(-1f32, 0f32, 0f32);

    square(
        "alt",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    );
    engine.objects.get_mut("alt").unwrap().set_texture(texture2);
    engine
        .objects
        .get_mut("alt")
        .unwrap()
        .set_position(0.2f32, 0f32, 0.001f32);

    square(
        "alt2",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    );
    engine
        .objects
        .get_mut("alt2")
        .unwrap()
        .set_texture(texture3);
    engine
        .objects
        .get_mut("alt2")
        .unwrap()
        .set_position(-0.2f32, 0f32, 0.001f32);

    let speed = -0.05;

    let mut last_time = std::time::Instant::now();
    let mut frames = 0;
    engine
        .update_loop(move |renderer, _window, objects, input, camera, plugins| {
            // calculate FPS
            let current_time = std::time::Instant::now();
            frames += 1;
            if current_time - last_time >= std::time::Duration::from_secs(1) {
                println!("{}ms/frame", 1000f32 / frames as f32);
                frames = 0;
                last_time = current_time;
            }

            let sprite = objects.get_mut("alt").unwrap();

            if input.key_held(blue_engine::KeyCode::Escape) {
                _window.close_engine();
            }
            if input.key_held(blue_engine::KeyCode::ArrowUp) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y - speed,
                    sprite.position.z,
                );
                //lm.ambient_color.data = [1f32, 1f32, 1f32, 1f32];
            }
            if input.key_held(blue_engine::KeyCode::ArrowDown) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y + speed,
                    sprite.position.z,
                );
                //lm.ambient_color.data = [0.1f32, 0.1f32, 0.1f32, 1f32];
            }

            if input.key_held(blue_engine::KeyCode::ArrowLeft) {
                sprite.set_position(
                    sprite.position.x + speed,
                    sprite.position.y,
                    sprite.position.z,
                );
            }
            if input.key_held(blue_engine::KeyCode::ArrowRight) {
                sprite.set_position(
                    sprite.position.x - speed,
                    sprite.position.y,
                    sprite.position.z,
                );
            }

            if input.key_held(blue_engine::KeyCode::KeyE) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y,
                    sprite.position.z + speed,
                );
            }
            if input.key_held(blue_engine::KeyCode::KeyQ) {
                sprite.set_position(
                    sprite.position.x,
                    sprite.position.y,
                    sprite.position.z - speed,
                );
            }
        })
        .expect("Error during update loop");

    println!("Engine have been closed")
}
source

pub fn flag_as_changed(&mut self)

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.

source

pub fn flag_as_unchanged(&mut self)

same as flag_as_changed, but inverse

source

pub fn inverse_matrices(&mut self)

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

source

pub fn update(&mut self, renderer: &mut Renderer) -> Result<()>

Update and apply changes done to an object

source

pub fn update_and_return( &mut self, renderer: &mut Renderer, ) -> Result<(VertexBuffers, UniformBuffers, Shaders)>

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

source

pub fn update_vertex_buffer(&mut self, renderer: &mut Renderer) -> Result<()>

Update and apply changes done to the vertex buffer

source

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

Returns the buffer with ownership

source

pub fn update_shader(&mut self, renderer: &mut Renderer) -> Result<()>

Update and apply changes done to the shader

source

pub fn update_shader_and_return( &mut self, renderer: &mut Renderer, ) -> Result<Shaders>

Returns the buffer with ownership

source

pub fn update_uniform_buffer(&mut self, renderer: &mut Renderer) -> Result<()>

Update and apply changes done to the uniform buffer

source

pub fn update_uniform_buffer_and_return( &mut self, renderer: &mut Renderer, ) -> Result<UniformBuffers>

Returns the buffer with ownership

source

pub fn update_instance_buffer(&mut self, renderer: &mut Renderer) -> Result<()>

Updates the instance buffer

Examples found in repository?
examples/utils/instancing.rs (line 56)
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

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");
}
source

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

Returns the buffer with ownership

source

pub fn reference_vertices(&mut self, object_id: impl StringBuffer)

References another object’s vertices

source

pub fn reference_shader(&mut self, object_id: impl StringBuffer)

References another object’s shader

source

pub fn reference_texture(&mut self, object_id: impl StringBuffer)

References another object’s texture

Examples found in repository?
examples/utils/resource_sharing.rs (line 61)
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

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

    // build a texture as an example of resource to be shared
    let texture = engine
        .renderer
        .build_texture(
            "background",
            TextureData::Path("resources/BlueLogoDiscord.png".to_string()),
            blue_engine::TextureMode::Clamp,
        )
        .unwrap();

    // build your main object with the texture
    square(
        "main",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("Error during creation of main square");

    // add the texture to the main object as normally would
    engine
        .objects
        .get_mut("main")
        .unwrap()
        .set_texture(texture)
        .expect("Error during inserting texture to the main square");
    // set position to make it visible
    engine
        .objects
        .get_mut("main")
        .expect("Error during setting the position of the main square")
        .set_position(-1.5f32, 0f32, 0f32);

    // create another object where you want to get resources shared with
    square(
        "alt",
        ObjectSettings::default(),
        &mut engine.renderer,
        &mut engine.objects,
    )
    .expect("Error during creation of alt square");

    // here you can use `reference_texture` to reference the texture from the main object
    engine
        .objects
        .get_mut("alt")
        .expect("Error during copying texture of the main square")
        .reference_texture("main");
    // setting position again to make it visible
    engine
        .objects
        .get_mut("alt")
        .expect("Error during setting the position of the alt square")
        .set_position(1.5f32, 0f32, 0f32);

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

pub fn reference_uniform_buffer(&mut self, object_id: impl StringBuffer)

References another object’s uniform buffer

source

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

Add an instance to the object

Examples found in repository?
examples/utils/instancing.rs (line 43)
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

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");
}

Trait Implementations§

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Any for T
where T: Any,

source§

fn into_any(self: Box<T>) -> Box<dyn Any>

source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

source§

fn type_name(&self) -> &'static str

source§

impl<T> AnySync for T
where T: Any + Send + Sync,

source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> Downcast<T> for T

source§

fn downcast(&self) -> &T

source§

impl<T> Downcast for T
where T: Any,

source§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
source§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
source§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
source§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
source§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

source§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

impl<D> OwoColorize for D

source§

fn fg<C>(&self) -> FgColorDisplay<'_, C, Self>
where C: Color,

Set the foreground color generically Read more
source§

fn bg<C>(&self) -> BgColorDisplay<'_, C, Self>
where C: Color,

Set the background color generically. Read more
source§

fn black<'a>(&'a self) -> FgColorDisplay<'a, Black, Self>

Change the foreground color to black
source§

fn on_black<'a>(&'a self) -> BgColorDisplay<'a, Black, Self>

Change the background color to black
source§

fn red<'a>(&'a self) -> FgColorDisplay<'a, Red, Self>

Change the foreground color to red
source§

fn on_red<'a>(&'a self) -> BgColorDisplay<'a, Red, Self>

Change the background color to red
source§

fn green<'a>(&'a self) -> FgColorDisplay<'a, Green, Self>

Change the foreground color to green
source§

fn on_green<'a>(&'a self) -> BgColorDisplay<'a, Green, Self>

Change the background color to green
source§

fn yellow<'a>(&'a self) -> FgColorDisplay<'a, Yellow, Self>

Change the foreground color to yellow
source§

fn on_yellow<'a>(&'a self) -> BgColorDisplay<'a, Yellow, Self>

Change the background color to yellow
source§

fn blue<'a>(&'a self) -> FgColorDisplay<'a, Blue, Self>

Change the foreground color to blue
source§

fn on_blue<'a>(&'a self) -> BgColorDisplay<'a, Blue, Self>

Change the background color to blue
source§

fn magenta<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>

Change the foreground color to magenta
source§

fn on_magenta<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>

Change the background color to magenta
source§

fn purple<'a>(&'a self) -> FgColorDisplay<'a, Magenta, Self>

Change the foreground color to purple
source§

fn on_purple<'a>(&'a self) -> BgColorDisplay<'a, Magenta, Self>

Change the background color to purple
source§

fn cyan<'a>(&'a self) -> FgColorDisplay<'a, Cyan, Self>

Change the foreground color to cyan
source§

fn on_cyan<'a>(&'a self) -> BgColorDisplay<'a, Cyan, Self>

Change the background color to cyan
source§

fn white<'a>(&'a self) -> FgColorDisplay<'a, White, Self>

Change the foreground color to white
source§

fn on_white<'a>(&'a self) -> BgColorDisplay<'a, White, Self>

Change the background color to white
source§

fn default_color<'a>(&'a self) -> FgColorDisplay<'a, Default, Self>

Change the foreground color to the terminal default
source§

fn on_default_color<'a>(&'a self) -> BgColorDisplay<'a, Default, Self>

Change the background color to the terminal default
source§

fn bright_black<'a>(&'a self) -> FgColorDisplay<'a, BrightBlack, Self>

Change the foreground color to bright black
source§

fn on_bright_black<'a>(&'a self) -> BgColorDisplay<'a, BrightBlack, Self>

Change the background color to bright black
source§

fn bright_red<'a>(&'a self) -> FgColorDisplay<'a, BrightRed, Self>

Change the foreground color to bright red
source§

fn on_bright_red<'a>(&'a self) -> BgColorDisplay<'a, BrightRed, Self>

Change the background color to bright red
source§

fn bright_green<'a>(&'a self) -> FgColorDisplay<'a, BrightGreen, Self>

Change the foreground color to bright green
source§

fn on_bright_green<'a>(&'a self) -> BgColorDisplay<'a, BrightGreen, Self>

Change the background color to bright green
source§

fn bright_yellow<'a>(&'a self) -> FgColorDisplay<'a, BrightYellow, Self>

Change the foreground color to bright yellow
source§

fn on_bright_yellow<'a>(&'a self) -> BgColorDisplay<'a, BrightYellow, Self>

Change the background color to bright yellow
source§

fn bright_blue<'a>(&'a self) -> FgColorDisplay<'a, BrightBlue, Self>

Change the foreground color to bright blue
source§

fn on_bright_blue<'a>(&'a self) -> BgColorDisplay<'a, BrightBlue, Self>

Change the background color to bright blue
source§

fn bright_magenta<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>

Change the foreground color to bright magenta
source§

fn on_bright_magenta<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>

Change the background color to bright magenta
source§

fn bright_purple<'a>(&'a self) -> FgColorDisplay<'a, BrightMagenta, Self>

Change the foreground color to bright purple
source§

fn on_bright_purple<'a>(&'a self) -> BgColorDisplay<'a, BrightMagenta, Self>

Change the background color to bright purple
source§

fn bright_cyan<'a>(&'a self) -> FgColorDisplay<'a, BrightCyan, Self>

Change the foreground color to bright cyan
source§

fn on_bright_cyan<'a>(&'a self) -> BgColorDisplay<'a, BrightCyan, Self>

Change the background color to bright cyan
source§

fn bright_white<'a>(&'a self) -> FgColorDisplay<'a, BrightWhite, Self>

Change the foreground color to bright white
source§

fn on_bright_white<'a>(&'a self) -> BgColorDisplay<'a, BrightWhite, Self>

Change the background color to bright white
source§

fn bold<'a>(&'a self) -> BoldDisplay<'a, Self>

Make the text bold
source§

fn dimmed<'a>(&'a self) -> DimDisplay<'a, Self>

Make the text dim
source§

fn italic<'a>(&'a self) -> ItalicDisplay<'a, Self>

Make the text italicized
source§

fn underline<'a>(&'a self) -> UnderlineDisplay<'a, Self>

Make the text italicized
Make the text blink
Make the text blink (but fast!)
source§

fn reversed<'a>(&'a self) -> ReversedDisplay<'a, Self>

Swap the foreground and background colors
source§

fn hidden<'a>(&'a self) -> HiddenDisplay<'a, Self>

Hide the text
source§

fn strikethrough<'a>(&'a self) -> StrikeThroughDisplay<'a, Self>

Cross out the text
source§

fn color<Color>(&self, color: Color) -> FgDynColorDisplay<'_, Color, Self>
where Color: DynColor,

Set the foreground color at runtime. Only use if you do not know which color will be used at compile-time. If the color is constant, use either OwoColorize::fg or a color-specific method, such as OwoColorize::green, Read more
source§

fn on_color<Color>(&self, color: Color) -> BgDynColorDisplay<'_, Color, Self>
where Color: DynColor,

Set the background color at runtime. Only use if you do not know what color to use at compile-time. If the color is constant, use either OwoColorize::bg or a color-specific method, such as OwoColorize::on_yellow, Read more
source§

fn fg_rgb<const R: u8, const G: u8, const B: u8>( &self, ) -> FgColorDisplay<'_, CustomColor<R, G, B>, Self>

Set the foreground color to a specific RGB value.
source§

fn bg_rgb<const R: u8, const G: u8, const B: u8>( &self, ) -> BgColorDisplay<'_, CustomColor<R, G, B>, Self>

Set the background color to a specific RGB value.
source§

fn truecolor(&self, r: u8, g: u8, b: u8) -> FgDynColorDisplay<'_, Rgb, Self>

Sets the foreground color to an RGB value.
source§

fn on_truecolor(&self, r: u8, g: u8, b: u8) -> BgDynColorDisplay<'_, Rgb, Self>

Sets the background color to an RGB value.
source§

fn style(&self, style: Style) -> Styled<&Self>

Apply a runtime-determined style
source§

impl<T> Pointable for T

source§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

source§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
source§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
source§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
source§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<T> Upcast<T> for T

source§

fn upcast(&self) -> Option<&T>

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> WasmNotSend for T
where T: Send,

source§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

source§

impl<T> WasmNotSync for T
where T: Sync,