Struct Runner

Source

pub struct Runner { /* private fields */ }

Expand description

Provide almost cross-platform event loop for the application.

This wrap winit’s EventLoop and provides a way to create windows and handle events. But with some limitations:

No support for iOS and WASM platforms.
macOS platform have to use [PollMode::WaitDraw] or drawing at event Event::RedrawRequested because how winit setup the window drawing on macOS.

Implementations§

Source §

impl Runner

Source

pub fn get_events(&self) -> &Vec<Event>

Returns the pending events that have been processed by the event loop in Runner::pump_events.

Examples found in repository ?

examples/software.rs (line 21)

6fn main() {
7    let mut runner = est_render::runner::new().expect("Failed to create runner");
8    let mut window = runner
9        .create_window("Engine Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut sw = est_render::software::new(Some(&mut window))
14        .build()
15        .expect("Failed to create pixel buffer");
16
17    let mut pixels = vec![128u32; (800 * 600) as usize];
18    let mut size_px = Point2::new(800.0, 600.0);
19
20    while runner.pump_events(None) {
21        for event in runner.get_events() {
22            match event {
23                Event::WindowClosed { .. } => {
24                    return;
25                }
26                Event::WindowResized { size, .. } => {
27                    pixels.resize((size.x * size.y) as usize, 128);
28                    size_px = Point2::new(size.x as f32, size.y as f32);
29                }
30                _ => {}
31            }
32        }
33
34        if let Err(e) = sw.write_buffers(&pixels, size_px) {
35            eprintln!("Error writing buffers: {}", e);
36        }
37    }
38}

More examples

Hide additional examples

examples/clear_color.rs (line 18)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Clear Color Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    while runner.pump_events(None) {
18        for event in runner.get_events() {
19            match event {
20                Event::WindowClosed { .. } => {
21                    return;
22                }
23                _ => {}
24            }
25        }
26
27        if let Ok(mut cmd) = gpu.begin_command() {
28            let surface = cmd.get_surface_texture();
29            if surface.is_err() {
30                println!("Failed to get surface texture: {:?}", surface.err());
31                continue;
32            }
33
34            // Or you could use `cmd.begin_renderpass()` directly
35            if let Ok(mut rp) = cmd.renderpass_builder()
36                .add_surface_color_attachment(surface.as_ref().unwrap(), Some(&BlendState::ALPHA_BLEND))
37                .build() 
38            {
39                rp.set_clear_color(Color::BLUE);
40            }
41        }
42    }
43}

examples/gpu_adapter.rs (line 35)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7    let mut window = runner
8        .create_window("Engine Example", Point2::new(800, 600))
9        .build()
10        .expect("Failed to create window");
11
12    let adapters = est_render::gpu::query_gpu_adapter(Some(&window));
13    if adapters.is_empty() {
14        eprintln!("No GPU adapters found. Exiting.");
15        return;
16    }
17
18    let selected_adapter = adapters
19        .iter()
20        .find(|adapter| adapter.backend_enum == AdapterBackend::Vulkan)
21        .cloned();
22
23    if selected_adapter.is_none() {
24        eprintln!("No suitable GPU adapter found. Exiting.");
25        return;
26    }
27
28    let adapter = selected_adapter.unwrap();
29    let mut gpu = est_render::gpu::new(Some(&mut window))
30        .set_adapter(&adapter)
31        .build()
32        .expect("Failed to create GPU");
33
34    while runner.pump_events(None) {
35        for event in runner.get_events() {
36            match event {
37                Event::WindowClosed { .. } => {
38                    return;
39                }
40                _ => {}
41            }
42        }
43
44        if let Ok(mut cmd) = gpu.begin_command() {
45            if let Ok(mut rp) = cmd.begin_renderpass() {
46                rp.set_clear_color(Color::LIGHTBLUE);
47            }
48        }
49    }
50}

