Struct egui::InputState

pub struct InputState {

    pub raw: RawInput,
    pub pointer: PointerState,
    pub scroll_delta: Vec2,
    pub screen_rect: Rect,
    pub pixels_per_point: f32,
    pub max_texture_side: usize,
    pub time: f64,
    pub unstable_dt: f32,
    pub predicted_dt: f32,
    pub stable_dt: f32,
    pub modifiers: Modifiers,
    pub keys_down: HashSet<Key>,
    pub events: Vec<Event>,
    /* private fields */
}

Input state that egui updates each frame.

You can check if egui is using the inputs using crate::Context::wants_pointer_input and crate::Context::wants_keyboard_input.

Fields

raw: RawInput

The raw input we got this frame from the backend.

pointer: PointerState

State of the mouse or simple touch gestures which can be mapped to mouse operations.

scroll_delta: Vec2

How many points the user scrolled.

The delta dictates how the content should move.

A positive X-value indicates the content is being moved right, as when swiping right on a touch-screen or track-pad with natural scrolling.

A positive Y-value indicates the content is being moved down, as when swiping down on a touch-screen or track-pad with natural scrolling.

screen_rect: Rect

Position and size of the egui area.

pixels_per_point: f32

Also known as device pixel ratio, > 1 for high resolution screens.

max_texture_side: usize

Maximum size of one side of a texture.

This depends on the backend.

time: f64

Time in seconds. Relative to whatever. Used for animation.

unstable_dt: f32

Time since last frame, in seconds.

This can be very unstable in reactive mode (when we don’t paint each frame). For animations it is therefore better to use Self::stable_dt.

predicted_dt: f32

Estimated time until next frame (provided we repaint right away).

Used for animations to get instant feedback (avoid frame delay). Should be set to the expected time between frames when painting at vsync speeds.

On most integrations this has a fixed value of 1.0 / 60.0, so it is not a very accurate estimate.

stable_dt: f32

Time since last frame (in seconds), but gracefully handles the first frame after sleeping in reactive mode.

In reactive mode (available in e.g. eframe), egui only updates when there is new input or something is animating. This can lead to large gaps of time (sleep), leading to large Self::unstable_dt.

If egui requested a repaint the previous frame, then egui will use stable_dt = unstable_dt;, but if egui did not not request a repaint last frame, then egui will assume unstable_dt is too large, and will use stable_dt = predicted_dt;.

This means that for the first frame after a sleep, stable_dt will be a prediction of the delta-time until the next frame, and in all other situations this will be an accurate measurement of time passed since the previous frame.

Note that a frame can still stall for various reasons, so stable_dt can still be unusually large in some situations.

When animating something, it is recommended that you use something like stable_dt.min(0.1) - this will give you smooth animations when the framerate is good (even in reactive mode), but will avoid large jumps when framerate is bad, and will effectively slow down the animation when FPS drops below 10.

modifiers: Modifiers

Which modifier keys are down at the start of the frame?

keys_down: HashSet<Key>

events: Vec<Event>

In-order events received this frame

Implementations

impl InputState

pub fn begin_frame(
    self,
    new: RawInput,
    requested_repaint_last_frame: bool
) -> InputState

pub fn screen_rect(&self) -> Rect

pub fn zoom_delta(&self) -> f32

Zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).

• zoom = 1: no change
• zoom < 1: pinch together
• zoom > 1: pinch spread

pub fn zoom_delta_2d(&self) -> Vec2

2D non-proportional zoom scale factor this frame (e.g. from ctrl-scroll or pinch gesture).

For multitouch devices the user can do a horizontal or vertical pinch gesture. In these cases a non-proportional zoom factor is a available. In other cases, this reverts to Vec2::splat(self.zoom_delta()).

For horizontal pinches, this will return [z, 1], for vertical pinches this will return [1, z], and otherwise this will return [z, z], where z is the zoom factor:

• zoom = 1: no change
• zoom < 1: pinch together
• zoom > 1: pinch spread

pub fn wants_repaint(&self) -> bool

pub fn consume_key(&mut self, modifiers: Modifiers, key: Key) -> bool

Check for a key press. If found, true is returned and the key pressed is consumed, so that this will only return true once.

pub fn key_pressed(&self, desired_key: Key) -> bool

Was the given key pressed this frame?

pub fn num_presses(&self, desired_key: Key) -> usize

How many times were the given key pressed this frame?

pub fn key_down(&self, desired_key: Key) -> bool

Is the given key currently held down?

pub fn key_released(&self, desired_key: Key) -> bool

Was the given key released this frame?

pub fn pixels_per_point(&self) -> f32

Also known as device pixel ratio, > 1 for high resolution screens.

pub fn physical_pixel_size(&self) -> f32

Size of a physical pixel in logical gui coordinates (points).

pub fn aim_radius(&self) -> f32

How imprecise do we expect the mouse/touch input to be? Returns imprecision in points.

pub fn multi_touch(&self) -> Option<MultiTouchInfo>

Returns details about the currently ongoing multi-touch gesture, if any. Note that this method returns None for single-touch gestures (click, drag, …).

let mut zoom = 1.0; // no zoom
let mut rotation = 0.0; // no rotation
let multi_touch = ui.input().multi_touch();
if let Some(multi_touch) = multi_touch {
    zoom *= multi_touch.zoom_delta;
    rotation += multi_touch.rotation_delta;
}
let transform = zoom * Rot2::from_angle(rotation);

By far not all touch devices are supported, and the details depend on the egui integration backend you are using. eframe web supports multi touch for most mobile devices, but not for a Trackpad on MacOS, for example. The backend has to be able to capture native touch events, but many browsers seem to pass such events only for touch screens, but not touch pads.

Refer to MultiTouchInfo for details about the touch information available.

Consider using zoom_delta() instead of MultiTouchInfo::zoom_delta as the former delivers a synthetic zoom factor based on ctrl-scroll events, as a fallback.

pub fn any_touches(&self) -> bool

True if there currently are any fingers touching egui.

impl InputState

pub fn ui(&self, ui: &mut Ui)

Trait Implementations

impl Clone for InputState

fn clone(&self) -> InputState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InputState

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

Formats the value using the given formatter.

impl Default for InputState

fn default() -> Self

Returns the “default value” for a type.