Struct EguiUiBuilder 

pub struct EguiUiBuilder<'a> { /* private fields */ }

Wraps &mut egui::Ui to implement the abstract [UiBuilder] trait.

Implementations

impl<'a> EguiUiBuilder<'a>

pub fn new( ui: &'a mut Ui, viewport_textures: &'a HashMap<ViewportTextureHandle, TextureId>, ) -> Self

Creates a new builder wrapping the given egui UI region.

Trait Implementations

impl UiBuilder for EguiUiBuilder<'_>

fn heading(&mut self, text: &str)

Large heading text.

fn label(&mut self, text: &str)

Normal label text.

fn colored_label(&mut self, color: [f32; 4], text: &str)

Colored label.

fn small_label(&mut self, text: &str)

Small / secondary label.

fn monospace(&mut self, text: &str)

Monospaced text (for code / log output).

fn button(&mut self, text: &str) -> bool

Push-button. Returns true the frame it is clicked.

fn small_button(&mut self, text: &str) -> bool

Small push-button (less padding).

fn selectable_label(&mut self, active: bool, text: &str) -> bool

Selectable label — highlights when active is true. Returns true when clicked.

fn selectable_label_double_clicked(&mut self, active: bool, text: &str) -> bool

Selectable label that returns true when double-clicked.

fn checkbox(&mut self, checked: &mut bool, text: &str) -> bool

Boolean checkbox. Returns true when toggled.

fn drag_value_f32(&mut self, label: &str, value: &mut f32, speed: f32) -> bool

Draggable f32 value. Returns true when changed.

fn slider_f32( &mut self, label: &str, value: &mut f32, min: f32, max: f32, ) -> bool

Slider for f32. Returns true when changed.

fn text_edit_singleline(&mut self, text: &mut String) -> bool

Single-line text input. Returns true when changed.

fn vec3_editor(&mut self, label: &str, value: &mut [f32; 3], speed: f32) -> bool

Editable Vec3 as three drag-values (X / Y / Z). Returns true when any component changed.

fn color_edit(&mut self, label: &str, color: &mut [f32; 4]) -> bool

RGBA color picker. Returns true when changed.

fn combo_box( &mut self, id_salt: &str, label: &str, current: &mut usize, options: &[&str], ) -> bool

Drop-down combo box picking among string options. current is the index of the currently selected item. Returns true when the selection changed. Dropdown over options, writing the picked index into current.

fn horizontal(&mut self, f: &mut dyn FnMut(&mut dyn UiBuilder))

Horizontal layout — children placed left-to-right.

fn vertical(&mut self, f: &mut dyn FnMut(&mut dyn UiBuilder))

Vertical layout (default, but useful inside a horizontal).

fn collapsing( &mut self, header: &str, default_open: bool, f: &mut dyn FnMut(&mut dyn UiBuilder), )

Collapsible section with a header.

fn indent(&mut self, id: &str, f: &mut dyn FnMut(&mut dyn UiBuilder))

Indented block.

fn scroll_area(&mut self, id: &str, f: &mut dyn FnMut(&mut dyn UiBuilder))

Scrollable area.

fn viewport_image( &mut self, handle: ViewportTextureHandle, size: [f32; 2], ) -> Option<[f32; 2]>

Display a viewport texture at the given size.

fn separator(&mut self)

Horizontal separator line.

fn spacing(&mut self, points: f32)

Blank vertical spacing (in logical points).

fn is_last_item_double_clicked(&self) -> bool

Returns true if the last widget was double-clicked.

fn is_last_item_hovered(&self) -> bool

Returns true if the last widget is currently hovered by the pointer.

fn is_last_item_enter_pressed(&self) -> bool

Returns true if Enter was pressed while the last widget had focus.

fn is_last_item_escape_pressed(&self) -> bool

Returns true if Escape was pressed while the last widget had focus.

fn context_menu_last(&mut self, f: &mut dyn FnMut(&mut dyn UiBuilder))

Shows a right-click context menu on the last widget. The closure is called to build menu content when the menu is open.

fn context_menu_panel(&mut self, f: &mut dyn FnMut(&mut dyn UiBuilder))