examples/drawing.rs (line 19)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Drawing Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    let mut rotation = 0.0f32;
18    while runner.pump_events(None) {
19        for event in runner.get_events() {
20            match event {
21                Event::WindowClosed { .. } => {
22                    return;
23                }
24                _ => {}
25            }
26        }
27
28        rotation += runner.get_frame_time() as f32 * 60.0f32; // Rotate at 60 degrees per second
29        if rotation >= 360.0 {
30            rotation -= 360.0; // Reset rotation after a full circle
31        }
32
33        if let Ok(mut cmd) = gpu.begin_command() {
34            if let Ok(mut gp) = cmd.begin_renderpass() {
35                gp.set_clear_color(Color::BLUE); // Set the clear color to blue
36
37                if let Some(mut drawing) = gp.begin_drawing() {
38                    drawing.set_rotation(rotation); // Set rotation to 45 degrees
39                    gp.set_blend(0, Some(&BlendState::ALPHA_BLEND));
40                    drawing.draw_rect_filled(
41                        Vector2::new(100.0, 100.0),
42                        Vector2::new(200.0, 200.0),
43                        Color::RED,
44                    );
45
46                    drawing.draw_circle_filled(Vector2::new(400.0, 300.0), 50.0, 25, Color::GREEN);
47
48                    gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
49
50                    drawing.draw_text(
51                        "Hello, World!",
52                        Vector2::new(300.0, 500.0),
53                        Color::WHITE,
54                    );
55                }
56            }
57        }
58    }
59}

examples/font.rs (line 29)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Font Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    let mut font_manager = est_render::font::new();
18
19    let font = font_manager
20        .load_font("Arial", None, 20.0)
21        .expect("Failed to load font");
22
23    // Generate baked text texture
24    let texture = font
25        .create_baked_text(&mut gpu, "Hello, World!\nThis is a clear color example.", None)
26        .expect("Failed to create baked text");
27
28    while runner.pump_events(None) {
29        for event in runner.get_events() {
30            match event {
31                Event::WindowClosed { .. } => {
32                    return;
33                }
34                _ => {}
35            }
36        }
37
38        if let Ok(mut cmd) = gpu.begin_command() {
39            if let Ok(mut gp) = cmd.begin_renderpass() {
40                gp.set_clear_color(Color::BLUE);
41
42                // The best texture blend for font rendering, others may has artifacts like black borders
43                gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
44                
45                if let Some(mut drawing) = gp.begin_drawing() {
46                    let size: Vector2 = texture.size().into();
47
48                    // Baked text rendering
49                    drawing.set_texture(Some(&texture));
50                    drawing.draw_rect_image(Vector2::new(0.0, 0.0), size, Color::WHITE);
51
52                    // Online text rendering
53                    drawing.set_font(&font);
54                    drawing.draw_text(
55                        "Hello, World!\nThis is a clear color example.",
56                        Vector2::new(size.x, 0.0),
57                        Color::WHITE,
58                    );
59                }
60            }
61        }
62    }
63}

examples/texture_atlas.rs (line 31)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Clear Color Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    let texture_atlas = gpu
18        .create_texture_atlas()
19        .add_texture_file(
20            "example_texture",
21            "./examples/resources/test1.png",
22        )
23        .add_texture_file(
24            "example_texture2",
25            "./examples/resources/test2.png",
26        )
27        .build()
28        .expect("Failed to create texture atlas");
29
30    while runner.pump_events(None) {
31        for event in runner.get_events() {
32            match event {
33                Event::WindowClosed { .. } => {
34                    return;
35                }
36                _ => {}
37            }
38        }
39
40        if let Ok(mut cmd) = gpu.begin_command() {
41            if let Ok(mut gp) = cmd.begin_renderpass() {
42                gp.set_clear_color(Color::BLUEVIOLET);
43                gp.set_blend(0, Some(&BlendState::NONE));
44
45                if let Some(mut drawing) = gp.begin_drawing() {
46                    drawing.set_texture_atlas(Some((&texture_atlas, "example_texture")));
47                    drawing.draw_rect_image(
48                        Vector2::new(100.0, 100.0),
49                        Vector2::new(200.0, 200.0),
50                        Color::WHITE,
51                    );
52                    drawing.set_texture_atlas(Some((&texture_atlas, "example_texture2")));
53                    drawing.draw_rect_image(
54                        Vector2::new(350.0, 100.0),
55                        Vector2::new(200.0, 200.0),
56                        Color::WHITE,
57                    );
58                    drawing.draw_circle_image(Vector2::new(600.0, 200.0), 100.0, 20, Color::WHITE);
59                }
60            }
61        }
62    }
63}

