use super::walker::{walk, IServerTreeVisitor, TreeWalkContext};
use super::ServerCompositionVisual;
use crate::media::{RenderOptions, TextOptions};
use crate::platform::{IDrawingContextImpl, LtrbRect};
use crate::rendering::composition::effects::{pop_custom_effect_graph_with, push_custom_effect_graph_with};
use crate::rendering::composition::server::{
render_scope, CompositorPools, IDirtyRectTracker, LitContent, ServerDrawItems, ServerVisualRenderContext,
};
use crate::{Matrix, Vector};
use std::rc::Rc;
pub(super) struct RenderContext<'a> {
pub(super) canvas: &'a mut dyn IDrawingContextImpl,
dirty_rects: Option<Rc<dyn IDirtyRectTracker>>,
pub(super) pools: &'a CompositorPools,
render_children: bool,
walk_context: TreeWalkContext,
opacity_stack: Vec<f64>,
opacity: f64,
full_skip: bool,
used_cache: bool,
rendered_visuals: i32,
visited_visuals: i32,
pub(super) root_visual: Rc<ServerCompositionVisual>,
skip_next_visual_transform: bool,
rendering_to_bitmap_cache: bool,
pub(super) adorner_pushed_clip_stack: Option<Vec<i32>>,
pub(super) current_adorner_layer: Option<Rc<ServerCompositionVisual>>,
stop_at: Option<*const ServerCompositionVisual>,
stopped: bool,
lights_registered: bool,
}
impl<'a> RenderContext<'a> {
#[allow(clippy::too_many_arguments)]
fn new(
root_visual: Rc<ServerCompositionVisual>,
canvas: &'a mut dyn IDrawingContextImpl,
mut dirty_rects: Option<Rc<dyn IDirtyRectTracker>>,
pools: &'a CompositorPools,
matrix: Matrix,
mut clip: LtrbRect,
render_children: bool,
skip_root_visual_transform: bool,
rendering_to_bitmap_cache: bool,
) -> Self {
if let Some(tracker) = &dirty_rects {
let dirty_clip = tracker.combined_rect();
let is_single = tracker.is_single_dirty_rect_tracker();
if is_single {
dirty_rects = None;
}
clip = clip.intersect_or_empty(dirty_clip);
}
let lights_registered = root_visual.compositor().is_some_and(|compositor| compositor.has_registered_lights());
Self {
canvas,
dirty_rects,
pools,
render_children,
root_visual,
lights_registered,
walk_context: TreeWalkContext::new(pools, matrix, clip),
opacity: 1.0,
opacity_stack: pools.double_stack_pool.rent(),
full_skip: false,
used_cache: false,
rendered_visuals: 0,
visited_visuals: 0,
skip_next_visual_transform: skip_root_visual_transform,
rendering_to_bitmap_cache,
adorner_pushed_clip_stack: None,
current_adorner_layer: None,
stop_at: None,
stopped: false,
}
}
fn handle_pre_graph_transform_clip_opacity(&mut self, visual: &ServerCompositionVisual) -> bool {
let Some(transformed_sub_tree_bounds) = visual.transformed_sub_tree_bounds.get() else { return false };
if !visual.visible() {
return false;
}
let visual_opacity = visual.opacity() as f64;
let effective_opacity = visual_opacity * self.opacity;
if effective_opacity <= 0.003 {
return false;
}
let mut effective_new_transform = self.walk_context.transform;
if let Some(own_transform) = visual.own_transform.get() {
if !self.skip_next_visual_transform {
effective_new_transform = own_transform * self.walk_context.transform;
}
}
self.skip_next_visual_transform = false;
let mut effective_clip = self.walk_context.clip;
if let Some(own_clip) = visual.own_clip_rect.get() {
effective_clip = effective_clip.intersect_or_empty(own_clip.transform_to_aabb(effective_new_transform));
}
let world_bounds = transformed_sub_tree_bounds.transform_to_aabb(self.walk_context.transform);
if !effective_clip.intersects(world_bounds)
|| self.dirty_rects.as_ref().is_some_and(|d| !d.intersects(world_bounds))
{
return false;
}
self.rendered_visuals += 1;
if visual_opacity != 1.0 {
self.opacity_stack.push(self.opacity);
self.opacity = effective_opacity;
crate::perf_count!(RenderVisualOpacitiesPushed);
self.canvas.push_opacity(visual_opacity, Some(transformed_sub_tree_bounds.to_rect()));
}
if visual.own_transform.get().is_some() {
self.walk_context.push_set_transform(effective_new_transform); crate::perf_count!(RenderVisualTransformsSet);
self.canvas.set_transform(effective_new_transform);
}
if visual.own_clip_rect.get().is_some() {
self.walk_context.push_clip(effective_clip);
}
if visual.clip_to_bounds() {
crate::perf_count!(RenderVisualClipsPushed);
visual.content.push_clip_to_bounds(visual, self.canvas);
}
if let Some(clip) = visual.clip() {
self.canvas.push_geometry_clip(&*clip);
}
if let Some(shape) = visual.composition_clip_shape() {
shape.push(self.canvas);
}
true
}
fn render_draw_items(
&mut self,
holder: &Rc<ServerCompositionVisual>,
items: &ServerDrawItems,
range: std::ops::Range<usize>,
) {
if range.is_empty() {
return;
}
let transform = self.walk_context.transform;
let clip = self.walk_context.clip;
let lit = if self.lights_registered { LitContent::begin(holder, self.canvas) } else { None };
let canvas = &mut *self.canvas;
let dirty_rects = self.dirty_rects.as_deref();
let moved = render_scope::with_painting_visual(holder, || {
items.render(range, canvas, transform, clip, dirty_rects)
});
if moved {
crate::perf_count!(RenderVisualTransformsSet);
self.canvas.set_transform(transform);
}
if let Some(lit) = lit {
lit.end(self.canvas);
}
}
fn dispose(mut self) {
let pools = self.pools;
self.adorner_helper_dispose();
pools.double_stack_pool.return_stack(self.opacity_stack);
self.walk_context.dispose(pools);
}
}
fn span_in_walk_space(from: f64, to: f64, scale: f64, offset: f64) -> Option<(f64, f64)> {
let end = |value: f64| -> Option<(f64, f64)> {
let at = (value - offset) / scale;
if at.is_nan() {
return None;
}
if at.is_infinite() {
return Some((at, at));
}
let off = ((value.abs() + offset.abs() + 1.0) / scale.abs() * 1e-9).max(at.abs() * 1e-12);
Some((at - off, at + off))
};
let (from, to) = (end(from)?, end(to)?);
Some((from.0.min(to.0), from.1.max(to.1)))
}
impl RenderContext<'_> {
fn clip_and_origin_in_walk_space(&self) -> Option<(LtrbRect, LtrbRect)> {
let m = self.walk_context.transform;
let straight = m.m12 == 0.0 && m.m21 == 0.0 && !m.contains_perspective();
if !straight || m.m11 == 0.0 || m.m22 == 0.0 || !(m.m11 + m.m22 + m.m31 + m.m32).is_finite() {
return None;
}
let clip = self.walk_context.clip;
let (left, right) = span_in_walk_space(clip.left, clip.right, m.m11, m.m31)?;
let (top, bottom) = span_in_walk_space(clip.top, clip.bottom, m.m22, m.m32)?;
let (origin_left, origin_right) = span_in_walk_space(0.0, 0.0, m.m11, m.m31)?;
let (origin_top, origin_bottom) = span_in_walk_space(0.0, 0.0, m.m22, m.m32)?;
Some((
LtrbRect::new(left, top, right, bottom),
LtrbRect::new(origin_left, origin_top, origin_right, origin_bottom),
))
}
}
impl IServerTreeVisitor for RenderContext<'_> {
fn next_child(&mut self, container: &Rc<ServerCompositionVisual>, from: usize, _count: usize) -> usize {
if self.stop_at.is_some() || self.skip_next_visual_transform {
return from;
}
let Some(children) = container.children() else { return from };
let Some((clip, origin)) = self.clip_and_origin_in_walk_space() else { return from };
let next = children.next_child_in(from, clip, origin);
if next > from {
self.visited_visuals += (next - from) as i32;
if container.has_draw_items() {
for index in from..next {
self.before_child(container, index);
}
}
}
next
}
fn before_child(&mut self, container: &Rc<ServerCompositionVisual>, index: usize) {
if !container.has_draw_items() || self.stopped {
return;
}
if let Some(items) = container.content.draw_items() {
self.render_draw_items(container, items, items.range_before_child(index));
}
}
fn pre_subgraph(&mut self, visual: &Rc<ServerCompositionVisual>) -> bool {
if let Some(stop_at) = self.stop_at {
if self.stopped || std::ptr::eq(Rc::as_ptr(visual), stop_at) {
self.stopped = true;
self.full_skip = true;
return false;
}
}
self.visited_visuals += 1;
let bitmap_cache_root = self.rendering_to_bitmap_cache && Rc::ptr_eq(visual, &self.root_visual);
if !bitmap_cache_root {
if !self.handle_pre_graph_transform_clip_opacity(visual) {
self.full_skip = true;
return false;
}
if visual.adorned_visual().is_some() {
self.adorner_helper_render_pre_graph_push_adorner_clip(visual);
}
if let Some(cache) = visual.cache() {
crate::perf_count!(RenderCachedVisualsDrawn);
let (visited, rendered) = cache.draw(self.canvas);
self.visited_visuals += visited;
self.rendered_visuals += rendered;
self.used_cache = true;
return false;
}
}
if visual.render_options() != RenderOptions::default() {
self.canvas.push_render_options(visual.render_options());
}
if visual.text_options() != TextOptions::default() {
self.canvas.push_text_options(visual.text_options());
}
if let (Some(mask), Some(bounds)) = (visual.opacity_mask_brush(), visual.sub_tree_bounds.get()) {
self.canvas.push_opacity_mask(&*mask, bounds.to_rect());
}
if let (Some(effect), Some(bounds)) = (visual.effect(), visual.sub_tree_bounds.get()) {
let graph = effect.as_custom_effect().is_some_and(|custom| {
push_custom_effect_graph_with(self.canvas, custom, bounds.to_rect(), visual.compositor())
});
if !graph {
if let Some(effects) = self.canvas.as_drawing_context_impl_with_effects() {
effects.push_effect(Some(bounds.to_rect()), &*effect);
}
}
}
let clip = self.walk_context.clip;
let lit = if self.lights_registered { LitContent::begin(visual, self.canvas) } else { None };
let canvas = &mut *self.canvas;
render_scope::with_painting_visual(visual, || {
visual.render_core(&mut ServerVisualRenderContext::new(canvas), clip);
});
if let Some(lit) = lit {
lit.end(self.canvas);
}
self.render_children
}
fn post_subgraph(&mut self, visual: &Rc<ServerCompositionVisual>) {
if self.full_skip {
self.full_skip = false;
return;
}
let bitmap_cache_root = self.rendering_to_bitmap_cache && Rc::ptr_eq(visual, &self.root_visual);
if !self.used_cache {
if visual.has_draw_items() && self.render_children && !self.stopped {
if let Some(items) = visual.content.draw_items() {
let children = visual.children().map_or(0, |children| children.count());
self.render_draw_items(visual, items, items.range_after_children(children));
}
}
let canvas = &mut *self.canvas;
render_scope::with_painting_visual(visual, || {
visual.content.render_after_children(visual, &mut ServerVisualRenderContext::new(canvas));
});
if let (Some(effect), Some(bounds)) = (visual.effect(), visual.sub_tree_bounds.get()) {
let graph = effect.as_custom_effect().is_some_and(|custom| {
pop_custom_effect_graph_with(self.canvas, custom, bounds.to_rect(), visual.compositor())
});
if !graph {
if let Some(effects) = self.canvas.as_drawing_context_impl_with_effects() {
effects.pop_effect();
}
}
}
if visual.opacity_mask_brush().is_some() && visual.sub_tree_bounds.get().is_some() {
self.canvas.pop_opacity_mask();
}
if visual.text_options() != TextOptions::default() {
self.canvas.pop_text_options();
}
if visual.render_options() != RenderOptions::default() {
self.canvas.pop_render_options();
}
}
self.used_cache = false;
if !bitmap_cache_root {
if visual.adorned_visual().is_some() {
self.adorner_helper_render_post_graph_push_adorner_clip(visual);
}
if let Some(shape) = visual.composition_clip_shape() {
shape.pop(self.canvas);
}
if visual.clip().is_some() {
self.canvas.pop_geometry_clip();
}
if visual.clip_to_bounds() {
self.canvas.pop_clip();
}
if visual.own_clip_rect.get().is_some() {
self.walk_context.pop_clip();
}
if visual.own_transform.get().is_some() {
self.walk_context.pop_transform();
crate::perf_count!(RenderVisualTransformsSet);
self.canvas.set_transform(self.walk_context.transform);
}
if visual.opacity() != 1.0 {
self.canvas.pop_opacity();
self.opacity = self.opacity_stack.pop().expect("an opacity was pushed");
}
}
}
}
impl ServerCompositionVisual {
pub fn render(
self: &Rc<Self>,
canvas: &mut dyn IDrawingContextImpl,
clip: LtrbRect,
dirty_rects: Option<Rc<dyn IDirtyRectTracker>>,
render_children: bool,
skip_root_visual_transform: bool,
rendering_to_bitmap_cache: bool,
) -> (i32, i32) {
self.render_with_stop(
canvas,
clip,
dirty_rects,
render_children,
skip_root_visual_transform,
rendering_to_bitmap_cache,
None,
Vector::ZERO,
)
}
pub(crate) fn render_up_to(
self: &Rc<Self>,
canvas: &mut dyn IDrawingContextImpl,
clip: LtrbRect,
stop_at: &Rc<ServerCompositionVisual>,
skip_root_visual_transform: bool,
rendering_to_bitmap_cache: bool,
device_origin: Vector,
) {
self.render_with_stop(
canvas,
clip,
None,
true,
skip_root_visual_transform,
rendering_to_bitmap_cache,
Some(Rc::as_ptr(stop_at)),
device_origin,
);
}
#[allow(clippy::too_many_arguments)]
fn render_with_stop(
self: &Rc<Self>,
canvas: &mut dyn IDrawingContextImpl,
clip: LtrbRect,
dirty_rects: Option<Rc<dyn IDirtyRectTracker>>,
render_children: bool,
skip_root_visual_transform: bool,
rendering_to_bitmap_cache: bool,
stop_at: Option<*const ServerCompositionVisual>,
device_origin: Vector,
) -> (i32, i32) {
let Some(compositor) = self.compositor() else { return (0, 0) };
let pools = compositor.pools();
let transform = canvas.transform();
let root = render_scope::RenderRoot {
visual: self.clone(),
transform,
clip,
device_origin,
skip_root_visual_transform,
rendering_to_bitmap_cache,
};
render_scope::with_render_root(root, || {
let mut render_context = RenderContext::new(
self.clone(),
canvas,
dirty_rects,
pools,
transform,
clip,
render_children,
skip_root_visual_transform,
rendering_to_bitmap_cache,
);
render_context.stop_at = stop_at;
walk(&mut render_context, self, pools);
let result = (render_context.visited_visuals, render_context.rendered_visuals);
{
use crate::diagnostics::perf_counters::{add, PerfCounter};
add(PerfCounter::RenderVisualsVisited, result.0.max(0) as u64);
add(PerfCounter::RenderVisualsRendered, result.1.max(0) as u64);
}
render_context.dispose();
result
})
}
}