Shows a right-click context menu when the user right-clicks anywhere on the current panel background (not on a specific widget).

fn close_menu(&mut self)

Close the currently open context menu (if any).

fn menu_button(&mut self, label: &str, f: &mut dyn FnMut(&mut dyn UiBuilder))

Shows a sub-menu button inside a context menu. Unlike collapsing, this creates a proper egui sub-menu that doesn’t steal focus from the parent context menu.

fn paint_line( &mut self, from: [f32; 2], to: [f32; 2], color: [f32; 4], thickness: f32, )

Paints a line in window-space coordinates.

fn paint_rect_filled( &mut self, min: [f32; 2], size: [f32; 2], color: [f32; 4], rounding: f32, )

Paints a filled rectangle in window-space coordinates.

fn paint_text(&mut self, pos: [f32; 2], color: [f32; 4], text: &str)

Paints text at a window-space position.

fn available_width(&self) -> f32

Available width in the current layout region.

fn available_height(&self) -> f32

Available height in the current layout region.

fn panel_rect(&self) -> [f32; 4]

Returns the current paint region in screen-space coordinates as [min_x, min_y, width, height].

fn screen_rect(&self) -> [f32; 4]

Returns the full screen size (top-left = (0, 0)) as [min_x, min_y, width, height].

fn paint_rect_stroke( &mut self, min: [f32; 2], size: [f32; 2], color: [f32; 4], rounding: f32, thickness: f32, )

Paints a stroked (outlined) rectangle in window-space.

fn paint_circle_filled( &mut self, center: [f32; 2], radius: f32, color: [f32; 4], )

Paints a filled circle.

fn paint_circle_stroke( &mut self, center: [f32; 2], radius: f32, color: [f32; 4], thickness: f32, )

Paints a circle outline.

fn paint_text_styled( &mut self, pos: [f32; 2], text: &str, size: f32, color: [f32; 4], family: FontFamilyHint, align: TextAlign, )

Paints text with explicit size, font family and alignment.

fn paint_path_filled(&mut self, points: &[[f32; 2]], color: [f32; 4])

Paints a closed polygon path (for diamonds, triangles, custom shapes). points is a list of [x, y] window-space coordinates.

fn interact_rect(&mut self, id_salt: &str, rect: [f32; 4]) -> Interaction

Allocates a clickable region at the given absolute window-space rect and reports interaction this frame. The id_salt disambiguates overlapping or repeatedly-painted hot regions.

fn key_pressed(&self, key: KeyCode) -> bool

Whether key was pressed this frame and no text field is consuming keyboard input.

fn keyboard_captured(&self) -> bool

Whether any widget currently holds keyboard focus — typically a text field being typed into.

fn raw_key_pressed(&self, key: KeyCode) -> bool

Whether key was pressed this frame, regardless of focus.

fn focus_last_item(&mut self)

Asks the backend to give the last widget keyboard focus.

fn push_clip_rect(&mut self, rect: [f32; 4])

Restricts painting to rect until the matching pop_clip_rect.

fn pop_clip_rect(&mut self)

Restores the clip region saved by push_clip_rect.

fn scroll_delta_in(&self, rect: [f32; 4]) -> f32

Accumulated scroll-wheel delta this frame while the pointer is inside rect, in points. Positive means the content should move down (the user scrolled towards the top of the list).

fn dnd_attach_drag_payload(&mut self, payload: u64)

Attaches a drag payload (typically an entity ID packed into a u64) to the last interacted region (the most recent interact_rect call). Should be called immediately after interact_rect. Avoids creating a competing hit-target on the same rect, which would steal pointer events. Default: no-op.

fn dnd_take_drop_payload(&mut self) -> Option<u64>

If a drag-and-drop just released on the last interacted region, returns its u64 payload. Should be called after interact_rect. Default: no-op.

fn pointer_position(&self) -> Option<[f32; 2]>

Current pointer (cursor) position in window-space [x, y], or None when the pointer is outside the window or unknown. Drop targets use this to place a dropped item where the cursor released (e.g. unproject the drop point into the 3D scene). Default: None.

fn is_last_item_dragged(&self) -> bool

Returns true if the last interacted region is currently being dragged. Used by drag sources to paint a cursor-following ghost so the user can see a drag is in progress. Default: false.