Additional examples can be found in:

Source

pub fn create_window(&mut self, title: &str, size: Point2) -> WindowBuilder<'_>

Creates a new WindowBuilder instance to build a new window.

Examples found in repository ?

examples/input.rs (line 9)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let _window = runner
9        .create_window("Input Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let window2 = runner
14        .create_window("Second Window", Point2::new(800, 600))
15        .build()
16        .expect("Failed to create second window");
17
18    let input = runner.create_input(None);
19    let mut input2 = runner.create_input(Some(&window2));
20
21    input2.listen_keyboard_event(|key, pressed| {
22        println!("Second window keyboard event: {} - {}", key, pressed);
23    });
24
25    while runner.pump_events(None) {
26        if input.mouse_pressed_once("Left") {
27            println!("Mouse position: {:?}", input.mouse_position());
28        }
29
30        if input2.mouse_pressed_once("Left") {
31            println!("Mouse position in second window: {:?}", input2.mouse_position());
32        }
33    }
34}

More examples

Hide additional examples

examples/software.rs (line 9)

6fn main() {
7    let mut runner = est_render::runner::new().expect("Failed to create runner");
8    let mut window = runner
9        .create_window("Engine Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut sw = est_render::software::new(Some(&mut window))
14        .build()
15        .expect("Failed to create pixel buffer");
16
17    let mut pixels = vec![128u32; (800 * 600) as usize];
18    let mut size_px = Point2::new(800.0, 600.0);
19
20    while runner.pump_events(None) {
21        for event in runner.get_events() {
22            match event {
23                Event::WindowClosed { .. } => {
24                    return;
25                }
26                Event::WindowResized { size, .. } => {
27                    pixels.resize((size.x * size.y) as usize, 128);
28                    size_px = Point2::new(size.x as f32, size.y as f32);
29                }
30                _ => {}
31            }
32        }
33
34        if let Err(e) = sw.write_buffers(&pixels, size_px) {
35            eprintln!("Error writing buffers: {}", e);
36        }
37    }
38}

examples/clear_color.rs (line 9)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Clear Color Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    while runner.pump_events(None) {
18        for event in runner.get_events() {
19            match event {
20                Event::WindowClosed { .. } => {
21                    return;
22                }
23                _ => {}
24            }
25        }
26
27        if let Ok(mut cmd) = gpu.begin_command() {
28            let surface = cmd.get_surface_texture();
29            if surface.is_err() {
30                println!("Failed to get surface texture: {:?}", surface.err());
31                continue;
32            }
33
34            // Or you could use `cmd.begin_renderpass()` directly
35            if let Ok(mut rp) = cmd.renderpass_builder()
36                .add_surface_color_attachment(surface.as_ref().unwrap(), Some(&BlendState::ALPHA_BLEND))
37                .build() 
38            {
39                rp.set_clear_color(Color::BLUE);
40            }
41        }
42    }
43}

