Struct MiniquadPixels

pub struct MiniquadPixels {
    pub pixels: Vec<u8>,
    /* private fields */
}

Available on crate features alloc and dep_miniquad only.

Draws a single fullscreen quad textured by a pixel buffer.

Fields

pixels: Vec<u8>

Implementations

impl MiniquadPixels

pub fn new(width: u32, height: u32) -> Self

Returns an uninitialized pixel-? stage with the given buffer size.

By default it maintains the aspect ratio, and doesn’t interpolate.

pub fn viewport(&self) -> (f32, f32, f32, f32)

Returns the current viewport size

pub fn init(self) -> Self

Initialize the pixel buffer stage.

This method performs the following steps:

• Creates a new rendering backend context.
• Defines a fullscreen quad in normalized device coordinates.
  • The vertex shader will flip the y-axis to match the pixel buffer’s top-left origin.
  • If maintain_aspect_ratio == true it will be letterboxed to maintain proportion, otherwise it will be rendered covering the entire screen from (-1, -1) to (1, 1).
• Creates a texture from the pixel data with the specified size, and filtering mode.
• Compiles the vertex and fragment shaders.
• Sets up the rendering pipeline.
• Returns the initialized MiniquadPixels instance.

Trait Implementations

impl Debug for MiniquadPixels

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

Formats the value using the given formatter.

impl EventHandler for MiniquadPixels

fn update(&mut self)

On most platforms update() and draw() are called each frame, sequentially, draw right after update. But on Android (and maybe some other platforms in the future) update might be called without draw. When the app is in background, Android destroys the rendering surface, while app is still alive and can do some usefull calculations. Note that in this case drawing from update may lead to crashes.

fn draw(&mut self)

fn resize_event(&mut self, _width: f32, _height: f32)

fn mouse_motion_event(&mut self, _x: f32, _y: f32)

fn mouse_wheel_event(&mut self, _x: f32, _y: f32)

fn mouse_button_down_event(&mut self, _button: MouseButton, _x: f32, _y: f32)

fn mouse_button_up_event(&mut self, _button: MouseButton, _x: f32, _y: f32)

fn char_event(&mut self, _character: char, _keymods: KeyMods, _repeat: bool)

fn key_down_event( &mut self, _keycode: KeyCode, _keymods: KeyMods, _repeat: bool, )

fn key_up_event(&mut self, _keycode: KeyCode, _keymods: KeyMods)

fn touch_event(&mut self, phase: TouchPhase, _id: u64, x: f32, y: f32)

Default implementation emulates mouse clicks

fn raw_mouse_motion(&mut self, _dx: f32, _dy: f32)

Represents raw hardware mouse motion event Note that these events are delivered regardless of input focus and not in pixels, but in hardware units instead. And those units may be different from pixels depending on the target platform

fn window_minimized_event(&mut self)

Window has been minimized Right now is only implemented on Android, X11 and wasm, On Andoid window_minimized_event is called on a Pause ndk callback On X11 and wasm it will be called on focus change events.

fn window_restored_event(&mut self)

Window has been restored Right now is only implemented on Android, X11 and wasm, On Andoid window_minimized_event is called on a Pause ndk callback On X11 and wasm it will be called on focus change events.

fn quit_requested_event(&mut self)

This event is sent when the userclicks the window’s close button or application code calls the ctx.request_quit() function. The event handler callback code can handle this event by calling ctx.cancel_quit() to cancel the quit. If the event is ignored, the application will quit as usual.

fn files_dropped_event(&mut self)

A file has been dropped over the application. Applications can request the number of dropped files with ctx.dropped_file_count(), path of an individual file with ctx.dropped_file_path(), and for wasm targets the file bytes can be requested with ctx.dropped_file_bytes().

impl MiniquadEventHandlerExt for MiniquadPixels

fn init(self) -> Self

Returns the event handler initialized.

fn interpolation(&self) -> bool

Whether it interpolates the scaled pixels.

fn set_interpolation(&mut self, set: bool)

Set whether to interpolate the scaled pixels.

fn maintain_aspect_ratio(&self) -> bool

Whether the aspect ratio is maintained on window resize.

fn set_maintain_aspect_ratio(&mut self, set: bool)

Set whether to maintain the aspect ratio on window resize.