fn is_drag_active(&self) -> bool

true while any u64 drag payload is in flight this frame (a drag started and hasn’t been released). Drop targets use it to show a “droppable here” highlight. Default: false.

fn inline_text_field( &mut self, rect: [f32; 4], id_salt: &str, text: &mut String, request_focus: bool, ) -> InlineEditEvent

Draws a single-line text editor at an absolute window-space rect and returns its outcome this frame (see [InlineEditEvent]). Unlike the generic region_at + response-tracking helpers, this is self-contained: it owns the widget’s Response, so Enter / Escape / focus-loss are detected reliably. Pass request_focus = true on the frame the field first appears so the user can type immediately. Default: no-op returning [InlineEditEvent::Idle].

fn overlay_rect_filled( &mut self, min: [f32; 2], size: [f32; 2], color: [f32; 4], rounding: f32, )

Paints a filled rounded rect in an unclipped top overlay layer (above all panels). For cursor-following affordances like drag ghosts that must remain visible outside the current panel’s clip rect. Default: no-op.

fn overlay_rect_stroke( &mut self, min: [f32; 2], size: [f32; 2], color: [f32; 4], rounding: f32, thickness: f32, )

Stroked rounded rect in the unclipped overlay layer. See overlay_rect_filled. Default: no-op.

fn overlay_text( &mut self, pos: [f32; 2], text: &str, size: f32, color: [f32; 4], family: FontFamilyHint, )

Text in the unclipped overlay layer. See overlay_rect_filled. Default: no-op.

fn tooltip_for_last(&mut self, text: &str)

Attaches a tooltip to the most recently created widget / interaction.

fn region_at( &mut self, id_salt: &str, rect: [f32; 4], f: &mut dyn FnMut(&mut dyn UiBuilder), )

Pushes a child layout region at the given absolute screen-space rect. Inside the closure, &mut dyn UiBuilder reflects the constrained region — egui-native widgets (button, text_edit_singleline, vec3_editor, …) lay out within it instead of the parent panel. Used by composite widgets (inspector cards) that paint their frame absolutely but want native egui controls inside.

fn cursor_pos(&self) -> [f32; 2]

Returns the current layout cursor in screen-space (x, y). Useful for composites that need to know where to place an absolutely-painted frame before advancing egui’s natural layout.

fn allocate_size(&mut self, size: [f32; 2]) -> [f32; 4]

Allocates [width, height] of space at the current cursor in the active layout direction. Returns the resulting rect as [x, y, w, h] — feed it to the paint primitives.

fn measure_text( &self, text: &str, size: f32, family: FontFamilyHint, ) -> [f32; 2]

Measures the rendered size of text at size points using family. Returns [width, height] in logical points.

fn top_inset_panel( &mut self, id: &str, height: f32, f: &mut dyn FnMut(&mut dyn UiBuilder), )

Inset panel along the top edge of the current region.

fn bottom_inset_panel( &mut self, id: &str, height: f32, f: &mut dyn FnMut(&mut dyn UiBuilder), )

Inset panel along the bottom edge — counterpart of top_inset_panel.

fn left_inset_panel( &mut self, id: &str, width: f32, f: &mut dyn FnMut(&mut dyn UiBuilder), )

Inset sidebar on the left edge of the current region.

fn right_inset_panel( &mut self, id: &str, width: f32, f: &mut dyn FnMut(&mut dyn UiBuilder), )

Inset sidebar on the right edge — counterpart of left_inset_panel.

fn central_inset(&mut self, f: &mut dyn FnMut(&mut dyn UiBuilder))

Central region — fills whatever space remains after the inset panels above were placed.

fn modal( &mut self, id: &str, size: [f32; 2], f: &mut dyn FnMut(&mut dyn UiBuilder), )

Open a modal dialog overlaid on top of the current screen.

fn frame_box( &mut self, margin: Margin, fill: Option<LinearRgba>, stroke: Stroke, radius: CornerRadius, f: &mut dyn FnMut(&mut dyn UiBuilder), )

Wraps f in a visual frame: paints the optional fill / stroke / rounded background first, then runs f inside the inner content rect (after applying margin).