examples/gpu_adapter.rs (line 8)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7    let mut window = runner
8        .create_window("Engine Example", Point2::new(800, 600))
9        .build()
10        .expect("Failed to create window");
11
12    let adapters = est_render::gpu::query_gpu_adapter(Some(&window));
13    if adapters.is_empty() {
14        eprintln!("No GPU adapters found. Exiting.");
15        return;
16    }
17
18    let selected_adapter = adapters
19        .iter()
20        .find(|adapter| adapter.backend_enum == AdapterBackend::Vulkan)
21        .cloned();
22
23    if selected_adapter.is_none() {
24        eprintln!("No suitable GPU adapter found. Exiting.");
25        return;
26    }
27
28    let adapter = selected_adapter.unwrap();
29    let mut gpu = est_render::gpu::new(Some(&mut window))
30        .set_adapter(&adapter)
31        .build()
32        .expect("Failed to create GPU");
33
34    while runner.pump_events(None) {
35        for event in runner.get_events() {
36            match event {
37                Event::WindowClosed { .. } => {
38                    return;
39                }
40                _ => {}
41            }
42        }
43
44        if let Ok(mut cmd) = gpu.begin_command() {
45            if let Ok(mut rp) = cmd.begin_renderpass() {
46                rp.set_clear_color(Color::LIGHTBLUE);
47            }
48        }
49    }
50}

examples/drawing.rs (line 9)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Drawing Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    let mut rotation = 0.0f32;
18    while runner.pump_events(None) {
19        for event in runner.get_events() {
20            match event {
21                Event::WindowClosed { .. } => {
22                    return;
23                }
24                _ => {}
25            }
26        }
27
28        rotation += runner.get_frame_time() as f32 * 60.0f32; // Rotate at 60 degrees per second
29        if rotation >= 360.0 {
30            rotation -= 360.0; // Reset rotation after a full circle
31        }
32
33        if let Ok(mut cmd) = gpu.begin_command() {
34            if let Ok(mut gp) = cmd.begin_renderpass() {
35                gp.set_clear_color(Color::BLUE); // Set the clear color to blue
36
37                if let Some(mut drawing) = gp.begin_drawing() {
38                    drawing.set_rotation(rotation); // Set rotation to 45 degrees
39                    gp.set_blend(0, Some(&BlendState::ALPHA_BLEND));
40                    drawing.draw_rect_filled(
41                        Vector2::new(100.0, 100.0),
42                        Vector2::new(200.0, 200.0),
43                        Color::RED,
44                    );
45
46                    drawing.draw_circle_filled(Vector2::new(400.0, 300.0), 50.0, 25, Color::GREEN);
47
48                    gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
49
50                    drawing.draw_text(
51                        "Hello, World!",
52                        Vector2::new(300.0, 500.0),
53                        Color::WHITE,
54                    );
55                }
56            }
57        }
58    }
59}

examples/font.rs (line 9)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Font Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    let mut font_manager = est_render::font::new();
18
19    let font = font_manager
20        .load_font("Arial", None, 20.0)
21        .expect("Failed to load font");
22
23    // Generate baked text texture
24    let texture = font
25        .create_baked_text(&mut gpu, "Hello, World!\nThis is a clear color example.", None)
26        .expect("Failed to create baked text");
27
28    while runner.pump_events(None) {
29        for event in runner.get_events() {
30            match event {
31                Event::WindowClosed { .. } => {
32                    return;
33                }
34                _ => {}
35            }
36        }
37
38        if let Ok(mut cmd) = gpu.begin_command() {
39            if let Ok(mut gp) = cmd.begin_renderpass() {
40                gp.set_clear_color(Color::BLUE);
41
42                // The best texture blend for font rendering, others may has artifacts like black borders
43                gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
44                
45                if let Some(mut drawing) = gp.begin_drawing() {
46                    let size: Vector2 = texture.size().into();
47
48                    // Baked text rendering
49                    drawing.set_texture(Some(&texture));
50                    drawing.draw_rect_image(Vector2::new(0.0, 0.0), size, Color::WHITE);
51
52                    // Online text rendering
53                    drawing.set_font(&font);
54                    drawing.draw_text(
55                        "Hello, World!\nThis is a clear color example.",
56                        Vector2::new(size.x, 0.0),
57                        Color::WHITE,
58                    );
59                }
60            }
61        }
62    }
63}

Additional examples can be found in:

Source

pub fn create_input(&mut self, window_id: Option<&Window>) -> Input

Creates a new [Input] instance for handling input events.

