Struct LayerPass

pub struct LayerPass<'a> {
    pub cmds: &'a [DrawCmd],
    pub clip: ClipStackSnapshot,
    pub clip_plan: RenderClipPlan,
    pub isolated: bool,
    pub isolated_depth: u8,
    pub effects: IsolatedEffects,
}

One scene layer: draw commands plus a non-destructive clip stack.

isolated == true requests an offscreen pass when [IsolatedEffects::needs_offscreen] is true (opacity < 1, blur, etc.). isolated compositor renders content to a pooled texture, runs the effect chain, then composites into the main pass.

Examples

use ailloli_ui_render_wgpu::LayerPass;

let layer = LayerPass::new(&[]);
assert!(layer.cmds.is_empty());
assert!(!layer.isolated);

Fields

cmds: &'a [DrawCmd]

Draw commands in stable painter’s order.

clip: ClipStackSnapshot

Immutable snapshot of nested clip entries for this layer.

clip_plan: RenderClipPlan

Resolved scissor/shader/stencil policy for Self::clip.

isolated: bool

Whether the runtime requested isolated compositing.

isolated_depth: u8

Nesting depth from runtime (PaintContext); 0 for flat isolated layers.

effects: IsolatedEffects

Opacity, filters, backdrop, and blend effects for isolated compositing.

Implementations

impl<'a> LayerPass<'a>

pub fn new(cmds: &'a [DrawCmd]) -> Self

Creates an unclipped, non-isolated layer.

Examples

use ailloli_ui_render_wgpu::LayerPass;

let layer = LayerPass::new(&[]);
assert!(layer.clip.is_empty());
assert!(!layer.isolated);

pub fn with_clip_stack(cmds: &'a [DrawCmd], clip: ClipStackSnapshot) -> Self

Creates a non-isolated layer and resolves its clip rendering plan.

Command count participates in choosing shader versus stencil clipping.

Examples

use ailloli_ui_render_wgpu::LayerPass;
use ailloli_ui_runtime::scene::ClipStackSnapshot;

let layer = LayerPass::with_clip_stack(&[], ClipStackSnapshot::empty());
assert!(layer.clip.is_empty());

pub fn from_scene_layer( cmds: &'a [DrawCmd], clip: ClipStackSnapshot, isolated: bool, isolated_depth: u8, effects: IsolatedEffects, ) -> Self

Converts runtime scene-layer metadata into a renderer layer.

isolated_depth is the runtime nesting depth; zero represents a flat isolated layer. Effects are retained even when isolation later downgrades under budget pressure.

Examples

use ailloli_ui_render_wgpu::LayerPass;
use ailloli_ui_runtime::{scene::ClipStackSnapshot, IsolatedEffects};

let layer = LayerPass::from_scene_layer(
    &[],
    ClipStackSnapshot::empty(),
    true,
    1,
    IsolatedEffects::default(),
);
assert!(layer.isolated);
assert_eq!(layer.isolated_depth, 1);

pub fn with_clip(cmds: &'a [DrawCmd], clip: ClipShape) -> Self

Creates a non-isolated layer with one ordinary clip shape.

Examples

use ailloli_ui_core::{ClipShape, Rect};
use ailloli_ui_render_wgpu::LayerPass;

let layer = LayerPass::with_clip(
    &[],
    ClipShape::Rect(Rect::new(0.0, 0.0, 20.0, 10.0)),
);
assert!(!layer.clip.is_empty());

pub fn with_window_root_clip(cmds: &'a [DrawCmd], clip: ClipShape) -> Self

Creates a clipped layer whose single clip is the window root.

Root status can force stencil selection for rounded window chrome.

Examples

use ailloli_ui_core::{ClipShape, Rect};
use ailloli_ui_render_wgpu::LayerPass;

let layer = LayerPass::with_window_root_clip(
    &[],
    ClipShape::Rect(Rect::new(0.0, 0.0, 20.0, 10.0)),
);
assert!(!layer.clip.is_empty());

pub fn new_isolated(cmds: &'a [DrawCmd]) -> Self

Isolated layer with default effects (collapsed into main pass if noop).

Examples

use ailloli_ui_render_wgpu::LayerPass;

let layer = LayerPass::new_isolated(&[]);
assert!(layer.isolated);

pub fn with_clip_stack_isolated( cmds: &'a [DrawCmd], clip: ClipStackSnapshot, ) -> Self

Same as with_clip_stack but marks the layer as isolated.

Examples

use ailloli_ui_render_wgpu::LayerPass;
use ailloli_ui_runtime::scene::ClipStackSnapshot;

let layer = LayerPass::with_clip_stack_isolated(&[], ClipStackSnapshot::empty());
assert!(layer.isolated);

pub fn with_clip_stack_isolated_effects( cmds: &'a [DrawCmd], clip: ClipStackSnapshot, effects: IsolatedEffects, ) -> Self

Creates an isolated layer with an explicit effect set.

The layer may later collapse into the main pass when the effects are a no-op or isolation is downgraded by the configured budget.

Examples

use ailloli_ui_render_wgpu::LayerPass;
use ailloli_ui_runtime::{scene::ClipStackSnapshot, IsolatedEffects};

let effects = IsolatedEffects::default();
let layer = LayerPass::with_clip_stack_isolated_effects(
    &[], ClipStackSnapshot::empty(), effects,
);
assert!(layer.isolated);

Trait Implementations

impl<'a> Clone for LayerPass<'a>

fn clone(&self) -> LayerPass<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for LayerPass<'a>

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

Formats the value using the given formatter.