use crate::diagnostics::PacketRebuildReason;
use crate::diagnostics::RetainedPacketRebuildStats;
use crate::draw::DrawOpArena;
use crate::geometry::hash_path;
use crate::geometry::hash_point;
use crate::geometry::hash_rect;
use crate::geometry::hash_transform;
use crate::geometry::transform_scene_path;
use crate::path_cache::PathMeshCache;
#[cfg(test)]
use crate::resources::DEFAULT_FEATHER_WIDTH;
use crate::scene::DirectPacketBuildDiagnostics;
use crate::scene::build_direct_packet_with_diagnostics;
use crate::text_engine::TextEngine;
use std::collections::HashMap;
use std::collections::HashSet;
use std::hash::DefaultHasher;
use std::hash::Hash;
use std::hash::Hasher;
use std::sync::Arc;
use sui_core::Color;
use sui_core::ColorSpace;
use sui_core::Path as ScenePath;
use sui_core::Point;
use sui_core::Rect;
use sui_core::Result;
use sui_core::Size;
use sui_core::Transform;
use sui_core::Vector;
use sui_scene::Brush;
use sui_scene::LayerProperties;
use sui_scene::Scene;
use sui_scene::SceneCommand;
use sui_scene::SceneFrame;
use sui_scene::SceneLayer;
use sui_scene::SceneLayerId;
use sui_scene::SceneLayerUpdateKind;
use sui_scene::TextRenderPolicy;
use sui_text::TextStyle;
use web_time::Instant;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) enum CompositionContainerId {
Root,
Layer(SceneLayerId),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) struct RetainedPacketId {
pub(crate) container: CompositionContainerId,
pub(crate) segment_index: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) struct TransformNodeId(pub(crate) u64);
impl TransformNodeId {
const ROOT: Self = Self(0);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) struct ClipNodeId(pub(crate) u64);
impl ClipNodeId {
const ROOT: Self = Self(0);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(crate) struct EffectNodeId(pub(crate) u64);
impl EffectNodeId {
const ROOT: Self = Self(0);
}
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
pub(crate) const MAX_ANALYTIC_PATH_CONTOURS: usize = 32;
#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
pub(crate) const MAX_ANALYTIC_PATH_POINTS: usize = 512;
#[derive(Debug, Clone, PartialEq, Default)]
pub(crate) struct RetainedCompositorFrameStats {
pub(crate) visible_layers: usize,
pub(crate) direct_packets: usize,
pub(crate) state_update_time_ms: f64,
pub(crate) composition_time_ms: f64,
pub(crate) scene_traversal_time_ms: f64,
pub(crate) snapshot_commands_replayed: usize,
pub(crate) snapshot_commands_reused: usize,
pub(crate) packet_build_count: usize,
pub(crate) packet_build_time_ms: f64,
pub(crate) packet_rebuilds: RetainedPacketRebuildStats,
pub(crate) packet_normalize_time_ms: f64,
pub(crate) packet_signature_time_ms: f64,
pub(crate) packet_raster_state_init_time_ms: f64,
pub(crate) packet_scene_build_time_ms: f64,
pub(crate) packet_command_count: usize,
pub(crate) packet_text_command_count: usize,
pub(crate) packet_path_command_count: usize,
pub(crate) packet_clip_path_command_count: usize,
pub(crate) packet_image_command_count: usize,
pub(crate) packet_rect_command_count: usize,
pub(crate) packet_text_command_time_ms: f64,
pub(crate) packet_path_command_time_ms: f64,
pub(crate) packet_clip_path_command_time_ms: f64,
pub(crate) packet_image_command_time_ms: f64,
pub(crate) packet_rect_command_time_ms: f64,
pub(crate) slowest_packet_build: Option<RetainedPacketBuildHotspot>,
}
#[derive(Debug, Clone, PartialEq)]
pub(crate) struct RetainedPacketBuildHotspot {
pub(crate) container_layer_id: Option<u64>,
pub(crate) owner_widget_id: Option<u64>,
pub(crate) segment_index: u32,
pub(crate) total_time_ms: f64,
pub(crate) scene_build_time_ms: f64,
pub(crate) command_count: usize,
pub(crate) text_command_count: usize,
pub(crate) path_command_count: usize,
pub(crate) rect_command_count: usize,
pub(crate) text_command_time_ms: f64,
pub(crate) path_command_time_ms: f64,
pub(crate) rect_command_time_ms: f64,
pub(crate) text_sample: Option<String>,
}
impl RetainedCompositorFrameStats {
pub(crate) fn record_packet_rebuild(&mut self, reason: PacketRebuildReason) {
self.packet_rebuilds.record_reason(reason);
}
pub(crate) fn record_packet_build_diagnostics(
&mut self,
diagnostics: DirectPacketBuildDiagnostics,
normalize_time_ms: f64,
signature_time_ms: f64,
) {
self.packet_normalize_time_ms += normalize_time_ms;
self.packet_signature_time_ms += signature_time_ms;
self.packet_raster_state_init_time_ms += diagnostics.raster_state_init_time_ms;
self.packet_scene_build_time_ms += diagnostics.scene_build_time_ms;
self.packet_command_count += diagnostics.command_count;
self.packet_text_command_count += diagnostics.text_command_count;
self.packet_path_command_count += diagnostics.path_command_count;
self.packet_clip_path_command_count += diagnostics.clip_path_command_count;
self.packet_image_command_count += diagnostics.image_command_count;
self.packet_rect_command_count += diagnostics.rect_command_count;
self.packet_text_command_time_ms += diagnostics.text_command_time_ms;
self.packet_path_command_time_ms += diagnostics.path_command_time_ms;
self.packet_clip_path_command_time_ms += diagnostics.clip_path_command_time_ms;
self.packet_image_command_time_ms += diagnostics.image_command_time_ms;
self.packet_rect_command_time_ms += diagnostics.rect_command_time_ms;
}
pub(crate) fn consider_packet_build_hotspot(&mut self, hotspot: RetainedPacketBuildHotspot) {
let should_replace = self
.slowest_packet_build
.as_ref()
.map(|current| hotspot.total_time_ms > current.total_time_ms)
.unwrap_or(true);
if should_replace {
self.slowest_packet_build = Some(hotspot);
}
}
}
#[derive(Debug)]
pub(crate) struct RetainedFrameSubmission {
pub(crate) fragments: Vec<RetainedFrameFragment>,
}
#[derive(Debug)]
pub(crate) struct RetainedFrameFragment {
pub(crate) id: RetainedPacketId,
pub(crate) draw_ops: Arc<DrawOpArena>,
}
#[derive(Debug, Clone, PartialEq)]
struct CompositionKey {
transform: Transform,
clips: Vec<ResolvedClipPrimitive>,
opacity: f32,
viewport: Size,
surface_size: Size,
}
#[derive(Debug, Clone)]
struct ComposedPacket {
key: CompositionKey,
draw_ops: Arc<DrawOpArena>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum CompositionItem {
Packet(RetainedPacketId),
Layer(SceneLayerId),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum CompositionPhase {
Normal,
Overlay,
Effect,
}
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub(crate) struct TransformNode {
pub(crate) id: TransformNodeId,
pub(crate) parent: Option<TransformNodeId>,
pub(crate) local: Transform,
pub(crate) world: Transform,
}
#[derive(Debug, Clone, PartialEq)]
pub(crate) enum ResolvedClipPrimitive {
Rect(Rect),
Path {
path: ScenePath,
bounds: Rect,
signature: u64,
},
}
#[allow(dead_code)]
impl ResolvedClipPrimitive {
pub(crate) fn bounds(&self) -> Rect {
match self {
Self::Rect(rect) => *rect,
Self::Path { bounds, .. } => *bounds,
}
}
}
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub(crate) struct ClipNode {
pub(crate) id: ClipNodeId,
pub(crate) parent: Option<ClipNodeId>,
pub(crate) primitive: Option<ResolvedClipPrimitive>,
}
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub(crate) struct EffectNode {
pub(crate) id: EffectNodeId,
pub(crate) parent: Option<EffectNodeId>,
pub(crate) composition_mode: sui_scene::LayerCompositionMode,
}
#[derive(Debug, Clone, PartialEq)]
pub(crate) struct ResolvedRasterState {
pub(crate) current_transform: Transform,
pub(crate) text_raster_transform: Transform,
pub(crate) text_background: crate::text_background::TextBackground,
pub(crate) text_lcd_allowed: bool,
pub(crate) transform_stack: Vec<Transform>,
pub(crate) text_render_policy: Option<TextRenderPolicy>,
pub(crate) text_render_policy_stack: Vec<Option<TextRenderPolicy>>,
pub(crate) pixel_snap_offset: Vector,
pub(crate) clip_stack: Vec<ResolvedClipPrimitive>,
pub(crate) transform_node: TransformNodeId,
pub(crate) clip_node: ClipNodeId,
pub(crate) effect_node: EffectNodeId,
}
impl ResolvedRasterState {
pub(crate) fn signature(&self) -> u64 {
let mut hasher = DefaultHasher::new();
hash_transform(&mut hasher, self.current_transform);
hash_transform(&mut hasher, self.text_raster_transform);
self.text_background.fingerprint(&mut hasher);
self.text_lcd_allowed.hash(&mut hasher);
self.transform_stack.len().hash(&mut hasher);
for transform in &self.transform_stack {
hash_transform(&mut hasher, *transform);
}
self.text_render_policy_stack.len().hash(&mut hasher);
for policy in
std::iter::once(&self.text_render_policy).chain(&self.text_render_policy_stack)
{
policy.is_some().hash(&mut hasher);
if let Some(policy) = policy {
hash_text_render_policy(*policy, &mut hasher);
}
}
self.pixel_snap_offset.x.to_bits().hash(&mut hasher);
self.pixel_snap_offset.y.to_bits().hash(&mut hasher);
self.transform_node.hash(&mut hasher);
self.clip_node.hash(&mut hasher);
self.effect_node.hash(&mut hasher);
for clip in &self.clip_stack {
match clip {
ResolvedClipPrimitive::Rect(rect) => {
0u8.hash(&mut hasher);
hash_rect(&mut hasher, *rect);
}
ResolvedClipPrimitive::Path {
bounds, signature, ..
} => {
1u8.hash(&mut hasher);
hash_rect(&mut hasher, *bounds);
signature.hash(&mut hasher);
}
}
}
hasher.finish()
}
}
pub(crate) fn clip_stack_signature(clips: &[ResolvedClipPrimitive]) -> u64 {
let mut hasher = DefaultHasher::new();
for clip in clips {
match clip {
ResolvedClipPrimitive::Rect(rect) => {
0u8.hash(&mut hasher);
hash_rect(&mut hasher, *rect);
}
ResolvedClipPrimitive::Path {
bounds, signature, ..
} => {
1u8.hash(&mut hasher);
hash_rect(&mut hasher, *bounds);
signature.hash(&mut hasher);
}
}
}
hasher.finish()
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub(crate) struct ComposedLayer {
pub(crate) opacity: f32,
pub(crate) scale: Vector,
pub(crate) offset: Vector,
}
impl Default for ComposedLayer {
fn default() -> Self {
Self {
opacity: 1.0,
scale: LayerProperties::IDENTITY_SCALE,
offset: Vector::ZERO,
}
}
}
impl ComposedLayer {
pub(crate) fn then_layer(self, local: &LayerProperties, bounds: Rect) -> Self {
let own_offset = local.map_point(bounds, Point::ZERO).to_vector();
Self {
opacity: self.opacity * local.opacity,
scale: Vector::new(self.scale.x * local.scale.x, self.scale.y * local.scale.y),
offset: Vector::new(
self.scale.x * own_offset.x + self.offset.x,
self.scale.y * own_offset.y + self.offset.y,
),
}
}
pub(crate) fn is_scaled(&self) -> bool {
self.scale != LayerProperties::IDENTITY_SCALE
}
pub(crate) fn transform(&self) -> Transform {
Transform::new(
self.scale.x,
0.0,
0.0,
self.scale.y,
self.offset.x,
self.offset.y,
)
}
pub(crate) fn map_point(&self, point: Point) -> Point {
Point::new(
point.x * self.scale.x + self.offset.x,
point.y * self.scale.y + self.offset.y,
)
}
pub(crate) fn map_rect(&self, rect: Rect) -> Rect {
if !self.is_scaled() {
return rect.translate(self.offset);
}
self.transform().transform_rect_bbox(rect)
}
}
pub(crate) fn normalized_clip_stack_signature(
clips: &[ResolvedClipPrimitive],
presentation: Transform,
) -> u64 {
if presentation.is_identity() {
return clip_stack_signature(clips);
}
let Some(to_local) = presentation.inverse() else {
return clip_stack_signature(clips);
};
let normalized = clips
.iter()
.cloned()
.map(|clip| transform_resolved_clip_primitive(clip, to_local))
.collect::<Vec<_>>();
clip_stack_signature(&normalized)
}
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub(crate) struct RetainedDirectPacket {
pub(crate) id: RetainedPacketId,
pub(crate) scene: Scene,
pub(crate) initial_state: ResolvedRasterState,
pub(crate) signature: u64,
raster_context: RasterContext,
pub(crate) coordinate_space: PacketCoordinateSpace,
pub(crate) draw_ops: Arc<DrawOpArena>,
composed: std::cell::RefCell<Option<ComposedPacket>>,
pub(crate) text_pages: u8,
pub(crate) atlas_versions: [u64; crate::text::TEXT_ATLAS_MAX_PAGES],
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct RasterContext {
viewport: Size,
surface_size: Size,
feather_width_bits: u32,
}
impl RasterContext {
fn new(frame: &SceneFrame, feather_width: f32) -> Self {
Self {
viewport: frame.viewport,
surface_size: frame.surface_size,
feather_width_bits: feather_width.to_bits(),
}
}
}
impl RetainedDirectPacket {
fn atlas_is_current(&self, engine: &TextEngine) -> bool {
(0..crate::text::TEXT_ATLAS_MAX_PAGES).all(|page| {
self.text_pages & (1 << page) == 0
|| engine
.atlas
.pages
.get(page)
.is_some_and(|p| p.generation == self.atlas_versions[page])
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum PacketCoordinateSpace {
World,
LayerLocal,
}
#[derive(Debug, Clone, Default)]
pub(crate) struct RetainedRootNode {
pub(crate) items: Vec<CompositionItem>,
pub(crate) packet_ids: Vec<RetainedPacketId>,
pub(crate) structure_version: u64,
}
#[derive(Debug, Clone)]
pub(crate) struct RetainedLayer {
pub(crate) descriptor: sui_scene::SceneLayerDescriptor,
pub(crate) composed_properties: ComposedLayer,
pub(crate) parent: Option<SceneLayerId>,
pub(crate) children: Vec<SceneLayerId>,
pub(crate) items: Vec<CompositionItem>,
pub(crate) packet_ids: Vec<RetainedPacketId>,
pub(crate) transform_node: TransformNodeId,
pub(crate) clip_node: ClipNodeId,
pub(crate) clip_signature: u64,
pub(crate) effect_node: EffectNodeId,
pub(crate) content_version: u64,
pub(crate) structure_version: u64,
}
#[derive(Debug, Clone)]
pub(crate) struct PacketSnapshot {
pub(crate) id: RetainedPacketId,
pub(crate) scene: Scene,
pub(crate) initial_state: ResolvedRasterState,
pub(crate) inherited_clip_count: usize,
}
#[derive(Debug, Clone)]
pub(crate) struct LayerSnapshot {
pub(crate) descriptor: sui_scene::SceneLayerDescriptor,
pub(crate) composed_properties: ComposedLayer,
pub(crate) parent: Option<SceneLayerId>,
pub(crate) children: Vec<SceneLayerId>,
pub(crate) items: Vec<CompositionItem>,
pub(crate) packet_ids: Vec<RetainedPacketId>,
pub(crate) packets: Vec<PacketSnapshot>,
pub(crate) transform_node: TransformNodeId,
pub(crate) clip_node: ClipNodeId,
pub(crate) clip_signature: u64,
pub(crate) effect_node: EffectNodeId,
}
#[derive(Debug, Clone, Default)]
pub(crate) struct RootSnapshot {
pub(crate) items: Vec<CompositionItem>,
pub(crate) packet_ids: Vec<RetainedPacketId>,
pub(crate) packets: Vec<PacketSnapshot>,
}
#[derive(Debug, Clone, Default)]
pub(crate) struct CompositorSnapshot {
pub(crate) root: RootSnapshot,
pub(crate) layers: HashMap<SceneLayerId, LayerSnapshot>,
}
#[derive(Debug, Clone, PartialEq)]
pub(crate) struct CompositionTraversalState {
pub(crate) current_transform: Transform,
pub(crate) text_background: crate::text_background::TextBackground,
pub(crate) text_lcd_allowed: bool,
pub(crate) transform_node: TransformNodeId,
pub(crate) transform_stack: Vec<(Transform, TransformNodeId)>,
pub(crate) text_render_policy: Option<TextRenderPolicy>,
pub(crate) text_render_policy_stack: Vec<Option<TextRenderPolicy>>,
pub(crate) clip_stack: Vec<(ResolvedClipPrimitive, ClipNodeId)>,
pub(crate) effect_node: EffectNodeId,
pub(crate) composed_layer_properties: ComposedLayer,
}
#[derive(Debug, Clone, PartialEq)]
struct SnapshotSpanInput {
state: CompositionTraversalState,
scopes: [usize; 3],
local_clips: Vec<bool>,
next_transform: u64,
next_clip: u64,
packet_start: usize,
packet_draw_limit: usize,
inherited_clip_count: usize,
}
#[derive(Debug)]
struct CachedSnapshotSpan {
commands: Arc<[SceneCommand]>,
input: SnapshotSpanInput,
end_state: CompositionTraversalState,
end_scopes: [usize; 3],
end_local_clips: Vec<bool>,
transforms: Vec<TransformNode>,
clips: Vec<ClipNode>,
packets: Vec<PacketSnapshot>,
last_used_snapshot: u64,
misses: u8,
}
impl Default for CompositionTraversalState {
fn default() -> Self {
Self {
current_transform: Transform::IDENTITY,
text_background: Default::default(),
text_lcd_allowed: true,
transform_node: TransformNodeId::ROOT,
transform_stack: Vec::new(),
text_render_policy: None,
text_render_policy_stack: Vec::new(),
clip_stack: Vec::new(),
effect_node: EffectNodeId::ROOT,
composed_layer_properties: ComposedLayer::default(),
}
}
}
impl CompositionTraversalState {
pub(crate) fn resolved_state(&self) -> ResolvedRasterState {
ResolvedRasterState {
current_transform: self.current_transform,
text_raster_transform: Transform::IDENTITY,
text_background: self.text_background.clone(),
text_lcd_allowed: self.text_lcd_allowed
&& self.composed_layer_properties.opacity >= 1.0,
transform_stack: self
.transform_stack
.iter()
.map(|(transform, _)| *transform)
.collect(),
text_render_policy: self.text_render_policy,
text_render_policy_stack: self.text_render_policy_stack.clone(),
pixel_snap_offset: Vector::ZERO,
clip_stack: self
.clip_stack
.iter()
.map(|(primitive, _)| primitive.clone())
.collect(),
transform_node: self.transform_node,
clip_node: self
.clip_stack
.last()
.map(|(_, node_id)| *node_id)
.unwrap_or(ClipNodeId::ROOT),
effect_node: self.effect_node,
}
}
}
#[derive(Debug)]
pub(crate) struct RetainedCompositorState {
pub(crate) root: RetainedRootNode,
pub(crate) layers: HashMap<SceneLayerId, RetainedLayer>,
pub(crate) packets: HashMap<RetainedPacketId, RetainedDirectPacket>,
pub(crate) transforms: HashMap<TransformNodeId, TransformNode>,
pub(crate) clips: HashMap<ClipNodeId, ClipNode>,
pub(crate) effects: HashMap<EffectNodeId, EffectNode>,
pub(crate) next_transform_node: u64,
pub(crate) next_clip_node: u64,
pub(crate) next_effect_node: u64,
pub(crate) viewport: Size,
pub(crate) surface_size: Size,
pub(crate) feather_width_bits: u32,
pub(crate) frame_index: u64,
pub(crate) last_frame_stats: RetainedCompositorFrameStats,
pub(crate) diagnostics_enabled: bool,
pub(crate) path_cache: PathMeshCache,
pub(crate) packet_draw_limit: usize,
snapshot_spans: HashMap<(CompositionContainerId, usize), CachedSnapshotSpan>,
snapshot_epoch: u64,
pub(crate) snapshot_commands_replayed: usize,
pub(crate) snapshot_commands_reused: usize,
#[cfg(test)]
pub(crate) snapshot_cache_enabled: bool,
}
impl Default for RetainedCompositorState {
fn default() -> Self {
Self {
root: RetainedRootNode::default(),
layers: HashMap::new(),
packets: HashMap::new(),
transforms: HashMap::new(),
clips: HashMap::new(),
effects: HashMap::new(),
next_transform_node: 0,
next_clip_node: 0,
next_effect_node: 0,
viewport: Size::ZERO,
surface_size: Size::ZERO,
feather_width_bits: 0,
frame_index: 0,
last_frame_stats: RetainedCompositorFrameStats::default(),
diagnostics_enabled: true,
path_cache: PathMeshCache::default(),
packet_draw_limit: 16,
snapshot_spans: HashMap::new(),
snapshot_epoch: 0,
snapshot_commands_replayed: 0,
snapshot_commands_reused: 0,
#[cfg(test)]
snapshot_cache_enabled: true,
}
}
}
impl RetainedCompositorState {
#[cfg(test)]
pub(crate) fn snapshot_cache_len(&self) -> usize {
self.snapshot_spans.len()
}
pub(crate) fn set_diagnostics_enabled(&mut self, enabled: bool) {
self.diagnostics_enabled = enabled;
self.path_cache.set_diagnostics_enabled(enabled);
if !enabled {
self.last_frame_stats = RetainedCompositorFrameStats::default();
}
}
#[cfg(test)]
pub(crate) fn prepare_frame(
&mut self,
frame: &SceneFrame,
text_engine: &mut TextEngine,
feather_width: f32,
) -> Result<DrawOpArena> {
let mut frame_stats = self.refresh_frame_state(frame, text_engine, feather_width)?;
let composition_started = self.diagnostics_enabled.then(Instant::now);
let mut draw_ops = self.compose_draw_ops(frame.viewport, &mut frame_stats)?;
draw_ops.finalize_image_draws(frame.viewport, frame.surface_size);
self.finish_frame(
frame.viewport,
frame.surface_size,
feather_width,
&mut frame_stats,
composition_started,
);
Ok(draw_ops)
}
pub(crate) fn prepare_frame_submission(
&mut self,
frame: &SceneFrame,
text_engine: &mut TextEngine,
feather_width: f32,
) -> Result<RetainedFrameSubmission> {
let mut frame_stats = self.refresh_frame_state(frame, text_engine, feather_width)?;
let composition_started = self.diagnostics_enabled.then(Instant::now);
let submission =
self.compose_submission(frame.viewport, frame.surface_size, &mut frame_stats)?;
self.finish_frame(
frame.viewport,
frame.surface_size,
feather_width,
&mut frame_stats,
composition_started,
);
Ok(submission)
}
pub(crate) fn refresh_frame_state(
&mut self,
frame: &SceneFrame,
text_engine: &mut TextEngine,
feather_width: f32,
) -> Result<RetainedCompositorFrameStats> {
let viewport_changed = self.viewport != frame.viewport;
let surface_size_changed = self.surface_size != frame.surface_size;
let feather_changed = self.feather_width_bits != feather_width.to_bits();
self.frame_index = self.frame_index.wrapping_add(1);
self.path_cache.begin_frame(self.frame_index);
let mut frame_stats = RetainedCompositorFrameStats::default();
let scene_traversal_started = self.diagnostics_enabled.then(Instant::now);
let snapshot = self.build_snapshot(&frame.scene, text_engine.lcd_blending_supported)?;
frame_stats.snapshot_commands_replayed = self.snapshot_commands_replayed;
frame_stats.snapshot_commands_reused = self.snapshot_commands_reused;
if let Some(started) = scene_traversal_started {
frame_stats.scene_traversal_time_ms = started.elapsed().as_secs_f64() * 1000.0;
}
let state_update_started = self.diagnostics_enabled.then(Instant::now);
self.apply_snapshot(
frame,
snapshot,
text_engine,
feather_width,
viewport_changed || surface_size_changed || feather_changed,
&mut frame_stats,
)?;
if let Some(started) = state_update_started {
frame_stats.state_update_time_ms = started.elapsed().as_secs_f64() * 1000.0;
}
Ok(frame_stats)
}
pub(crate) fn finish_frame(
&mut self,
viewport: Size,
surface_size: Size,
feather_width: f32,
frame_stats: &mut RetainedCompositorFrameStats,
composition_started: Option<Instant>,
) {
if let Some(started) = composition_started {
frame_stats.composition_time_ms = started.elapsed().as_secs_f64() * 1000.0;
self.last_frame_stats = frame_stats.clone();
} else {
self.last_frame_stats = RetainedCompositorFrameStats::default();
}
self.viewport = viewport;
self.surface_size = surface_size;
self.feather_width_bits = feather_width.to_bits();
}
pub(crate) fn build_snapshot(
&mut self,
scene: &Scene,
lcd_blending_supported: bool,
) -> Result<CompositorSnapshot> {
self.reset_property_trees();
self.snapshot_epoch = self.snapshot_epoch.wrapping_add(1);
self.snapshot_commands_replayed = 0;
self.snapshot_commands_reused = 0;
let mut snapshot = CompositorSnapshot::default();
snapshot.root = self.build_container_snapshot(
CompositionContainerId::Root,
scene,
CompositionTraversalState {
text_lcd_allowed: lcd_blending_supported,
..CompositionTraversalState::default()
},
&mut snapshot,
None,
0,
)?;
self.snapshot_spans
.retain(|_, span| span.last_used_snapshot == self.snapshot_epoch);
Ok(snapshot)
}
pub(crate) fn build_container_snapshot(
&mut self,
container: CompositionContainerId,
scene: &Scene,
mut state: CompositionTraversalState,
snapshot: &mut CompositorSnapshot,
parent_layer: Option<SceneLayerId>,
inherited_clip_count: usize,
) -> Result<RootSnapshot> {
let mut result = RootSnapshot::default();
let mut normal_items = Vec::new();
let mut overlay_items = Vec::new();
let mut effect_items = Vec::new();
let mut segment_scene = Scene::new();
let mut segment_start = None::<ResolvedRasterState>;
let mut draws = 0usize;
let mut scopes = [0usize; 3]; let mut local_clips_untransformed = Vec::new();
let commands = scene.commands();
let mut cursor = 0;
while cursor < commands.len() {
if let SceneCommand::Layer(layer) = &commands[cursor] {
self.snapshot_commands_replayed += 1;
flush_container_segment(
container,
&mut result,
&mut normal_items,
&mut overlay_items,
&mut effect_items,
&mut segment_scene,
&mut segment_start,
inherited_clip_count,
);
draws = 0;
let mut child_state = state.clone();
if !layer.descriptor.clip_to_ancestors {
child_state.clip_stack.clear();
}
child_state.effect_node = self
.push_effect_node(Some(state.effect_node), layer.descriptor.composition_mode);
let layer_clip = if layer.descriptor.composition_mode
== sui_scene::LayerCompositionMode::Scroll
{
Some(
state
.composed_layer_properties
.map_rect(layer.descriptor.presented_bounds()),
)
} else if layer.descriptor.is_stack_surface {
Some(
state
.composed_layer_properties
.map_rect(layer.descriptor.presented_paint_bounds()),
)
} else {
None
};
if let Some(clip_rect) = layer_clip {
let clip = ResolvedClipPrimitive::Rect(clip_rect);
let parent = child_state
.clip_stack
.last()
.map(|(_, node_id)| *node_id)
.unwrap_or(ClipNodeId::ROOT);
let node_id = self.push_clip_node(Some(parent), clip.clone());
child_state.clip_stack.push((clip, node_id));
}
let phase = composition_phase_for_mode(layer.descriptor.composition_mode);
let layer_snapshot =
self.build_layer_snapshot(layer, parent_layer, child_state, snapshot)?;
push_composition_item(
phase,
CompositionItem::Layer(layer.layer_id()),
&mut normal_items,
&mut overlay_items,
&mut effect_items,
);
snapshot.layers.insert(layer.layer_id(), layer_snapshot);
cursor += 1;
} else {
let start = cursor;
while cursor < commands.len() && !matches!(commands[cursor], SceneCommand::Layer(_))
{
cursor += 1;
}
let span_commands = &commands[start..cursor];
let cache_id = (container, start);
let input = SnapshotSpanInput {
state: state.clone(),
scopes,
local_clips: local_clips_untransformed.clone(),
next_transform: self.next_transform_node,
next_clip: self.next_clip_node,
packet_start: result.packets.len(),
packet_draw_limit: self.packet_draw_limit,
inherited_clip_count,
};
let cache_enabled = {
#[cfg(test)]
{
self.snapshot_cache_enabled
}
#[cfg(not(test))]
{
true
}
};
if cache_enabled
&& let Some(cached) = self.snapshot_spans.get_mut(&cache_id)
&& cached.input == input
&& cached.commands.as_ref() == span_commands
{
for node in &cached.transforms {
self.transforms.insert(node.id, node.clone());
}
for node in &cached.clips {
self.clips.insert(node.id, node.clone());
}
self.next_transform_node += cached.transforms.len() as u64;
self.next_clip_node += cached.clips.len() as u64;
state = cached.end_state.clone();
scopes = cached.end_scopes;
local_clips_untransformed = cached.end_local_clips.clone();
for packet in &cached.packets {
normal_items.push(CompositionItem::Packet(packet.id));
result.packet_ids.push(packet.id);
result.packets.push(packet.clone());
}
cached.last_used_snapshot = self.snapshot_epoch;
cached.misses = 0;
self.snapshot_commands_reused += span_commands.len();
draws = 0;
continue;
}
self.snapshot_commands_replayed += span_commands.len();
for command in span_commands {
if segment_start.is_none() {
segment_start = Some(state.resolved_state());
}
segment_scene.push(command.clone());
let clip = state
.clip_stack
.iter()
.map(|(clip, _)| match clip {
ResolvedClipPrimitive::Rect(rect) => *rect,
ResolvedClipPrimitive::Path { bounds, .. } => *bounds,
})
.reduce(|a, b| a.intersection(b).unwrap_or(Rect::ZERO));
let rectangular_clip = state
.clip_stack
.iter()
.all(|(clip, _)| matches!(clip, ResolvedClipPrimitive::Rect(_)));
state.text_background.observe(
command,
state
.composed_layer_properties
.transform()
.then(state.current_transform),
clip,
rectangular_clip,
);
self.apply_command_to_traversal_state(command, &mut state);
match command {
SceneCommand::PushTransform { .. } => scopes[0] += 1,
SceneCommand::PopTransform => scopes[0] = scopes[0].saturating_sub(1),
SceneCommand::PushClip { .. } | SceneCommand::PushClipPath { .. } => {
scopes[1] += 1;
local_clips_untransformed.push(state.current_transform.is_identity());
}
SceneCommand::PopClip => {
scopes[1] = scopes[1].saturating_sub(1);
local_clips_untransformed.pop();
}
SceneCommand::PushTextRenderPolicy { .. } => scopes[2] += 1,
SceneCommand::PopTextRenderPolicy => {
scopes[2] = scopes[2].saturating_sub(1)
}
_ => draws += usize::from(command_has_draw_content(command)),
}
if draws >= self.packet_draw_limit
&& (container == CompositionContainerId::Root
|| (scopes[0] == 0
&& local_clips_untransformed.iter().all(|safe| *safe)))
{
flush_container_segment(
container,
&mut result,
&mut normal_items,
&mut overlay_items,
&mut effect_items,
&mut segment_scene,
&mut segment_start,
inherited_clip_count,
);
draws = 0;
}
}
flush_container_segment(
container,
&mut result,
&mut normal_items,
&mut overlay_items,
&mut effect_items,
&mut segment_scene,
&mut segment_start,
inherited_clip_count,
);
draws = 0;
let save_snapshot = if cache_enabled {
if let Some(cached) = self.snapshot_spans.get_mut(&cache_id) {
cached.last_used_snapshot = self.snapshot_epoch;
cached.misses = cached.misses.saturating_add(1);
span_commands.len() < 32 || cached.misses >= 8
} else {
true
}
} else {
false
};
if save_snapshot {
let transforms = (input.next_transform..self.next_transform_node)
.map(|id| self.transforms[&TransformNodeId(id)].clone())
.collect();
let clips = (input.next_clip..self.next_clip_node)
.map(|id| self.clips[&ClipNodeId(id)].clone())
.collect();
let packets = result.packets[input.packet_start..].to_vec();
self.snapshot_spans.insert(
cache_id,
CachedSnapshotSpan {
commands: Arc::from(span_commands),
input,
end_state: state.clone(),
end_scopes: scopes,
end_local_clips: local_clips_untransformed.clone(),
transforms,
clips,
packets,
last_used_snapshot: self.snapshot_epoch,
misses: 0,
},
);
}
}
}
flush_container_segment(
container,
&mut result,
&mut normal_items,
&mut overlay_items,
&mut effect_items,
&mut segment_scene,
&mut segment_start,
inherited_clip_count,
);
result.items = normal_items;
result.items.extend(overlay_items);
result.items.extend(effect_items);
Ok(result)
}
pub(crate) fn build_layer_snapshot(
&mut self,
layer: &SceneLayer,
parent_layer: Option<SceneLayerId>,
mut state: CompositionTraversalState,
snapshot: &mut CompositorSnapshot,
) -> Result<LayerSnapshot> {
let composed_properties = state
.composed_layer_properties
.then_layer(&layer.descriptor.properties, layer.descriptor.bounds);
state.composed_layer_properties = composed_properties;
state.text_lcd_allowed &=
layer.descriptor.composition_mode != sui_scene::LayerCompositionMode::Effect;
let inherited_state = state.resolved_state();
let container = self.build_container_snapshot(
CompositionContainerId::Layer(layer.layer_id()),
&layer.scene,
state,
snapshot,
Some(layer.layer_id()),
inherited_state.clip_stack.len(),
)?;
let clip_signature = normalized_clip_stack_signature(
&inherited_state.clip_stack,
Transform::translation_vector(layer.descriptor.bounds.origin.to_vector())
.then(composed_properties.transform()),
);
let children = container
.items
.iter()
.filter_map(|item| match item {
CompositionItem::Layer(layer_id) => Some(*layer_id),
CompositionItem::Packet(_) => None,
})
.collect();
Ok(LayerSnapshot {
descriptor: layer.descriptor.clone(),
composed_properties,
parent: parent_layer,
children,
items: container.items,
packet_ids: container.packet_ids,
packets: container.packets,
transform_node: inherited_state.transform_node,
clip_node: inherited_state.clip_node,
clip_signature,
effect_node: inherited_state.effect_node,
})
}
pub(crate) fn apply_command_to_traversal_state(
&mut self,
command: &SceneCommand,
state: &mut CompositionTraversalState,
) {
match command {
SceneCommand::PushTransform { transform } => {
let parent_world = state.current_transform;
let parent_node = state.transform_node;
state.transform_stack.push((parent_world, parent_node));
let world = parent_world.then(*transform);
state.current_transform = world;
state.transform_node =
self.push_transform_node(Some(parent_node), *transform, world);
}
SceneCommand::PopTransform => {
let (world, node_id) = state
.transform_stack
.pop()
.unwrap_or((Transform::IDENTITY, TransformNodeId::ROOT));
state.current_transform = world;
state.transform_node = node_id;
}
SceneCommand::PushClip { rect } => {
let clip =
ResolvedClipPrimitive::Rect(state.current_transform.transform_rect_bbox(*rect));
let parent = state
.clip_stack
.last()
.map(|(_, node_id)| *node_id)
.unwrap_or(ClipNodeId::ROOT);
let node_id = self.push_clip_node(Some(parent), clip.clone());
state.clip_stack.push((clip, node_id));
}
SceneCommand::PushClipPath { path } => {
let transformed_path = transform_scene_path(path, state.current_transform);
let bounds = transformed_path.bounds();
let clip = ResolvedClipPrimitive::Path {
signature: hash_path(&transformed_path, Transform::IDENTITY),
path: transformed_path,
bounds,
};
let parent = state
.clip_stack
.last()
.map(|(_, node_id)| *node_id)
.unwrap_or(ClipNodeId::ROOT);
let node_id = self.push_clip_node(Some(parent), clip.clone());
state.clip_stack.push((clip, node_id));
}
SceneCommand::PopClip => {
let _ = state.clip_stack.pop();
}
SceneCommand::PushTextRenderPolicy { policy } => {
state
.text_render_policy_stack
.push(state.text_render_policy);
state.text_render_policy = Some(policy.normalized());
}
SceneCommand::PopTextRenderPolicy => {
state.text_render_policy = state.text_render_policy_stack.pop().unwrap_or(None);
}
SceneCommand::Clear(_)
| SceneCommand::FillRect { .. }
| SceneCommand::StrokeRect { .. }
| SceneCommand::FillPath { .. }
| SceneCommand::StrokePath { .. }
| SceneCommand::DrawText(_)
| SceneCommand::DrawShapedText(_)
| SceneCommand::DrawShapedTextWindow(_)
| SceneCommand::DrawImage { .. }
| SceneCommand::DrawImageQuad { .. }
| SceneCommand::DrawShaderRect { .. }
| SceneCommand::Layer(_)
| SceneCommand::FillRoundedRect { .. }
| SceneCommand::Label { .. } => {}
}
}
pub(crate) fn apply_snapshot(
&mut self,
frame: &SceneFrame,
snapshot: CompositorSnapshot,
text_engine: &mut TextEngine,
feather_width: f32,
global_rebuild: bool,
frame_stats: &mut RetainedCompositorFrameStats,
) -> Result<()> {
for packet in &snapshot.root.packets {
self.protect_reused_packet_pages(
frame,
packet,
PacketCoordinateSpace::World,
text_engine,
feather_width,
);
}
for layer in snapshot.layers.values() {
let (origin, pixel_origin) = self.layer_packet_origins(layer);
for packet in &layer.packets {
if self
.packets
.get(&packet.id)
.is_none_or(|cached| cached.text_pages == 0)
{
continue;
}
let normalized = normalize_packet_snapshot(
packet.clone(),
PacketCoordinateSpace::LayerLocal,
origin,
pixel_origin,
frame.scale_factor,
);
self.protect_reused_packet_pages(
frame,
&normalized,
PacketCoordinateSpace::LayerLocal,
text_engine,
feather_width,
);
}
}
let previous_layers = self.layers.clone();
let layer_translation_deltas = snapshot
.layers
.iter()
.filter_map(|(layer_id, layer_snapshot)| {
previous_layers.get(layer_id).and_then(|previous| {
descriptor_translation_delta(&previous.descriptor, &layer_snapshot.descriptor)
.map(|delta| (*layer_id, delta))
})
})
.collect::<HashMap<_, _>>();
let mut packet_dirty_layers = HashSet::new();
let current_layers = snapshot.layers.keys().copied().collect::<HashSet<_>>();
let mut root_dirty = global_rebuild;
for update in &frame.layer_updates {
if !current_layers.contains(&update.layer_id) {
root_dirty = true;
continue;
}
match update.kind {
SceneLayerUpdateKind::Content | SceneLayerUpdateKind::Resources => {
packet_dirty_layers.insert(update.layer_id);
}
SceneLayerUpdateKind::Transform
if !layer_translation_deltas.contains_key(&update.layer_id) =>
{
packet_dirty_layers.insert(update.layer_id);
}
SceneLayerUpdateKind::Ordering
| SceneLayerUpdateKind::Clip
| SceneLayerUpdateKind::Effect
| SceneLayerUpdateKind::Visibility
| SceneLayerUpdateKind::Transform => {}
}
}
let mut valid_packets = HashSet::new();
valid_packets.extend(snapshot.root.packet_ids.iter().copied());
for layer in snapshot.layers.values() {
valid_packets.extend(layer.packet_ids.iter().copied());
}
if self.root.items != snapshot.root.items
|| self.root.packet_ids != snapshot.root.packet_ids
{
self.root.structure_version = self.root.structure_version.wrapping_add(1);
}
self.root.items = snapshot.root.items.clone();
self.root.packet_ids = snapshot.root.packet_ids.clone();
for packet in snapshot.root.packets {
self.upsert_packet(
frame,
packet,
root_dirty,
PacketCoordinateSpace::World,
Vector::ZERO,
Vector::ZERO,
frame.scale_factor,
text_engine,
feather_width,
frame_stats,
)?;
}
self.layers
.retain(|layer_id, _| current_layers.contains(layer_id));
for (layer_id, layer_snapshot) in snapshot.layers {
let translation_delta = layer_translation_deltas.get(&layer_id).copied();
let translated_only = translation_delta.is_some();
let structure_changed = previous_layers.get(&layer_id).is_none_or(|previous| {
previous.parent != layer_snapshot.parent
|| previous.children != layer_snapshot.children
|| previous.items != layer_snapshot.items
|| previous.packet_ids != layer_snapshot.packet_ids
|| previous.transform_node != layer_snapshot.transform_node
|| previous.clip_signature != layer_snapshot.clip_signature
|| previous.effect_node != layer_snapshot.effect_node
|| (!translated_only && previous.descriptor != layer_snapshot.descriptor)
});
let content_changed = packet_dirty_layers.contains(&layer_id)
|| previous_layers.get(&layer_id).is_none_or(|previous| {
!translated_only
&& previous.descriptor.bounds != layer_snapshot.descriptor.bounds
});
let previous = previous_layers.get(&layer_id);
let retained = self
.layers
.entry(layer_id)
.or_insert_with(|| RetainedLayer {
descriptor: layer_snapshot.descriptor.clone(),
composed_properties: layer_snapshot.composed_properties,
parent: layer_snapshot.parent,
children: layer_snapshot.children.clone(),
items: layer_snapshot.items.clone(),
packet_ids: layer_snapshot.packet_ids.clone(),
transform_node: layer_snapshot.transform_node,
clip_node: layer_snapshot.clip_node,
clip_signature: layer_snapshot.clip_signature,
effect_node: layer_snapshot.effect_node,
content_version: 0,
structure_version: 0,
});
if structure_changed {
retained.structure_version = previous
.map_or(retained.structure_version + 1, |old| {
old.structure_version.wrapping_add(1)
});
}
if content_changed {
retained.content_version = previous.map_or(retained.content_version + 1, |old| {
old.content_version.wrapping_add(1)
});
}
retained.descriptor = layer_snapshot.descriptor.clone();
retained.composed_properties = layer_snapshot.composed_properties;
retained.parent = layer_snapshot.parent;
retained.children = layer_snapshot.children.clone();
retained.items = layer_snapshot.items.clone();
retained.packet_ids = layer_snapshot.packet_ids.clone();
retained.transform_node = layer_snapshot.transform_node;
retained.clip_node = layer_snapshot.clip_node;
retained.clip_signature = layer_snapshot.clip_signature;
retained.effect_node = layer_snapshot.effect_node;
let packet_dirty =
global_rebuild || structure_changed || packet_dirty_layers.contains(&layer_id);
let coordinate_space = PacketCoordinateSpace::LayerLocal;
let (normalization_origin, pixel_snap_origin) =
self.layer_packet_origins(&layer_snapshot);
for packet in layer_snapshot.packets {
self.upsert_packet(
frame,
packet,
packet_dirty,
coordinate_space,
normalization_origin,
pixel_snap_origin,
frame.scale_factor,
text_engine,
feather_width,
frame_stats,
)?;
}
}
self.packets
.retain(|packet_id, _| valid_packets.contains(packet_id));
Ok(())
}
fn layer_packet_origins(&self, layer: &LayerSnapshot) -> (Vector, Vector) {
let origin = layer.descriptor.bounds.origin.to_vector();
let local_origin = layer
.composed_properties
.map_point(layer.descriptor.bounds.origin);
let transform = self
.transforms
.get(&layer.transform_node)
.map_or(Transform::IDENTITY, |node| node.world);
(origin, transform.transform_point(local_origin).to_vector())
}
fn protect_reused_packet_pages(
&self,
frame: &SceneFrame,
snapshot: &PacketSnapshot,
space: PacketCoordinateSpace,
engine: &mut TextEngine,
feather_width: f32,
) {
let Some(packet) = self.packets.get(&snapshot.id) else {
return;
};
if packet.text_pages == 0
|| packet.coordinate_space != space
|| !packet.atlas_is_current(engine)
|| packet.initial_state != snapshot.initial_state
|| (!packet.scene.shares_commands_with(&snapshot.scene)
&& packet.scene != snapshot.scene)
|| packet.raster_context != RasterContext::new(frame, feather_width)
{
return;
}
for page in 0..crate::text::TEXT_ATLAS_MAX_PAGES {
if packet.text_pages & (1 << page) != 0 {
engine.atlas.touch_page(page, engine.frame_counter);
}
}
}
pub(crate) fn upsert_packet(
&mut self,
frame: &SceneFrame,
snapshot: PacketSnapshot,
_forced_dirty: bool,
coordinate_space: PacketCoordinateSpace,
normalization_origin: Vector,
pixel_snap_origin: Vector,
raster_scale_factor: f32,
text_engine: &mut TextEngine,
feather_width: f32,
stats: &mut RetainedCompositorFrameStats,
) -> Result<()> {
let normalize_started = self.diagnostics_enabled.then(Instant::now);
let snapshot = normalize_packet_snapshot(
snapshot,
coordinate_space,
normalization_origin,
pixel_snap_origin,
raster_scale_factor,
);
let normalize_time_ms = normalize_started
.map(|started| started.elapsed().as_secs_f64() * 1000.0)
.unwrap_or(0.0);
let raster_context = RasterContext::new(frame, feather_width);
if let Some(packet) = self.packets.get(&snapshot.id)
&& packet.coordinate_space == coordinate_space
&& packet.raster_context == raster_context
&& packet.atlas_is_current(text_engine)
&& packet.initial_state == snapshot.initial_state
&& (packet.scene.shares_commands_with(&snapshot.scene)
|| packet.scene == snapshot.scene)
{
return Ok(());
}
let signature_started = self.diagnostics_enabled.then(Instant::now);
let signature = packet_signature(
&snapshot.scene,
&snapshot.initial_state,
frame.viewport,
frame.surface_size,
feather_width,
);
let signature_time_ms = signature_started
.map(|started| started.elapsed().as_secs_f64() * 1000.0)
.unwrap_or(0.0);
let rebuild_reason = match self.packets.get(&snapshot.id) {
None => Some(PacketRebuildReason::NewPacket),
Some(packet) if packet.coordinate_space != coordinate_space => {
Some(PacketRebuildReason::CoordinateSpace)
}
Some(packet) if !packet.atlas_is_current(text_engine) => {
Some(PacketRebuildReason::State)
}
Some(packet) if packet.signature != signature => {
if self.diagnostics_enabled {
if packet.scene != snapshot.scene {
Some(PacketRebuildReason::Scene)
} else if packet.initial_state != snapshot.initial_state {
Some(PacketRebuildReason::State)
} else {
Some(PacketRebuildReason::Signature)
}
} else {
Some(PacketRebuildReason::Signature)
}
}
Some(packet) if packet.scene != snapshot.scene => Some(PacketRebuildReason::Scene),
Some(packet) if packet.initial_state != snapshot.initial_state => {
Some(PacketRebuildReason::State)
}
Some(_) => None,
};
if let Some(reason) = rebuild_reason {
let packet_build_started = self.diagnostics_enabled.then(Instant::now);
let (draw_ops, diagnostics) = build_direct_packet_with_diagnostics(
frame,
&snapshot.scene,
&snapshot.initial_state,
text_engine,
&mut self.path_cache,
feather_width,
)?;
stats.record_packet_rebuild(reason);
stats.record_packet_build_diagnostics(
diagnostics,
normalize_time_ms,
signature_time_ms,
);
if let Some(started) = packet_build_started {
let total_time_ms = started.elapsed().as_secs_f64() * 1000.0;
stats.packet_build_count += 1;
stats.packet_build_time_ms += total_time_ms;
let (container_layer_id, owner_widget_id) = match snapshot.id.container {
CompositionContainerId::Root => (None, None),
CompositionContainerId::Layer(layer_id) => (
Some(layer_id.get()),
self.layers
.get(&layer_id)
.map(|layer| layer.descriptor.owner.get()),
),
};
stats.consider_packet_build_hotspot(RetainedPacketBuildHotspot {
container_layer_id,
owner_widget_id,
segment_index: snapshot.id.segment_index,
total_time_ms,
scene_build_time_ms: diagnostics.scene_build_time_ms,
command_count: diagnostics.command_count,
text_command_count: diagnostics.text_command_count,
path_command_count: diagnostics.path_command_count,
rect_command_count: diagnostics.rect_command_count,
text_command_time_ms: diagnostics.text_command_time_ms,
path_command_time_ms: diagnostics.path_command_time_ms,
rect_command_time_ms: diagnostics.rect_command_time_ms,
text_sample: packet_text_sample(&snapshot.scene),
});
}
self.packets.insert(
snapshot.id,
RetainedDirectPacket {
id: snapshot.id,
scene: snapshot.scene,
initial_state: snapshot.initial_state,
signature,
raster_context,
coordinate_space,
text_pages: draw_ops
.text_instances
.iter()
.fold(0, |mask, glyph| mask | (1 << glyph.layer)),
atlas_versions: std::array::from_fn(|page| {
text_engine
.atlas
.pages
.get(page)
.map_or(0, |p| p.generation)
}),
draw_ops: Arc::new(draw_ops),
composed: Default::default(),
},
);
}
Ok(())
}
#[cfg(test)]
pub(crate) fn compose_draw_ops(
&self,
viewport: Size,
stats: &mut RetainedCompositorFrameStats,
) -> Result<DrawOpArena> {
let mut draw_ops = DrawOpArena::default();
for phase in [
CompositionPhase::Normal,
CompositionPhase::Overlay,
CompositionPhase::Effect,
] {
self.append_items_for_phase(&self.root.items, phase, &mut draw_ops, viewport, stats)?;
}
Ok(draw_ops)
}
pub(crate) fn compose_submission(
&self,
viewport: Size,
surface_size: Size,
stats: &mut RetainedCompositorFrameStats,
) -> Result<RetainedFrameSubmission> {
let mut submission = RetainedFrameSubmission {
fragments: Vec::new(),
};
for phase in [
CompositionPhase::Normal,
CompositionPhase::Overlay,
CompositionPhase::Effect,
] {
self.append_items_to_submission_for_phase(
&self.root.items,
phase,
&mut submission,
viewport,
surface_size,
stats,
)?;
}
Ok(submission)
}
#[cfg(test)]
pub(crate) fn append_items_for_phase(
&self,
items: &[CompositionItem],
phase: CompositionPhase,
draw_ops: &mut DrawOpArena,
viewport: Size,
stats: &mut RetainedCompositorFrameStats,
) -> Result<()> {
for item in items {
match item {
CompositionItem::Packet(packet_id) => {
if let Some(packet) = self.packets.get(packet_id) {
if composition_phase_for_effect_node(
packet.initial_state.effect_node,
&self.effects,
) != phase
{
continue;
}
match packet.coordinate_space {
PacketCoordinateSpace::World => {
draw_ops.append_fragment(&packet.draw_ops);
}
PacketCoordinateSpace::LayerLocal => {
let (transform, clip_stack, opacity) = match packet.id.container {
CompositionContainerId::Root => {
(Transform::IDENTITY, Vec::new(), 1.0)
}
CompositionContainerId::Layer(layer_id) => self
.layers
.get(&layer_id)
.map(|layer| {
let origin = layer.descriptor.bounds.origin.to_vector();
let world = self
.transforms
.get(&layer.transform_node)
.map_or(Transform::IDENTITY, |node| node.world);
(
Transform::translation_vector(origin)
.then(layer.composed_properties.transform())
.then(world),
resolved_clip_primitives(
layer.clip_node,
&self.clips,
),
layer.composed_properties.opacity,
)
})
.unwrap_or((Transform::IDENTITY, Vec::new(), 1.0)),
};
draw_ops.append_transformed_fragment(
&packet.draw_ops,
transform,
opacity,
&clip_stack,
viewport,
)?;
}
}
stats.direct_packets += 1;
}
}
CompositionItem::Layer(layer_id) => {
if let Some(layer) = self.layers.get(layer_id) {
stats.visible_layers += 1;
self.append_items_for_phase(
&layer.items,
phase,
draw_ops,
viewport,
stats,
)?;
}
}
}
}
Ok(())
}
pub(crate) fn append_items_to_submission_for_phase(
&self,
items: &[CompositionItem],
phase: CompositionPhase,
submission: &mut RetainedFrameSubmission,
viewport: Size,
surface_size: Size,
stats: &mut RetainedCompositorFrameStats,
) -> Result<()> {
for item in items {
match item {
CompositionItem::Packet(packet_id) => {
if let Some(packet) = self.packets.get(packet_id) {
if composition_phase_for_effect_node(
packet.initial_state.effect_node,
&self.effects,
) != phase
{
continue;
}
let (transform, clips, opacity) = match packet.coordinate_space {
PacketCoordinateSpace::World => (Transform::IDENTITY, Vec::new(), 1.0),
PacketCoordinateSpace::LayerLocal => match packet.id.container {
CompositionContainerId::Root => {
(Transform::IDENTITY, Vec::new(), 1.0)
}
CompositionContainerId::Layer(layer_id) => self
.layers
.get(&layer_id)
.map(|layer| {
let origin = layer.descriptor.bounds.origin.to_vector();
let world = self
.transforms
.get(&layer.transform_node)
.map_or(Transform::IDENTITY, |node| node.world);
(
Transform::translation_vector(origin)
.then(layer.composed_properties.transform())
.then(world),
resolved_clip_primitives(layer.clip_node, &self.clips),
layer.composed_properties.opacity,
)
})
.unwrap_or((Transform::IDENTITY, Vec::new(), 1.0)),
},
};
let key = CompositionKey {
transform,
clips,
opacity,
viewport,
surface_size,
};
let mut cached = packet.composed.borrow_mut();
if cached.as_ref().is_none_or(|cached| cached.key != key) {
let mut current = if key.transform.is_identity()
&& key.clips.is_empty()
&& key.opacity == 1.0
{
Arc::clone(&packet.draw_ops)
} else {
let mut current = DrawOpArena::default();
current.append_transformed_fragment(
&packet.draw_ops,
key.transform,
key.opacity,
&key.clips,
viewport,
)?;
Arc::new(current)
};
if current.draw_ops.iter().any(|op| op.image.is_some()) {
Arc::make_mut(&mut current)
.finalize_image_draws(viewport, surface_size);
}
*cached = Some(ComposedPacket {
key,
draw_ops: current,
});
}
let current = &cached.as_ref().expect("composed packet cached").draw_ops;
if !current.draw_ops.is_empty() {
submission.fragments.push(RetainedFrameFragment {
id: packet.id,
draw_ops: Arc::clone(current),
});
}
stats.direct_packets += 1;
}
}
CompositionItem::Layer(layer_id) => {
if let Some(layer) = self.layers.get(layer_id) {
stats.visible_layers += 1;
self.append_items_to_submission_for_phase(
&layer.items,
phase,
submission,
viewport,
surface_size,
stats,
)?;
}
}
}
}
Ok(())
}
}
pub(crate) fn push_composition_item(
phase: CompositionPhase,
item: CompositionItem,
normal_items: &mut Vec<CompositionItem>,
overlay_items: &mut Vec<CompositionItem>,
effect_items: &mut Vec<CompositionItem>,
) {
match phase {
CompositionPhase::Normal => normal_items.push(item),
CompositionPhase::Overlay => overlay_items.push(item),
CompositionPhase::Effect => effect_items.push(item),
}
}
pub(crate) fn flush_container_segment(
container: CompositionContainerId,
result: &mut RootSnapshot,
normal_items: &mut Vec<CompositionItem>,
overlay_items: &mut Vec<CompositionItem>,
effect_items: &mut Vec<CompositionItem>,
segment_scene: &mut Scene,
segment_start: &mut Option<ResolvedRasterState>,
inherited_clip_count: usize,
) {
if !scene_has_draw_content(segment_scene) {
*segment_scene = Scene::new();
*segment_start = None;
return;
}
let initial_state = segment_start
.take()
.expect("segment state available before flush");
let phase = CompositionPhase::Normal;
let packet_id = RetainedPacketId {
container,
segment_index: result.packets.len() as u32,
};
push_composition_item(
phase,
CompositionItem::Packet(packet_id),
normal_items,
overlay_items,
effect_items,
);
result.packet_ids.push(packet_id);
result.packets.push(PacketSnapshot {
id: packet_id,
scene: std::mem::take(segment_scene),
initial_state,
inherited_clip_count,
});
}
pub(crate) fn composition_phase_for_effect_node(
mut effect_node: EffectNodeId,
effects: &HashMap<EffectNodeId, EffectNode>,
) -> CompositionPhase {
let mut phase = CompositionPhase::Normal;
while let Some(node) = effects.get(&effect_node) {
phase = match (phase, node.composition_mode) {
(CompositionPhase::Effect, _) | (_, sui_scene::LayerCompositionMode::Effect) => {
CompositionPhase::Effect
}
(CompositionPhase::Overlay, _) | (_, sui_scene::LayerCompositionMode::Overlay) => {
CompositionPhase::Overlay
}
_ => phase,
};
let Some(parent) = node.parent else {
break;
};
effect_node = parent;
}
phase
}
pub(crate) fn composition_phase_for_mode(
mode: sui_scene::LayerCompositionMode,
) -> CompositionPhase {
match mode {
sui_scene::LayerCompositionMode::Normal | sui_scene::LayerCompositionMode::Scroll => {
CompositionPhase::Normal
}
sui_scene::LayerCompositionMode::Overlay => CompositionPhase::Overlay,
sui_scene::LayerCompositionMode::Effect => CompositionPhase::Effect,
}
}
pub(crate) fn resolved_clip_primitives(
mut clip_node: ClipNodeId,
clips: &HashMap<ClipNodeId, ClipNode>,
) -> Vec<ResolvedClipPrimitive> {
let mut primitives = Vec::new();
while clip_node != ClipNodeId::ROOT {
let Some(node) = clips.get(&clip_node) else {
break;
};
if let Some(primitive) = &node.primitive {
primitives.push(primitive.clone());
}
clip_node = node.parent.unwrap_or(ClipNodeId::ROOT);
}
primitives.reverse();
primitives
}
impl RetainedCompositorState {
pub(crate) fn reset_property_trees(&mut self) {
self.transforms.clear();
self.clips.clear();
self.effects.clear();
self.transforms.insert(
TransformNodeId::ROOT,
TransformNode {
id: TransformNodeId::ROOT,
parent: None,
local: Transform::IDENTITY,
world: Transform::IDENTITY,
},
);
self.clips.insert(
ClipNodeId::ROOT,
ClipNode {
id: ClipNodeId::ROOT,
parent: None,
primitive: None,
},
);
self.effects.insert(
EffectNodeId::ROOT,
EffectNode {
id: EffectNodeId::ROOT,
parent: None,
composition_mode: sui_scene::LayerCompositionMode::Normal,
},
);
self.next_transform_node = 1;
self.next_clip_node = 1;
self.next_effect_node = 1;
}
pub(crate) fn push_transform_node(
&mut self,
parent: Option<TransformNodeId>,
local: Transform,
world: Transform,
) -> TransformNodeId {
let id = TransformNodeId(self.next_transform_node);
self.next_transform_node += 1;
self.transforms.insert(
id,
TransformNode {
id,
parent,
local,
world,
},
);
id
}
pub(crate) fn push_clip_node(
&mut self,
parent: Option<ClipNodeId>,
primitive: ResolvedClipPrimitive,
) -> ClipNodeId {
let id = ClipNodeId(self.next_clip_node);
self.next_clip_node += 1;
self.clips.insert(
id,
ClipNode {
id,
parent,
primitive: Some(primitive),
},
);
id
}
pub(crate) fn push_effect_node(
&mut self,
parent: Option<EffectNodeId>,
composition_mode: sui_scene::LayerCompositionMode,
) -> EffectNodeId {
let id = EffectNodeId(self.next_effect_node);
self.next_effect_node += 1;
self.effects.insert(
id,
EffectNode {
id,
parent,
composition_mode,
},
);
id
}
}
pub(crate) fn scene_has_draw_content(scene: &Scene) -> bool {
scene.commands().iter().any(command_has_draw_content)
}
fn command_has_draw_content(command: &SceneCommand) -> bool {
matches!(
command,
SceneCommand::Clear(_)
| SceneCommand::FillRect { .. }
| SceneCommand::StrokeRect { .. }
| SceneCommand::FillPath { .. }
| SceneCommand::StrokePath { .. }
| SceneCommand::DrawText(_)
| SceneCommand::DrawShapedText(_)
| SceneCommand::DrawShapedTextWindow(_)
| SceneCommand::DrawImage { .. }
| SceneCommand::DrawImageQuad { .. }
| SceneCommand::DrawShaderRect { .. }
| SceneCommand::FillRoundedRect { .. }
| SceneCommand::Label { .. }
)
}
pub(crate) fn normalize_packet_snapshot(
mut snapshot: PacketSnapshot,
coordinate_space: PacketCoordinateSpace,
normalization_origin: Vector,
pixel_snap_origin: Vector,
raster_scale_factor: f32,
) -> PacketSnapshot {
let has_text = snapshot.scene.commands().iter().any(|command| {
matches!(
command,
SceneCommand::DrawText(_)
| SceneCommand::DrawShapedText(_)
| SceneCommand::DrawShapedTextWindow(_)
| SceneCommand::Label { .. }
)
});
if !has_text {
snapshot.initial_state.text_background = Default::default();
}
if has_text && coordinate_space == PacketCoordinateSpace::LayerLocal {
let inverse = snapshot
.initial_state
.current_transform
.inverse()
.unwrap_or(Transform::IDENTITY);
let presented_origin = inverse.transform_point(sui_core::Point::new(
pixel_snap_origin.x,
pixel_snap_origin.y,
));
snapshot
.initial_state
.text_background
.transform(inverse.then(Transform::translation(
-presented_origin.x,
-presented_origin.y,
)));
}
if coordinate_space == PacketCoordinateSpace::LayerLocal && normalization_origin != Vector::ZERO
{
let delta = Vector::new(-normalization_origin.x, -normalization_origin.y);
snapshot.scene.translate(delta);
snapshot.initial_state = translate_resolved_raster_state(&snapshot.initial_state, delta);
}
if coordinate_space == PacketCoordinateSpace::LayerLocal {
let strip_count = snapshot
.inherited_clip_count
.min(snapshot.initial_state.clip_stack.len());
snapshot.initial_state.clip_stack.drain(0..strip_count);
snapshot.initial_state.clip_node = ClipNodeId::ROOT;
let inherited = snapshot.initial_state.current_transform;
snapshot.initial_state.text_raster_transform = Transform::new(
inherited.xx,
inherited.yx,
inherited.xy,
inherited.yy,
0.0,
0.0,
);
snapshot.initial_state.current_transform = Transform::IDENTITY;
snapshot.initial_state.transform_stack.clear();
snapshot.initial_state.transform_node = TransformNodeId::ROOT;
snapshot.initial_state.pixel_snap_offset =
physical_pixel_phase(pixel_snap_origin, raster_scale_factor);
}
if !has_text {
snapshot.initial_state.text_background = Default::default();
snapshot.initial_state.text_lcd_allowed = true;
snapshot.initial_state.text_raster_transform = Transform::IDENTITY;
snapshot.initial_state.pixel_snap_offset = Vector::ZERO;
}
snapshot
}
pub(crate) fn physical_pixel_phase(origin: Vector, raster_scale_factor: f32) -> Vector {
if !raster_scale_factor.is_finite() || raster_scale_factor <= 0.0 {
return Vector::ZERO;
}
let phase = |value: f32| {
if value.is_finite() {
value - ((value * raster_scale_factor).floor() / raster_scale_factor)
} else {
0.0
}
};
Vector::new(phase(origin.x), phase(origin.y))
}
pub(crate) fn packet_text_sample(scene: &Scene) -> Option<String> {
for command in scene.commands() {
let text = match command {
SceneCommand::Label { text, .. } => Some(text.as_str()),
SceneCommand::DrawText(run) => Some(run.text.as_str()),
_ => None,
};
if let Some(text) = text {
let trimmed = text.trim();
if !trimmed.is_empty() {
let mut excerpt = trimmed.chars().take(64).collect::<String>();
if trimmed.chars().count() > 64 {
excerpt.push_str("...");
}
return Some(excerpt);
}
}
}
None
}
pub(crate) fn translate_resolved_raster_state(
state: &ResolvedRasterState,
delta: Vector,
) -> ResolvedRasterState {
let mut translated = state.clone();
translated.clip_stack = translated
.clip_stack
.into_iter()
.map(|clip| translate_resolved_clip_primitive(clip, delta))
.collect();
translated
}
pub(crate) fn transform_resolved_clip_primitive(
primitive: ResolvedClipPrimitive,
transform: Transform,
) -> ResolvedClipPrimitive {
match primitive {
ResolvedClipPrimitive::Rect(rect) => {
ResolvedClipPrimitive::Rect(transform.transform_rect_bbox(rect))
}
ResolvedClipPrimitive::Path { path, bounds, .. } => {
let transformed_path = transform_scene_path(&path, transform);
ResolvedClipPrimitive::Path {
signature: hash_path(&transformed_path, Transform::IDENTITY),
path: transformed_path,
bounds: transform.transform_rect_bbox(bounds),
}
}
}
}
pub(crate) fn translate_resolved_clip_primitive(
primitive: ResolvedClipPrimitive,
delta: Vector,
) -> ResolvedClipPrimitive {
match primitive {
ResolvedClipPrimitive::Rect(rect) => ResolvedClipPrimitive::Rect(rect.translate(delta)),
ResolvedClipPrimitive::Path { path, bounds, .. } => {
let translated_path = transform_scene_path(&path, Transform::translation_vector(delta));
let translated_bounds = bounds.translate(delta);
ResolvedClipPrimitive::Path {
signature: hash_path(&translated_path, Transform::IDENTITY),
path: translated_path,
bounds: translated_bounds,
}
}
}
}
pub(crate) fn descriptor_translation_delta(
previous: &sui_scene::SceneLayerDescriptor,
current: &sui_scene::SceneLayerDescriptor,
) -> Option<Vector> {
if previous.id != current.id
|| previous.owner != current.owner
|| previous.composition_mode != current.composition_mode
|| previous.bounds.size != current.bounds.size
|| previous.content_bounds.size != current.content_bounds.size
|| previous.paint_bounds.size != current.paint_bounds.size
{
return None;
}
let bounds_delta = current.bounds.origin - previous.bounds.origin;
let content_delta = current.content_bounds.origin - previous.content_bounds.origin;
let paint_delta = current.paint_bounds.origin - previous.paint_bounds.origin;
if bounds_delta != content_delta || bounds_delta != paint_delta {
return None;
}
Some(bounds_delta + (current.properties.translation - previous.properties.translation))
}
pub(crate) fn packet_signature(
scene: &Scene,
initial_state: &ResolvedRasterState,
viewport: Size,
surface_size: Size,
feather_width: f32,
) -> u64 {
let mut hasher = DefaultHasher::new();
scene.commands().len().hash(&mut hasher);
hash_scene(scene, &mut hasher);
initial_state.signature().hash(&mut hasher);
viewport.width.to_bits().hash(&mut hasher);
viewport.height.to_bits().hash(&mut hasher);
surface_size.width.to_bits().hash(&mut hasher);
surface_size.height.to_bits().hash(&mut hasher);
feather_width.to_bits().hash(&mut hasher);
hasher.finish()
}
pub(crate) fn hash_scene(scene: &Scene, hasher: &mut DefaultHasher) {
for command in scene.commands() {
hash_scene_command(command, hasher);
}
}
pub(crate) fn hash_scene_command(command: &SceneCommand, hasher: &mut DefaultHasher) {
match command {
SceneCommand::Clear(color) => {
0u8.hash(hasher);
hash_color(*color, hasher);
}
SceneCommand::FillRect { rect, brush } => {
1u8.hash(hasher);
hash_rect(hasher, *rect);
hash_brush(brush, hasher);
}
SceneCommand::StrokeRect {
rect,
brush,
stroke,
} => {
2u8.hash(hasher);
hash_rect(hasher, *rect);
hash_brush(brush, hasher);
stroke.width.to_bits().hash(hasher);
stroke.cap.hash(hasher);
stroke.join.hash(hasher);
}
SceneCommand::FillPath { path, brush } => {
3u8.hash(hasher);
hash_path(path, Transform::IDENTITY).hash(hasher);
hash_brush(brush, hasher);
}
SceneCommand::StrokePath {
path,
brush,
stroke,
} => {
4u8.hash(hasher);
hash_path(path, Transform::IDENTITY).hash(hasher);
hash_brush(brush, hasher);
stroke.width.to_bits().hash(hasher);
stroke.cap.hash(hasher);
stroke.join.hash(hasher);
}
SceneCommand::DrawText(text) => {
5u8.hash(hasher);
hash_rect(hasher, text.rect);
text.text.hash(hasher);
hash_text_style(&text.style, hasher);
}
SceneCommand::DrawShapedText(text) => {
6u8.hash(hasher);
hash_point(hasher, text.origin);
text.layout_handle.get().hash(hasher);
text.layout_version.get().hash(hasher);
hash_rect(hasher, text.bounds);
hash_optional_color(text.color_override, hasher);
}
SceneCommand::DrawShapedTextWindow(text) => {
15u8.hash(hasher);
hash_point(hasher, text.origin);
text.layout_handle.get().hash(hasher);
text.layout_version.get().hash(hasher);
text.line_range.start.hash(hasher);
text.line_range.end.hash(hasher);
hash_rect(hasher, text.bounds);
hash_optional_color(text.color_override, hasher);
}
SceneCommand::DrawImage { rect, source } => {
7u8.hash(hasher);
hash_rect(hasher, *rect);
source.image.get().hash(hasher);
source.sampling.hash(hasher);
source.pixel_snap.hash(hasher);
source
.source_rect
.map(|rect| {
1u8.hash(hasher);
hash_rect(hasher, rect);
})
.unwrap_or_else(|| 0u8.hash(hasher));
source
.tint
.map(|color| {
1u8.hash(hasher);
hash_color(color, hasher);
})
.unwrap_or_else(|| 0u8.hash(hasher));
}
SceneCommand::DrawImageQuad { points, source } => {
17u8.hash(hasher);
for point in points {
hash_point(hasher, *point);
}
source.image.get().hash(hasher);
source.sampling.hash(hasher);
source.pixel_snap.hash(hasher);
source
.source_rect
.map(|rect| {
1u8.hash(hasher);
hash_rect(hasher, rect);
})
.unwrap_or_else(|| 0u8.hash(hasher));
source
.tint
.map(|color| {
1u8.hash(hasher);
hash_color(color, hasher);
})
.unwrap_or_else(|| 0u8.hash(hasher));
}
SceneCommand::DrawShaderRect { rect, shader } => {
16u8.hash(hasher);
hash_rect(hasher, *rect);
hash_widget_shader(shader, hasher);
}
SceneCommand::PushClip { rect } => {
8u8.hash(hasher);
hash_rect(hasher, *rect);
}
SceneCommand::PushClipPath { path } => {
9u8.hash(hasher);
hash_path(path, Transform::IDENTITY).hash(hasher);
}
SceneCommand::PopClip => {
10u8.hash(hasher);
}
SceneCommand::PushTransform { transform } => {
11u8.hash(hasher);
hash_transform(hasher, *transform);
}
SceneCommand::PopTransform => {
12u8.hash(hasher);
}
SceneCommand::PushTextRenderPolicy { policy } => {
19u8.hash(hasher);
hash_text_render_policy(*policy, hasher);
}
SceneCommand::PopTextRenderPolicy => {
20u8.hash(hasher);
}
SceneCommand::Layer(layer) => {
13u8.hash(hasher);
layer.layer_id().get().hash(hasher);
}
SceneCommand::Label { rect, text, color } => {
14u8.hash(hasher);
hash_rect(hasher, *rect);
text.hash(hasher);
hash_color(*color, hasher);
}
SceneCommand::FillRoundedRect {
rect,
radii,
brush,
border,
shadow,
} => {
18u8.hash(hasher);
hash_rect(hasher, *rect);
for radius in radii {
radius.to_bits().hash(hasher);
}
hash_brush(brush, hasher);
match border {
Some(border) => {
1u8.hash(hasher);
border.width.to_bits().hash(hasher);
hash_color(border.color, hasher);
}
None => 0u8.hash(hasher),
}
match shadow {
Some(shadow) => {
1u8.hash(hasher);
shadow.offset_x.to_bits().hash(hasher);
shadow.offset_y.to_bits().hash(hasher);
shadow.blur.to_bits().hash(hasher);
shadow.spread.to_bits().hash(hasher);
hash_color(shadow.color, hasher);
shadow.placement.hash(hasher);
}
None => 0u8.hash(hasher),
}
}
}
}
pub(crate) fn hash_widget_shader(shader: &sui_scene::WidgetShader, hasher: &mut DefaultHasher) {
match shader {
sui_scene::WidgetShader::ColorWheel => {
0u8.hash(hasher);
}
sui_scene::WidgetShader::ColorPickerHueBar => {
1u8.hash(hasher);
}
sui_scene::WidgetShader::ColorPickerSaturationValuePlane {
color_space,
hue,
max_value,
} => {
2u8.hash(hasher);
hash_color_space(*color_space, hasher);
hue.to_bits().hash(hasher);
max_value.to_bits().hash(hasher);
}
sui_scene::WidgetShader::ColorPickerSaturationBar {
color_space,
hue,
value,
} => {
3u8.hash(hasher);
hash_color_space(*color_space, hasher);
hue.to_bits().hash(hasher);
value.to_bits().hash(hasher);
}
sui_scene::WidgetShader::ColorPickerValueBar {
color_space,
hue,
saturation,
max_value,
} => {
4u8.hash(hasher);
hash_color_space(*color_space, hasher);
hue.to_bits().hash(hasher);
saturation.to_bits().hash(hasher);
max_value.to_bits().hash(hasher);
}
sui_scene::WidgetShader::ColorPickerAlphaBar { color } => {
5u8.hash(hasher);
hash_color(*color, hasher);
hash_color_space(color.space, hasher);
}
sui_scene::WidgetShader::ColorPickerRgbChannelBar {
color,
channel,
max_value,
} => {
6u8.hash(hasher);
hash_color(*color, hasher);
hash_color_space(color.space, hasher);
channel.hash(hasher);
max_value.to_bits().hash(hasher);
}
}
}
pub(crate) fn hash_text_render_policy(
policy: sui_scene::TextRenderPolicy,
hasher: &mut DefaultHasher,
) {
match policy.render_mode {
Some(sui_scene::TextRenderMode::Grayscale) => {
1u8.hash(hasher);
}
Some(sui_scene::TextRenderMode::LcdSubpixel) => {
2u8.hash(hasher);
}
None => 0u8.hash(hasher),
}
match policy.subpixel_order {
Some(sui_scene::TextSubpixelOrder::None) => {
1u8.hash(hasher);
}
Some(sui_scene::TextSubpixelOrder::Rgb) => {
2u8.hash(hasher);
}
Some(sui_scene::TextSubpixelOrder::Bgr) => {
3u8.hash(hasher);
}
None => 0u8.hash(hasher),
}
match policy.hinting {
Some(sui_scene::TextRenderHinting::None) => {
1u8.hash(hasher);
}
Some(sui_scene::TextRenderHinting::Slight { max_ppem }) => {
2u8.hash(hasher);
max_ppem.to_bits().hash(hasher);
}
None => 0u8.hash(hasher),
}
match policy.stem_darkening {
Some(sui_scene::TextRenderStemDarkening::None) => {
1u8.hash(hasher);
}
Some(sui_scene::TextRenderStemDarkening::Enabled { max_ppem, amount }) => {
2u8.hash(hasher);
max_ppem.to_bits().hash(hasher);
amount.to_bits().hash(hasher);
}
None => 0u8.hash(hasher),
}
match policy.coverage_policy {
Some(sui_scene::TextRenderCoveragePolicy::Perceptual) => {
1u8.hash(hasher);
}
Some(sui_scene::TextRenderCoveragePolicy::Linear) => {
2u8.hash(hasher);
}
Some(sui_scene::TextRenderCoveragePolicy::Gamma(gamma)) => {
3u8.hash(hasher);
gamma.to_bits().hash(hasher);
}
Some(sui_scene::TextRenderCoveragePolicy::CoverageBoost(amount)) => {
4u8.hash(hasher);
amount.to_bits().hash(hasher);
}
Some(sui_scene::TextRenderCoveragePolicy::TwoCoverageMinusCoverageSq) => {
5u8.hash(hasher);
}
None => 0u8.hash(hasher),
}
}
pub(crate) fn hash_brush(brush: &Brush, hasher: &mut DefaultHasher) {
match brush {
Brush::Solid(color) => {
0u8.hash(hasher);
hash_color(*color, hasher);
}
Brush::LinearGradient { start, end, stops } => {
1u8.hash(hasher);
start.x.to_bits().hash(hasher);
start.y.to_bits().hash(hasher);
end.x.to_bits().hash(hasher);
end.y.to_bits().hash(hasher);
(stops.len() as u32).hash(hasher);
for stop in stops {
stop.offset.to_bits().hash(hasher);
hash_color(stop.color, hasher);
}
}
}
}
pub(crate) fn hash_color(color: Color, hasher: &mut DefaultHasher) {
color.red.to_bits().hash(hasher);
color.green.to_bits().hash(hasher);
color.blue.to_bits().hash(hasher);
color.alpha.to_bits().hash(hasher);
}
pub(crate) fn hash_optional_color(color: Option<Color>, hasher: &mut DefaultHasher) {
match color {
Some(color) => {
1u8.hash(hasher);
hash_color(color, hasher);
hash_color_space(color.space, hasher);
}
None => 0u8.hash(hasher),
}
}
pub(crate) fn hash_color_space(space: ColorSpace, hasher: &mut DefaultHasher) {
(match space {
ColorSpace::Srgb => 0u8,
ColorSpace::LinearSrgb => 1u8,
ColorSpace::DisplayP3 => 2u8,
ColorSpace::LinearDisplayP3 => 3u8,
})
.hash(hasher);
}
pub(crate) fn hash_text_style(style: &TextStyle, hasher: &mut DefaultHasher) {
style.font.map(|font| font.get()).hash(hasher);
style.font_size.to_bits().hash(hasher);
style.line_height.to_bits().hash(hasher);
hash_color(style.color, hasher);
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
use std::sync::Arc;
use sui_core::{Rect, Size, Vector, WidgetId, WindowId};
use sui_scene::{
ImageRegistry, LayerCompositionMode, SceneFrame, SceneLayerUpdate, SceneLayerUpdateKind,
};
use sui_text::{FontRegistry, TextLayoutRegistry};
fn build_layer_frame(
descriptor: sui_scene::SceneLayerDescriptor,
update_kind: SceneLayerUpdateKind,
) -> SceneFrame {
let bounds = descriptor.bounds;
let mut layer_scene = Scene::new();
layer_scene.push(SceneCommand::FillRect {
rect: bounds,
brush: Color::rgba(0.82, 0.36, 0.18, 1.0).into(),
});
let mut scene = Scene::new();
scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
descriptor.clone(),
layer_scene,
)));
SceneFrame {
window_id: WindowId::new(24),
viewport: Size::new(160.0, 80.0),
surface_size: Size::new(160.0, 80.0),
scale_factor: 1.0,
dirty_regions: Vec::new(),
layer_updates: vec![SceneLayerUpdate::from_descriptor(update_kind, descriptor)],
scene,
font_registry: Arc::new(FontRegistry::new()),
image_registry: Arc::new(ImageRegistry::new()),
text_layout_registry: Arc::new(TextLayoutRegistry::default()),
}
}
fn build_nested_layer_frame(
parent_descriptor: sui_scene::SceneLayerDescriptor,
child_descriptor: sui_scene::SceneLayerDescriptor,
layer_updates: Vec<SceneLayerUpdate>,
) -> SceneFrame {
let mut child_scene = Scene::new();
child_scene.push(SceneCommand::FillRect {
rect: child_descriptor.bounds,
brush: Color::rgba(0.82, 0.36, 0.18, 1.0).into(),
});
let mut parent_scene = Scene::new();
parent_scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
child_descriptor,
child_scene,
)));
let mut scene = Scene::new();
scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
parent_descriptor,
parent_scene,
)));
SceneFrame {
window_id: WindowId::new(25),
viewport: Size::new(160.0, 80.0),
surface_size: Size::new(160.0, 80.0),
scale_factor: 1.0,
dirty_regions: Vec::new(),
layer_updates,
scene,
font_registry: Arc::new(FontRegistry::new()),
image_registry: Arc::new(ImageRegistry::new()),
text_layout_registry: Arc::new(TextLayoutRegistry::default()),
}
}
fn layer_packet_signature(compositor: &RetainedCompositorState, layer_id: WidgetId) -> u64 {
let container = CompositionContainerId::Layer(SceneLayerId::from_widget(layer_id));
let packet = compositor
.packets
.values()
.find(|packet| packet.id.container == container)
.expect("retained packet for layer");
packet_signature(
&packet.scene,
&packet.initial_state,
compositor.viewport,
compositor.surface_size,
f32::from_bits(compositor.feather_width_bits),
)
}
fn layer_clip_rects(compositor: &RetainedCompositorState, layer_id: WidgetId) -> Vec<Rect> {
let layer = compositor
.layers
.get(&SceneLayerId::from_widget(layer_id))
.expect("retained layer present");
resolved_clip_primitives(layer.clip_node, &compositor.clips)
.into_iter()
.filter_map(|clip| match clip {
ResolvedClipPrimitive::Rect(rect) => Some(rect),
ResolvedClipPrimitive::Path { .. } => None,
})
.collect()
}
#[test]
fn layer_local_packets_preserve_internal_clips_after_child_layer_split() {
let scroll_id = WidgetId::new(62);
let child_id = WidgetId::new(63);
let scroll_bounds = Rect::new(0.0, 0.0, 200.0, 160.0);
let internal_clip = Rect::new(20.0, 24.0, 120.0, 80.0);
let scroll_descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(scroll_id),
scroll_id,
scroll_bounds,
)
.with_content_bounds(scroll_bounds)
.with_paint_bounds(scroll_bounds)
.with_composition_mode(LayerCompositionMode::Scroll);
let child_descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(child_id),
child_id,
Rect::new(32.0, 36.0, 48.0, 36.0),
)
.with_content_bounds(Rect::new(32.0, 36.0, 48.0, 36.0))
.with_paint_bounds(Rect::new(32.0, 36.0, 48.0, 36.0));
let mut child_scene = Scene::new();
child_scene.push(SceneCommand::FillRect {
rect: Rect::new(32.0, 36.0, 48.0, 36.0),
brush: Color::rgba(0.18, 0.54, 0.82, 1.0).into(),
});
let mut scroll_scene = Scene::new();
scroll_scene.push(SceneCommand::PushClip {
rect: internal_clip,
});
scroll_scene.push(SceneCommand::FillRect {
rect: Rect::new(28.0, 36.0, 52.0, 20.0),
brush: Color::rgba(0.86, 0.92, 0.98, 1.0).into(),
});
scroll_scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
child_descriptor.clone(),
child_scene,
)));
scroll_scene.push(SceneCommand::FillRect {
rect: Rect::new(28.0, 12.0, 96.0, 40.0),
brush: Color::rgba(0.17, 0.21, 0.29, 1.0).into(),
});
scroll_scene.push(SceneCommand::PopClip);
let mut scene = Scene::new();
scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
scroll_descriptor.clone(),
scroll_scene,
)));
let frame = SceneFrame {
window_id: WindowId::new(26),
viewport: Size::new(200.0, 160.0),
surface_size: Size::new(200.0, 160.0),
scale_factor: 1.0,
dirty_regions: Vec::new(),
layer_updates: vec![
SceneLayerUpdate::from_descriptor(SceneLayerUpdateKind::Content, scroll_descriptor),
SceneLayerUpdate::from_descriptor(SceneLayerUpdateKind::Content, child_descriptor),
],
scene,
font_registry: Arc::new(FontRegistry::new()),
image_registry: Arc::new(ImageRegistry::new()),
text_layout_registry: Arc::new(TextLayoutRegistry::default()),
};
let mut text_engine = TextEngine::new().unwrap();
let mut compositor = RetainedCompositorState::default();
let _ = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let packet_id = RetainedPacketId {
container: CompositionContainerId::Layer(SceneLayerId::from_widget(scroll_id)),
segment_index: 1,
};
let packet = compositor
.packets
.get(&packet_id)
.expect("post-child layer packet should be retained");
assert_eq!(
packet.initial_state.clip_stack,
vec![ResolvedClipPrimitive::Rect(internal_clip)],
"layer-local packets should strip only inherited layer clips"
);
assert!(
packet
.draw_ops
.draw_ops
.iter()
.any(|op| op.clip_rect == Some(internal_clip)),
"post-child draw op should keep the internal scroll viewport clip"
);
}
#[test]
fn stack_surface_layers_clip_to_presented_paint_bounds() {
let layer_id = WidgetId::new(61);
let bounds = Rect::new(40.0, 30.0, 32.0, 20.0);
let paint_bounds = Rect::new(32.0, 8.0, 48.0, 54.0);
let descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(layer_id),
layer_id,
bounds,
)
.with_content_bounds(paint_bounds)
.with_paint_bounds(paint_bounds)
.with_is_stack_surface(true)
.with_composition_mode(LayerCompositionMode::Overlay);
let mut layer_scene = Scene::new();
layer_scene.push(SceneCommand::FillRect {
rect: paint_bounds,
brush: Color::rgba(0.82, 0.36, 0.18, 1.0).into(),
});
let mut scene = Scene::new();
scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
descriptor.clone(),
layer_scene,
)));
let frame = SceneFrame {
window_id: WindowId::new(25),
viewport: Size::new(120.0, 90.0),
surface_size: Size::new(120.0, 90.0),
scale_factor: 1.0,
dirty_regions: Vec::new(),
layer_updates: vec![SceneLayerUpdate::from_descriptor(
SceneLayerUpdateKind::Content,
descriptor,
)],
scene,
font_registry: Arc::new(FontRegistry::new()),
image_registry: Arc::new(ImageRegistry::new()),
text_layout_registry: Arc::new(TextLayoutRegistry::default()),
};
let mut text_engine = TextEngine::new().unwrap();
let mut compositor = RetainedCompositorState::default();
let _ = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let clips = layer_clip_rects(&compositor, layer_id);
assert!(
clips.contains(&paint_bounds),
"stack surfaces should keep overhanging popover paint visible; clips={clips:?}"
);
assert!(
!clips.contains(&bounds),
"stack surfaces should not clip popovers to layout bounds; clips={clips:?}"
);
}
#[test]
fn overlay_layers_escape_ancestor_clips_but_keep_their_own_paint_clip() {
let layer_id = WidgetId::new(64);
let ancestor_clip = Rect::new(20.0, 20.0, 48.0, 36.0);
let paint_bounds = Rect::new(8.0, 8.0, 112.0, 72.0);
let descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(layer_id),
layer_id,
Rect::new(28.0, 28.0, 40.0, 24.0),
)
.with_content_bounds(paint_bounds)
.with_paint_bounds(paint_bounds)
.with_is_stack_surface(true)
.with_clip_to_ancestors(false)
.with_composition_mode(LayerCompositionMode::Overlay);
let mut layer_scene = Scene::new();
layer_scene.push(SceneCommand::FillRect {
rect: paint_bounds,
brush: Color::rgba(0.28, 0.64, 0.88, 1.0).into(),
});
let mut scene = Scene::new();
scene.push(SceneCommand::PushClip {
rect: ancestor_clip,
});
scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
descriptor.clone(),
layer_scene,
)));
scene.push(SceneCommand::PopClip);
let frame = SceneFrame {
window_id: WindowId::new(27),
viewport: Size::new(128.0, 88.0),
surface_size: Size::new(128.0, 88.0),
scale_factor: 1.0,
dirty_regions: Vec::new(),
layer_updates: vec![SceneLayerUpdate::from_descriptor(
SceneLayerUpdateKind::Content,
descriptor,
)],
scene,
font_registry: Arc::new(FontRegistry::new()),
image_registry: Arc::new(ImageRegistry::new()),
text_layout_registry: Arc::new(TextLayoutRegistry::default()),
};
let mut text_engine = TextEngine::new().unwrap();
let mut compositor = RetainedCompositorState::default();
let _ = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let clips = layer_clip_rects(&compositor, layer_id);
assert!(
clips.contains(&paint_bounds),
"overlay paint clip missing: {clips:?}"
);
assert!(
!clips.contains(&ancestor_clip),
"overlay should not inherit ancestor clip: {clips:?}"
);
}
fn build_affine_layer_frame(
descriptor: sui_scene::SceneLayerDescriptor,
transform: Transform,
update_kind: SceneLayerUpdateKind,
) -> SceneFrame {
let bounds = descriptor.bounds;
let mut layer_scene = Scene::new();
layer_scene.push(SceneCommand::FillPath {
path: ScenePath::rounded_rect(bounds, 6.0),
brush: Color::rgba(0.82, 0.36, 0.18, 1.0).into(),
});
let mut scene = Scene::new();
scene.push(SceneCommand::PushTransform { transform });
scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
descriptor.clone(),
layer_scene,
)));
scene.push(SceneCommand::PopTransform);
SceneFrame {
window_id: WindowId::new(25),
viewport: Size::new(320.0, 180.0),
surface_size: Size::new(320.0, 180.0),
scale_factor: 1.0,
dirty_regions: Vec::new(),
layer_updates: vec![SceneLayerUpdate::from_descriptor(update_kind, descriptor)],
scene,
font_registry: Arc::new(FontRegistry::new()),
image_registry: Arc::new(ImageRegistry::new()),
text_layout_registry: Arc::new(TextLayoutRegistry::default()),
}
}
#[test]
fn nested_overlay_is_locally_above_later_effect_content() {
let first_dialog_id = WidgetId::new(65);
let popup_id = WidgetId::new(66);
let second_dialog_id = WidgetId::new(67);
let bounds = Rect::new(0.0, 0.0, 120.0, 80.0);
let first_dialog = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(first_dialog_id),
first_dialog_id,
bounds,
)
.with_content_bounds(bounds)
.with_paint_bounds(bounds)
.with_is_stack_surface(true)
.with_stack_order(0)
.with_composition_mode(LayerCompositionMode::Effect);
let popup = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(popup_id),
popup_id,
bounds,
)
.with_content_bounds(bounds)
.with_paint_bounds(bounds)
.with_is_stack_surface(true)
.with_stack_order(1)
.with_composition_mode(LayerCompositionMode::Overlay);
let second_dialog = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(second_dialog_id),
second_dialog_id,
bounds,
)
.with_content_bounds(bounds)
.with_paint_bounds(bounds)
.with_is_stack_surface(true)
.with_stack_order(2)
.with_composition_mode(LayerCompositionMode::Effect);
let mut popup_scene = Scene::new();
popup_scene.push(SceneCommand::FillRect {
rect: bounds,
brush: Color::rgba(0.9, 0.1, 0.2, 1.0).into(),
});
let mut first_dialog_scene = Scene::new();
first_dialog_scene.push(SceneCommand::FillRect {
rect: bounds,
brush: Color::rgba(0.1, 0.2, 0.3, 1.0).into(),
});
first_dialog_scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
popup.clone(),
popup_scene,
)));
first_dialog_scene.push(SceneCommand::FillRect {
rect: bounds,
brush: Color::rgba(0.1, 0.8, 0.2, 1.0).into(),
});
let mut second_dialog_scene = Scene::new();
second_dialog_scene.push(SceneCommand::FillRect {
rect: bounds,
brush: Color::rgba(0.1, 0.2, 0.9, 1.0).into(),
});
let mut scene = Scene::new();
scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
first_dialog.clone(),
first_dialog_scene,
)));
scene.push(SceneCommand::Layer(SceneLayer::from_descriptor(
second_dialog.clone(),
second_dialog_scene,
)));
let frame = SceneFrame {
window_id: WindowId::new(28),
viewport: bounds.size,
surface_size: bounds.size,
scale_factor: 1.0,
dirty_regions: Vec::new(),
layer_updates: vec![
SceneLayerUpdate::from_descriptor(SceneLayerUpdateKind::Content, first_dialog),
SceneLayerUpdate::from_descriptor(SceneLayerUpdateKind::Content, popup),
SceneLayerUpdate::from_descriptor(SceneLayerUpdateKind::Content, second_dialog),
],
scene,
font_registry: Arc::new(FontRegistry::new()),
image_registry: Arc::new(ImageRegistry::new()),
text_layout_registry: Arc::new(TextLayoutRegistry::default()),
};
let mut text_engine = TextEngine::new().unwrap();
let mut compositor = RetainedCompositorState::default();
let _ = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let first_dialog_layer = compositor
.layers
.get(&SceneLayerId::from_widget(first_dialog_id))
.expect("first dialog retained layer");
assert_eq!(
first_dialog_layer.items,
vec![
CompositionItem::Packet(RetainedPacketId {
container: CompositionContainerId::Layer(SceneLayerId::from_widget(
first_dialog_id,
)),
segment_index: 0,
}),
CompositionItem::Packet(RetainedPacketId {
container: CompositionContainerId::Layer(SceneLayerId::from_widget(
first_dialog_id,
)),
segment_index: 1,
}),
CompositionItem::Layer(SceneLayerId::from_widget(popup_id)),
],
"the popup must paint after all ordinary content in its owner surface"
);
assert_eq!(
compositor.root.items,
vec![
CompositionItem::Layer(SceneLayerId::from_widget(first_dialog_id)),
CompositionItem::Layer(SceneLayerId::from_widget(second_dialog_id)),
],
"a popup in an older modal must remain below a newer modal"
);
}
#[test]
fn translation_only_layer_updates_reuse_retained_content() {
let layer_id = WidgetId::new(53);
let descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(layer_id),
layer_id,
Rect::new(8.0, 10.0, 80.0, 36.0),
)
.with_content_bounds(Rect::new(8.0, 10.0, 80.0, 36.0))
.with_paint_bounds(Rect::new(8.0, 10.0, 80.0, 36.0));
let mut frame = build_layer_frame(descriptor.clone(), SceneLayerUpdateKind::Content);
let mut text_engine = TextEngine::new().unwrap();
let mut compositor = RetainedCompositorState::default();
let first = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let first_signature = layer_packet_signature(&compositor, layer_id);
let first_content_version =
compositor.layers[&SceneLayerId::from_widget(layer_id)].content_version;
let translated = descriptor.with_translation(Vector::new(36.0, 0.0));
frame = build_layer_frame(translated, SceneLayerUpdateKind::Transform);
let second = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let second_signature = layer_packet_signature(&compositor, layer_id);
let second_content_version =
compositor.layers[&SceneLayerId::from_widget(layer_id)].content_version;
assert_eq!(first_signature, second_signature);
assert_eq!(first_content_version, second_content_version);
assert_eq!(compositor.last_frame_stats.packet_build_count, 0);
assert_eq!(compositor.last_frame_stats.direct_packets, 1);
assert_ne!(first.scene_vertices, second.scene_vertices);
assert_eq!(
compositor.layers[&SceneLayerId::from_widget(layer_id)]
.descriptor
.properties
.translation,
Vector::new(36.0, 0.0)
);
}
#[test]
fn scale_only_layer_updates_reuse_retained_content() {
let layer_id = WidgetId::new(54);
let descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(layer_id),
layer_id,
Rect::new(8.0, 10.0, 80.0, 36.0),
)
.with_content_bounds(Rect::new(8.0, 10.0, 80.0, 36.0))
.with_paint_bounds(Rect::new(8.0, 10.0, 80.0, 36.0));
let mut frame = build_layer_frame(descriptor.clone(), SceneLayerUpdateKind::Content);
let mut text_engine = TextEngine::new().unwrap();
let mut compositor = RetainedCompositorState::default();
let first = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let first_content_version =
compositor.layers[&SceneLayerId::from_widget(layer_id)].content_version;
let scaled = descriptor.with_properties(LayerProperties::default().with_scale(0.5));
frame = build_layer_frame(scaled, SceneLayerUpdateKind::Transform);
let second = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
assert_eq!(compositor.last_frame_stats.packet_build_count, 0);
assert_eq!(
compositor.layers[&SceneLayerId::from_widget(layer_id)].content_version,
first_content_version
);
let span = |vertices: &[_]| {
let xs = vertices
.iter()
.map(|vertex: &crate::gpu::Vertex| vertex.position[0])
.collect::<Vec<_>>();
let min = xs.iter().copied().fold(f32::INFINITY, f32::min);
let max = xs.iter().copied().fold(f32::NEG_INFINITY, f32::max);
(min, max)
};
let (first_min, first_max) = span(&first.scene_vertices);
let (second_min, second_max) = span(&second.scene_vertices);
let ratio = (second_max - second_min) / (first_max - first_min);
assert!((ratio - 0.5).abs() < 0.02, "scaled to half: {ratio}");
let first_center = (first_min + first_max) * 0.5;
let second_center = (second_min + second_max) * 0.5;
assert!(
(first_center - second_center).abs() < 1e-3,
"scaling keeps the center"
);
}
#[test]
fn affine_parent_transform_reuses_layer_local_packet() {
let layer_id = WidgetId::new(153);
let descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(layer_id),
layer_id,
Rect::new(8.0, 10.0, 80.0, 36.0),
)
.with_content_bounds(Rect::new(8.0, 10.0, 80.0, 36.0))
.with_paint_bounds(Rect::new(8.0, 10.0, 80.0, 36.0));
let mut frame = build_affine_layer_frame(
descriptor.clone(),
Transform::scale(0.5, 0.5).then(Transform::translation(20.0, 14.0)),
SceneLayerUpdateKind::Content,
);
let mut text_engine = TextEngine::new().unwrap();
let mut compositor = RetainedCompositorState::default();
let first = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let first_signature = layer_packet_signature(&compositor, layer_id);
frame = build_affine_layer_frame(
descriptor,
Transform::scale(0.85, 0.85).then(Transform::translation(44.0, 28.0)),
SceneLayerUpdateKind::Transform,
);
let second = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let second_signature = layer_packet_signature(&compositor, layer_id);
assert_eq!(first_signature, second_signature);
assert_eq!(compositor.last_frame_stats.packet_build_count, 0);
assert_ne!(first.scene_vertices, second.scene_vertices);
}
#[test]
fn opacity_only_layer_updates_reuse_retained_content() {
let layer_id = WidgetId::new(54);
let descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(layer_id),
layer_id,
Rect::new(8.0, 10.0, 80.0, 36.0),
)
.with_content_bounds(Rect::new(8.0, 10.0, 80.0, 36.0))
.with_paint_bounds(Rect::new(8.0, 10.0, 80.0, 36.0));
let mut frame = build_layer_frame(descriptor.clone(), SceneLayerUpdateKind::Content);
let mut text_engine = TextEngine::new().unwrap();
let mut compositor = RetainedCompositorState::default();
let first = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let first_signature = layer_packet_signature(&compositor, layer_id);
let first_content_version =
compositor.layers[&SceneLayerId::from_widget(layer_id)].content_version;
let first_alpha = first.scene_vertices[0].color[3];
let faded = descriptor.with_opacity(0.5);
frame = build_layer_frame(faded, SceneLayerUpdateKind::Effect);
let second = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let second_signature = layer_packet_signature(&compositor, layer_id);
let second_content_version =
compositor.layers[&SceneLayerId::from_widget(layer_id)].content_version;
let second_alpha = second.scene_vertices[0].color[3];
assert_eq!(first_signature, second_signature);
assert_eq!(first_content_version, second_content_version);
assert_eq!(compositor.last_frame_stats.packet_build_count, 0);
assert_eq!(compositor.last_frame_stats.direct_packets, 1);
assert!(second_alpha < first_alpha);
assert_eq!(second_alpha, first_alpha * 0.5);
assert_eq!(
compositor.layers[&SceneLayerId::from_widget(layer_id)]
.descriptor
.properties
.opacity,
0.5
);
}
#[test]
fn nested_layers_inherit_ancestor_opacity_and_translation() {
let parent_id = WidgetId::new(55);
let child_id = WidgetId::new(56);
let parent_descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(parent_id),
parent_id,
Rect::new(8.0, 8.0, 112.0, 56.0),
)
.with_content_bounds(Rect::new(8.0, 8.0, 112.0, 56.0))
.with_paint_bounds(Rect::new(8.0, 8.0, 112.0, 56.0))
.with_is_stack_surface(true)
.with_composition_mode(LayerCompositionMode::Overlay);
let child_descriptor = sui_scene::SceneLayerDescriptor::new(
SceneLayerId::from_widget(child_id),
child_id,
Rect::new(32.0, 20.0, 48.0, 24.0),
)
.with_content_bounds(Rect::new(32.0, 20.0, 48.0, 24.0))
.with_paint_bounds(Rect::new(32.0, 20.0, 48.0, 24.0))
.with_opacity(0.5)
.with_translation(Vector::new(2.0, 0.0))
.with_composition_mode(LayerCompositionMode::Scroll);
let initial_updates = vec![
SceneLayerUpdate::from_descriptor(
SceneLayerUpdateKind::Content,
parent_descriptor.clone(),
),
SceneLayerUpdate::from_descriptor(
SceneLayerUpdateKind::Content,
child_descriptor.clone(),
),
];
let mut frame = build_nested_layer_frame(
parent_descriptor.clone(),
child_descriptor.clone(),
initial_updates,
);
let mut text_engine = TextEngine::new().unwrap();
let mut compositor = RetainedCompositorState::default();
let first = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let first_signature = layer_packet_signature(&compositor, child_id);
let first_content_version =
compositor.layers[&SceneLayerId::from_widget(child_id)].content_version;
let first_alpha = first.scene_vertices[0].color[3];
let first_min_x = first
.scene_vertices
.iter()
.map(|vertex| vertex.position[0])
.fold(f32::INFINITY, f32::min);
let transitioned_parent = parent_descriptor
.with_opacity(0.4)
.with_translation(Vector::new(10.0, 6.0));
frame = build_nested_layer_frame(
transitioned_parent.clone(),
child_descriptor.clone(),
vec![
SceneLayerUpdate::from_descriptor(
SceneLayerUpdateKind::Transform,
transitioned_parent.clone(),
),
SceneLayerUpdate::from_descriptor(
SceneLayerUpdateKind::Effect,
transitioned_parent.clone(),
),
],
);
let second = compositor
.prepare_frame(&frame, &mut text_engine, DEFAULT_FEATHER_WIDTH)
.unwrap();
let second_signature = layer_packet_signature(&compositor, child_id);
let second_content_version =
compositor.layers[&SceneLayerId::from_widget(child_id)].content_version;
let second_alpha = second.scene_vertices[0].color[3];
let second_min_x = second
.scene_vertices
.iter()
.map(|vertex| vertex.position[0])
.fold(f32::INFINITY, f32::min);
let child_layer = &compositor.layers[&SceneLayerId::from_widget(child_id)];
let child_clips = layer_clip_rects(&compositor, child_id);
assert_eq!(first_signature, second_signature);
assert_eq!(first_content_version, second_content_version);
assert_eq!(compositor.last_frame_stats.packet_build_count, 0);
assert!((second_alpha - (first_alpha * 0.4)).abs() < f32::EPSILON);
let expected_ndc_delta_x = (10.0 / frame.viewport.width) * 2.0;
assert!(
(second_min_x - first_min_x - expected_ndc_delta_x).abs() < f32::EPSILON,
"expected nested child vertices to move by {expected_ndc_delta_x}, got {}",
second_min_x - first_min_x
);
assert_eq!(
child_layer.composed_properties,
ComposedLayer {
opacity: 0.2,
scale: LayerProperties::IDENTITY_SCALE,
offset: Vector::new(12.0, 6.0),
}
);
assert!(
child_clips.contains(&transitioned_parent.presented_paint_bounds()),
"nested child lost its translated stack-surface clip: {child_clips:?}"
);
assert!(
child_clips.contains(
&child_descriptor
.presented_bounds()
.translate(transitioned_parent.properties.translation)
),
"nested scroll clip did not follow the ancestor translation: {child_clips:?}"
);
}
}