You can pass an optional Window reference to associate the input with a specific window. If no window is provided, the input will be global and not associated with any specific window.

You still need a Window created with Runner::create_window to receive input events.

Examples found in repository ?

examples/input.rs (line 18)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let _window = runner
9        .create_window("Input Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let window2 = runner
14        .create_window("Second Window", Point2::new(800, 600))
15        .build()
16        .expect("Failed to create second window");
17
18    let input = runner.create_input(None);
19    let mut input2 = runner.create_input(Some(&window2));
20
21    input2.listen_keyboard_event(|key, pressed| {
22        println!("Second window keyboard event: {} - {}", key, pressed);
23    });
24
25    while runner.pump_events(None) {
26        if input.mouse_pressed_once("Left") {
27            println!("Mouse position: {:?}", input.mouse_position());
28        }
29
30        if input2.mouse_pressed_once("Left") {
31            println!("Mouse position in second window: {:?}", input2.mouse_position());
32        }
33    }
34}

Source

pub fn pump_events<T>(&mut self, mode: T) -> bool
where T: Into<Option<PumpMode>>,

Pump the event loop and process events.

This method will block based on the provided mode.

[PollMode::Poll] will return immediately if there are no events.
[PollMode::Wait] will block until an event is available.
[PollMode::WaitDraw] will block until a redraw is requested (Recommended for MacOS platform).

You can also pass None to use the default behavior, which is equivalent to PollMode::Poll.

After calling this method, you can access the processed events using the Runner::get_events method.

§Incompatible platforms

iOS: This method is not supported on iOS due to platform limitations.
WASM: This method is not supported on WASM due to how the browser handles events, unless you using the emscripten event loop.

Examples found in repository ?

examples/input.rs (line 25)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let _window = runner
9        .create_window("Input Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let window2 = runner
14        .create_window("Second Window", Point2::new(800, 600))
15        .build()
16        .expect("Failed to create second window");
17
18    let input = runner.create_input(None);
19    let mut input2 = runner.create_input(Some(&window2));
20
21    input2.listen_keyboard_event(|key, pressed| {
22        println!("Second window keyboard event: {} - {}", key, pressed);
23    });
24
25    while runner.pump_events(None) {
26        if input.mouse_pressed_once("Left") {
27            println!("Mouse position: {:?}", input.mouse_position());
28        }
29
30        if input2.mouse_pressed_once("Left") {
31            println!("Mouse position in second window: {:?}", input2.mouse_position());
32        }
33    }
34}

More examples

Hide additional examples

examples/software.rs (line 20)

6fn main() {
7    let mut runner = est_render::runner::new().expect("Failed to create runner");
8    let mut window = runner
9        .create_window("Engine Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut sw = est_render::software::new(Some(&mut window))
14        .build()
15        .expect("Failed to create pixel buffer");
16
17    let mut pixels = vec![128u32; (800 * 600) as usize];
18    let mut size_px = Point2::new(800.0, 600.0);
19
20    while runner.pump_events(None) {
21        for event in runner.get_events() {
22            match event {
23                Event::WindowClosed { .. } => {
24                    return;
25                }
26                Event::WindowResized { size, .. } => {
27                    pixels.resize((size.x * size.y) as usize, 128);
28                    size_px = Point2::new(size.x as f32, size.y as f32);
29                }
30                _ => {}
31            }
32        }
33
34        if let Err(e) = sw.write_buffers(&pixels, size_px) {
35            eprintln!("Error writing buffers: {}", e);
36        }
37    }
38}

examples/clear_color.rs (line 17)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Clear Color Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    while runner.pump_events(None) {
18        for event in runner.get_events() {
19            match event {
20                Event::WindowClosed { .. } => {
21                    return;
22                }
23                _ => {}
24            }
25        }
26
27        if let Ok(mut cmd) = gpu.begin_command() {
28            let surface = cmd.get_surface_texture();
29            if surface.is_err() {
30                println!("Failed to get surface texture: {:?}", surface.err());
31                continue;
32            }
33
34            // Or you could use `cmd.begin_renderpass()` directly
35            if let Ok(mut rp) = cmd.renderpass_builder()
36                .add_surface_color_attachment(surface.as_ref().unwrap(), Some(&BlendState::ALPHA_BLEND))
37                .build() 
38            {
39                rp.set_clear_color(Color::BLUE);
40            }
41        }
42    }
43}

