Struct OutputNode 

pub struct OutputNode {

    pub id: u32,
    pub output: Output,
    pub global: Option<GlobalId>,
    pub owner: Option<u32>,
    pub view_size: (i32, i32),
    pub view_scale: f64,
    pub pos: (i32, i32),
    pub damage_tracker: OutputDamageTracker,
    pub content_tracker: Option<OutputDamageTracker>,
    pub frame_buffer: Vec<u8>,
    pub offscreen_buffer: Option<(BufferObject<()>, Dmabuf)>,
    pub undrawn_ticks: u32,
    pub overlay_state: OverlayState,
    pub capture: Option<WlCapture>,
    pub frame_seq: u64,
    pub target_seeded: bool,
    pub content_hold_until: Option<Instant>,
}

One virtual output and everything sized to it: the Smithay Output + its advertised global, its layout position, the damage tracker, render targets, and the (at most one) capture bound to it. id is the Python-facing display key; id 0 is the primary HEADLESS-1 output, which is never destroyed.

Fields

id: u32

output: Output

global: Option<GlobalId>

The wl_output global this node published, and None for a view: a view captures a rectangle of another node’s output rather than a screen of its own, so it publishes nothing and the session sees one screen for all the views over it. That is what keeps a pointer grab – a window drag – inside one surface as it crosses from one display to the next.

owner: Option<u32>

The node whose output this one is a view of; None when it owns its output.

view_size: (i32, i32)

The rectangle size a view’s damage tracker was built for, so a display that changes resolution rebuilds it rather than tracking damage for the old one.

view_scale: f64

The scale the view’s tracker maps windows with; a screen’s tracker follows its output.

pos: (i32, i32)

Layout offset: the output’s logical position in the Space AND its physical offset for absolute input injection. The two coincide at scale 1; with mixed scales the caller must place outputs so neither the logical nor the physical rectangles overlap.

damage_tracker: OutputDamageTracker

content_tracker: Option<OutputDamageTracker>

What changed on the output between one software-rendered frame and the next, apart from damage_tracker’s answer, which is what the buffer rendered into has to have repainted: that render goes straight into a pool buffer, and one the encoder held through a slow frame is older than the tracker’s history, so repainting it damages the whole output though nothing on it changed. Built on the first such frame, and again after the output changes size.

frame_buffer: Vec<u8>

Host-side scratch target: pixman throttle path renders here, GLES screenshots read back here.

offscreen_buffer: Option<(BufferObject<()>, Dmabuf)>

GPU render target for this output (GLES mode): the GBM BO and its dmabuf export.

undrawn_ticks: u32

Render ticks in a row that drew nothing on the target (UNDRAWN_TICKS_PER_FRAME).

overlay_state: OverlayState

Watermark overlay for THIS output: loaded at the output’s scale, positioned (and, for the bouncing anchor, animated) against the output’s own frame dimensions.

capture: Option<WlCapture>

frame_seq: u64

Monotonic count of frames reported presented through wp_presentation.

target_seeded: bool

Whether the render target already holds a fully composited frame, so a capture-less render (screenshot, copy-capture client) may use buffer age instead of redrawing everything. Cleared whenever the target is replaced.

content_hold_until: Option<Instant>

Deadline for this output’s post-reconfigure content hold. While it is set, the display composites but does not publish: a resized or freshly created output paints its clear color wherever a client has not yet answered the new size, and that gray must not reach the stream. Cleared by the first tick a client covers the output, and by the deadline for one that never does.

Implementations

impl OutputNode

pub fn logical_geometry(&self) -> Option<Rectangle<i32, Logical>>

The output’s logical geometry in layout coordinates: origin plus mode/scale-derived logical size. A view’s size is its own rectangle – the mode belongs to the screen it is cut from.