examples/gpu_adapter.rs (line 34)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7    let mut window = runner
8        .create_window("Engine Example", Point2::new(800, 600))
9        .build()
10        .expect("Failed to create window");
11
12    let adapters = est_render::gpu::query_gpu_adapter(Some(&window));
13    if adapters.is_empty() {
14        eprintln!("No GPU adapters found. Exiting.");
15        return;
16    }
17
18    let selected_adapter = adapters
19        .iter()
20        .find(|adapter| adapter.backend_enum == AdapterBackend::Vulkan)
21        .cloned();
22
23    if selected_adapter.is_none() {
24        eprintln!("No suitable GPU adapter found. Exiting.");
25        return;
26    }
27
28    let adapter = selected_adapter.unwrap();
29    let mut gpu = est_render::gpu::new(Some(&mut window))
30        .set_adapter(&adapter)
31        .build()
32        .expect("Failed to create GPU");
33
34    while runner.pump_events(None) {
35        for event in runner.get_events() {
36            match event {
37                Event::WindowClosed { .. } => {
38                    return;
39                }
40                _ => {}
41            }
42        }
43
44        if let Ok(mut cmd) = gpu.begin_command() {
45            if let Ok(mut rp) = cmd.begin_renderpass() {
46                rp.set_clear_color(Color::LIGHTBLUE);
47            }
48        }
49    }
50}

examples/drawing.rs (line 18)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Drawing Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    let mut rotation = 0.0f32;
18    while runner.pump_events(None) {
19        for event in runner.get_events() {
20            match event {
21                Event::WindowClosed { .. } => {
22                    return;
23                }
24                _ => {}
25            }
26        }
27
28        rotation += runner.get_frame_time() as f32 * 60.0f32; // Rotate at 60 degrees per second
29        if rotation >= 360.0 {
30            rotation -= 360.0; // Reset rotation after a full circle
31        }
32
33        if let Ok(mut cmd) = gpu.begin_command() {
34            if let Ok(mut gp) = cmd.begin_renderpass() {
35                gp.set_clear_color(Color::BLUE); // Set the clear color to blue
36
37                if let Some(mut drawing) = gp.begin_drawing() {
38                    drawing.set_rotation(rotation); // Set rotation to 45 degrees
39                    gp.set_blend(0, Some(&BlendState::ALPHA_BLEND));
40                    drawing.draw_rect_filled(
41                        Vector2::new(100.0, 100.0),
42                        Vector2::new(200.0, 200.0),
43                        Color::RED,
44                    );
45
46                    drawing.draw_circle_filled(Vector2::new(400.0, 300.0), 50.0, 25, Color::GREEN);
47
48                    gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
49
50                    drawing.draw_text(
51                        "Hello, World!",
52                        Vector2::new(300.0, 500.0),
53                        Color::WHITE,
54                    );
55                }
56            }
57        }
58    }
59}

examples/font.rs (line 28)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Font Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    let mut font_manager = est_render::font::new();
18
19    let font = font_manager
20        .load_font("Arial", None, 20.0)
21        .expect("Failed to load font");
22
23    // Generate baked text texture
24    let texture = font
25        .create_baked_text(&mut gpu, "Hello, World!\nThis is a clear color example.", None)
26        .expect("Failed to create baked text");
27
28    while runner.pump_events(None) {
29        for event in runner.get_events() {
30            match event {
31                Event::WindowClosed { .. } => {
32                    return;
33                }
34                _ => {}
35            }
36        }
37
38        if let Ok(mut cmd) = gpu.begin_command() {
39            if let Ok(mut gp) = cmd.begin_renderpass() {
40                gp.set_clear_color(Color::BLUE);
41
42                // The best texture blend for font rendering, others may has artifacts like black borders
43                gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
44                
45                if let Some(mut drawing) = gp.begin_drawing() {
46                    let size: Vector2 = texture.size().into();
47
48                    // Baked text rendering
49                    drawing.set_texture(Some(&texture));
50                    drawing.draw_rect_image(Vector2::new(0.0, 0.0), size, Color::WHITE);
51
52                    // Online text rendering
53                    drawing.set_font(&font);
54                    drawing.draw_text(
55                        "Hello, World!\nThis is a clear color example.",
56                        Vector2::new(size.x, 0.0),
57                        Color::WHITE,
58                    );
59                }
60            }
61        }
62    }
63}

Additional examples can be found in:

Source

pub fn set_rate(&mut self, rate: Option<Duration>)

Set the rate (frame rate) for the event loop.

This only useful if you want to control the frame rate of the event loop. Not effective if you use PollMode::Wait or PollMode::WaitDraw, or multi window mode, or multiple threads.

Source

pub fn set_target_fps(&mut self, fps: u32)

Set the target frames per second (FPS) for the event loop.

This only useful if you want to control the frame rate of the event loop. Not effective if you use PollMode::Wait or PollMode::WaitDraw, or multi window mode, or multiple threads.

Source

pub fn get_target_fps(&self) -> u32

Get the current frame rate (FPS) of the event loop.

This only useful if you want to control the frame rate of the event loop. Not effective if you use PollMode::Wait or PollMode::WaitDraw, or multi window mode, or multiple threads.

Source

pub fn get_frame_time(&self) -> f64

Get the time taken for each frame in milliseconds.

This only useful if you want to control the frame rate of the event loop. Not effective if you use PollMode::Wait or PollMode::WaitDraw, or multi window mode, or multiple threads.

Examples found in repository ?

examples/drawing.rs (line 28)

5fn main() {
6    let mut runner = est_render::runner::new().expect("Failed to create runner");
7
8    let mut window = runner
9        .create_window("Drawing Example", Point2::new(800, 600))
10        .build()
11        .expect("Failed to create window");
12
13    let mut gpu = est_render::gpu::new(Some(&mut window))
14        .build()
15        .expect("Failed to create GPU");
16
17    let mut rotation = 0.0f32;
18    while runner.pump_events(None) {
19        for event in runner.get_events() {
20            match event {
21                Event::WindowClosed { .. } => {
22                    return;
23                }
24                _ => {}
25            }
26        }
27
28        rotation += runner.get_frame_time() as f32 * 60.0f32; // Rotate at 60 degrees per second
29        if rotation >= 360.0 {
30            rotation -= 360.0; // Reset rotation after a full circle
31        }
32
33        if let Ok(mut cmd) = gpu.begin_command() {
34            if let Ok(mut gp) = cmd.begin_renderpass() {
35                gp.set_clear_color(Color::BLUE); // Set the clear color to blue
36
37                if let Some(mut drawing) = gp.begin_drawing() {
38                    drawing.set_rotation(rotation); // Set rotation to 45 degrees
39                    gp.set_blend(0, Some(&BlendState::ALPHA_BLEND));
40                    drawing.draw_rect_filled(
41                        Vector2::new(100.0, 100.0),
42                        Vector2::new(200.0, 200.0),
43                        Color::RED,
44                    );
45
46                    drawing.draw_circle_filled(Vector2::new(400.0, 300.0), 50.0, 25, Color::GREEN);
47
48                    gp.set_blend(0, Some(&BlendState::ADDITIVE_BLEND));
49
50                    drawing.draw_text(
51                        "Hello, World!",
52                        Vector2::new(300.0, 500.0),
53                        Color::WHITE,
54                    );
55                }
56            }
57        }
58    }
59}

Auto Trait Implementations§

§

impl !UnwindSafe for Runner

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