summaryrefslogtreecommitdiffstats
path: root/gfx/wr/webrender/src/surface.rs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /gfx/wr/webrender/src/surface.rs
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/wr/webrender/src/surface.rs')
-rw-r--r--gfx/wr/webrender/src/surface.rs612
1 files changed, 612 insertions, 0 deletions
diff --git a/gfx/wr/webrender/src/surface.rs b/gfx/wr/webrender/src/surface.rs
new file mode 100644
index 0000000000..44be7ae279
--- /dev/null
+++ b/gfx/wr/webrender/src/surface.rs
@@ -0,0 +1,612 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use api::units::*;
+use crate::command_buffer::{CommandBufferBuilderKind, CommandBufferList, CommandBufferBuilder, CommandBufferIndex};
+use crate::internal_types::FastHashMap;
+use crate::picture::{SurfaceInfo, SurfaceIndex, TileKey, SubSliceIndex, MAX_COMPOSITOR_SURFACES};
+use crate::prim_store::{PictureIndex};
+use crate::render_task_graph::{RenderTaskId, RenderTaskGraphBuilder};
+use crate::render_target::ResolveOp;
+use crate::render_task::{RenderTask, RenderTaskKind, RenderTaskLocation};
+use crate::visibility::{VisibilityState, PrimitiveVisibility};
+
+/*
+ Contains functionality to help building the render task graph from a series of off-screen
+ surfaces that are created during the prepare pass. For now, it maintains existing behavior.
+ A future patch will add support for surface sub-graphs, while ensuring the render task
+ graph itself is built correctly with dependencies regardless of the surface kind (chained,
+ tiled, simple).
+ */
+
+// Information about the render task(s) for a given tile
+#[cfg_attr(feature = "capture", derive(Serialize))]
+#[cfg_attr(feature = "replay", derive(Deserialize))]
+pub struct SurfaceTileDescriptor {
+ /// Target render task for commands added to this tile. This is changed
+ /// each time a sub-graph is encountered on this tile
+ pub current_task_id: RenderTaskId,
+ /// The compositing task for this tile, if required. This is only needed
+ /// when a tile contains one or more sub-graphs.
+ pub composite_task_id: Option<RenderTaskId>,
+ /// Dirty rect for this tile
+ pub dirty_rect: PictureRect,
+}
+
+// Details of how a surface is rendered
+pub enum SurfaceDescriptorKind {
+ // Picture cache tiles
+ Tiled {
+ tiles: FastHashMap<TileKey, SurfaceTileDescriptor>,
+ },
+ // A single surface (e.g. for an opacity filter)
+ Simple {
+ render_task_id: RenderTaskId,
+ dirty_rect: PictureRect,
+ },
+ // A surface with 1+ intermediate tasks (e.g. blur)
+ Chained {
+ render_task_id: RenderTaskId,
+ root_task_id: RenderTaskId,
+ dirty_rect: PictureRect,
+ },
+}
+
+// Describes how a surface is rendered
+pub struct SurfaceDescriptor {
+ kind: SurfaceDescriptorKind,
+}
+
+impl SurfaceDescriptor {
+ // Create a picture cache tiled surface
+ pub fn new_tiled(
+ tiles: FastHashMap<TileKey, SurfaceTileDescriptor>,
+ ) -> Self {
+ SurfaceDescriptor {
+ kind: SurfaceDescriptorKind::Tiled {
+ tiles,
+ },
+ }
+ }
+
+ // Create a chained surface (e.g. blur)
+ pub fn new_chained(
+ render_task_id: RenderTaskId,
+ root_task_id: RenderTaskId,
+ dirty_rect: PictureRect,
+ ) -> Self {
+ SurfaceDescriptor {
+ kind: SurfaceDescriptorKind::Chained {
+ render_task_id,
+ root_task_id,
+ dirty_rect,
+ },
+ }
+ }
+
+ // Create a simple surface (e.g. opacity)
+ pub fn new_simple(
+ render_task_id: RenderTaskId,
+ dirty_rect: PictureRect,
+ ) -> Self {
+ SurfaceDescriptor {
+ kind: SurfaceDescriptorKind::Simple {
+ render_task_id,
+ dirty_rect,
+ },
+ }
+ }
+}
+
+// Describes a list of command buffers that we are adding primitives to
+// for a given surface. These are created from a command buffer builder
+// as an optimization - skipping the indirection pic_task -> cmd_buffer_index
+struct CommandBufferTargets {
+ available_cmd_buffers: Vec<Vec<(PictureRect, CommandBufferIndex)>>,
+}
+
+impl CommandBufferTargets {
+ fn new() -> Self {
+ CommandBufferTargets {
+ available_cmd_buffers: vec![Vec::new(); MAX_COMPOSITOR_SURFACES+1],
+ }
+ }
+
+ fn init(
+ &mut self,
+ cb: &CommandBufferBuilder,
+ rg_builder: &RenderTaskGraphBuilder,
+ ) {
+ for available_cmd_buffers in &mut self.available_cmd_buffers {
+ available_cmd_buffers.clear();
+ }
+
+ match cb.kind {
+ CommandBufferBuilderKind::Tiled { ref tiles, .. } => {
+ for (key, desc) in tiles {
+ let task = rg_builder.get_task(desc.current_task_id);
+ match task.kind {
+ RenderTaskKind::Picture(ref info) => {
+ let available_cmd_buffers = &mut self.available_cmd_buffers[key.sub_slice_index.as_usize()];
+ available_cmd_buffers.push((desc.dirty_rect, info.cmd_buffer_index));
+ }
+ _ => unreachable!("bug: not a picture"),
+ }
+ }
+ }
+ CommandBufferBuilderKind::Simple { render_task_id, dirty_rect, .. } => {
+ let task = rg_builder.get_task(render_task_id);
+ match task.kind {
+ RenderTaskKind::Picture(ref info) => {
+ for sub_slice_buffer in &mut self.available_cmd_buffers {
+ sub_slice_buffer.push((dirty_rect, info.cmd_buffer_index));
+ }
+ }
+ _ => unreachable!("bug: not a picture"),
+ }
+ }
+ CommandBufferBuilderKind::Invalid => {}
+ };
+ }
+
+ /// For a given rect and sub-slice, get a list of command buffers to write commands to
+ fn get_cmd_buffer_targets_for_rect(
+ &mut self,
+ rect: &PictureRect,
+ sub_slice_index: SubSliceIndex,
+ targets: &mut Vec<CommandBufferIndex>,
+ ) -> bool {
+
+ for (dirty_rect, cmd_buffer_index) in &self.available_cmd_buffers[sub_slice_index.as_usize()] {
+ if dirty_rect.intersects(rect) {
+ targets.push(*cmd_buffer_index);
+ }
+ }
+
+ !targets.is_empty()
+ }
+}
+
+// Main helper interface to build a graph of surfaces. In future patches this
+// will support building sub-graphs.
+pub struct SurfaceBuilder {
+ // The currently set cmd buffer targets (updated during push/pop)
+ current_cmd_buffers: CommandBufferTargets,
+ // Stack of surfaces that are parents to the current targets
+ builder_stack: Vec<CommandBufferBuilder>,
+ // A map of the output render tasks from any sub-graphs that haven't
+ // been consumed by BackdropRender prims yet
+ pub sub_graph_output_map: FastHashMap<PictureIndex, RenderTaskId>,
+}
+
+impl SurfaceBuilder {
+ pub fn new() -> Self {
+ SurfaceBuilder {
+ current_cmd_buffers: CommandBufferTargets::new(),
+ builder_stack: Vec::new(),
+ sub_graph_output_map: FastHashMap::default(),
+ }
+ }
+
+ /// Register the current surface as the source of a resolve for the task sub-graph that
+ /// is currently on the surface builder stack.
+ pub fn register_resolve_source(
+ &mut self,
+ ) {
+ let surface_task_id = match self.builder_stack.last().unwrap().kind {
+ CommandBufferBuilderKind::Tiled { .. } | CommandBufferBuilderKind::Invalid => {
+ panic!("bug: only supported for non-tiled surfaces");
+ }
+ CommandBufferBuilderKind::Simple { render_task_id, .. } => render_task_id,
+ };
+
+ for builder in self.builder_stack.iter_mut().rev() {
+ if builder.establishes_sub_graph {
+ assert_eq!(builder.resolve_source, None);
+ builder.resolve_source = Some(surface_task_id);
+ return;
+ }
+ }
+
+ unreachable!("bug: resolve source with no sub-graph");
+ }
+
+ pub fn push_surface(
+ &mut self,
+ surface_index: SurfaceIndex,
+ is_sub_graph: bool,
+ clipping_rect: PictureRect,
+ descriptor: SurfaceDescriptor,
+ surfaces: &mut [SurfaceInfo],
+ rg_builder: &RenderTaskGraphBuilder,
+ ) {
+ // Init the surface
+ surfaces[surface_index.0].clipping_rect = clipping_rect;
+
+ let builder = match descriptor.kind {
+ SurfaceDescriptorKind::Tiled { tiles } => {
+ CommandBufferBuilder::new_tiled(
+ tiles,
+ )
+ }
+ SurfaceDescriptorKind::Simple { render_task_id, dirty_rect, .. } => {
+ CommandBufferBuilder::new_simple(
+ render_task_id,
+ is_sub_graph,
+ None,
+ dirty_rect,
+ )
+ }
+ SurfaceDescriptorKind::Chained { render_task_id, root_task_id, dirty_rect, .. } => {
+ CommandBufferBuilder::new_simple(
+ render_task_id,
+ is_sub_graph,
+ Some(root_task_id),
+ dirty_rect,
+ )
+ }
+ };
+
+ self.current_cmd_buffers.init(&builder, rg_builder);
+ self.builder_stack.push(builder);
+ }
+
+ // Add a child render task (e.g. a render task cache item, or a clip mask) as a
+ // dependency of the current surface
+ pub fn add_child_render_task(
+ &mut self,
+ child_task_id: RenderTaskId,
+ rg_builder: &mut RenderTaskGraphBuilder,
+ ) {
+ let builder = self.builder_stack.last().unwrap();
+
+ match builder.kind {
+ CommandBufferBuilderKind::Tiled { ref tiles } => {
+ for (_, descriptor) in tiles {
+ rg_builder.add_dependency(
+ descriptor.current_task_id,
+ child_task_id,
+ );
+ }
+ }
+ CommandBufferBuilderKind::Simple { render_task_id, .. } => {
+ rg_builder.add_dependency(
+ render_task_id,
+ child_task_id,
+ );
+ }
+ CommandBufferBuilderKind::Invalid { .. } => {}
+ }
+ }
+
+ // Add a picture render task as a dependency of the parent surface. This is a
+ // special case with extra complexity as the root of the surface may change
+ // when inside a sub-graph. It's currently only needed for drop-shadow effects.
+ pub fn add_picture_render_task(
+ &mut self,
+ child_task_id: RenderTaskId,
+ ) {
+ self.builder_stack
+ .last_mut()
+ .unwrap()
+ .extra_dependencies
+ .push(child_task_id);
+ }
+
+ // Get a list of command buffer indices that primitives should be pushed
+ // to for a given current visbility / dirty state
+ pub fn get_cmd_buffer_targets_for_prim(
+ &mut self,
+ vis: &PrimitiveVisibility,
+ targets: &mut Vec<CommandBufferIndex>,
+ ) -> bool {
+ targets.clear();
+
+ match vis.state {
+ VisibilityState::Unset => {
+ panic!("bug: invalid vis state");
+ }
+ VisibilityState::Culled => {
+ false
+ }
+ VisibilityState::Visible { sub_slice_index, .. } => {
+ self.current_cmd_buffers.get_cmd_buffer_targets_for_rect(
+ &vis.clip_chain.pic_coverage_rect,
+ sub_slice_index,
+ targets,
+ )
+ }
+ VisibilityState::PassThrough => {
+ true
+ }
+ }
+ }
+
+ // Finish adding primitives and child tasks to a surface and pop it off the stack
+ pub fn pop_surface(
+ &mut self,
+ pic_index: PictureIndex,
+ rg_builder: &mut RenderTaskGraphBuilder,
+ cmd_buffers: &mut CommandBufferList,
+ ) {
+ let builder = self.builder_stack.pop().unwrap();
+
+ if builder.establishes_sub_graph {
+ // If we are popping a sub-graph off the stack the dependency setup is rather more complex...
+ match builder.kind {
+ CommandBufferBuilderKind::Tiled { .. } | CommandBufferBuilderKind::Invalid => {
+ unreachable!("bug: sub-graphs can only be simple surfaces");
+ }
+ CommandBufferBuilderKind::Simple { render_task_id: child_render_task_id, root_task_id: child_root_task_id, .. } => {
+ // Get info about the resolve operation to copy from parent surface or tiles to the picture cache task
+ if let Some(resolve_task_id) = builder.resolve_source {
+ let mut src_task_ids = Vec::new();
+
+ // Make the output of the sub-graph a dependency of the new replacement tile task
+ let _old = self.sub_graph_output_map.insert(
+ pic_index,
+ child_root_task_id.unwrap_or(child_render_task_id),
+ );
+ debug_assert!(_old.is_none());
+
+ // Set up dependencies for the sub-graph. The basic concepts below are the same, but for
+ // tiled surfaces are a little more complex as there are multiple tasks to set up.
+ // (a) Set up new task(s) on parent surface that write to the same location
+ // (b) Set up a resolve target to copy from parent surface tasks(s) to the resolve target
+ // (c) Make the old parent surface tasks input dependencies of the resolve target
+ // (d) Make the sub-graph output an input dependency of the new task(s).
+
+ match self.builder_stack.last_mut().unwrap().kind {
+ CommandBufferBuilderKind::Tiled { ref mut tiles } => {
+ let keys: Vec<TileKey> = tiles.keys().cloned().collect();
+
+ // For each tile in parent surface
+ for key in keys {
+ let descriptor = tiles.remove(&key).unwrap();
+ let parent_task_id = descriptor.current_task_id;
+ let parent_task = rg_builder.get_task_mut(parent_task_id);
+
+ match parent_task.location {
+ RenderTaskLocation::Unallocated { .. } | RenderTaskLocation::Existing { .. } => {
+ // Get info about the parent tile task location and params
+ let location = RenderTaskLocation::Existing {
+ parent_task_id,
+ size: parent_task.location.size(),
+ };
+
+ let pic_task = match parent_task.kind {
+ RenderTaskKind::Picture(ref mut pic_task) => {
+ let cmd_buffer_index = cmd_buffers.create_cmd_buffer();
+ let new_pic_task = pic_task.duplicate(cmd_buffer_index);
+
+ // Add the resolve src to copy from tile -> picture input task
+ src_task_ids.push(parent_task_id);
+
+ new_pic_task
+ }
+ _ => panic!("bug: not a picture"),
+ };
+
+ // Make the existing tile an input dependency of the resolve target
+ rg_builder.add_dependency(
+ resolve_task_id,
+ parent_task_id,
+ );
+
+ // Create the new task to replace the tile task
+ let new_task_id = rg_builder.add().init(
+ RenderTask::new(
+ location, // draw to same place
+ RenderTaskKind::Picture(pic_task),
+ ),
+ );
+
+ // Ensure that the parent task will get scheduled earlier during
+ // pass assignment since we are reusing the existing surface,
+ // even though it's not technically needed for rendering order.
+ rg_builder.add_dependency(
+ new_task_id,
+ parent_task_id,
+ );
+
+ // Update the surface builder with the now current target for future primitives
+ tiles.insert(
+ key,
+ SurfaceTileDescriptor {
+ current_task_id: new_task_id,
+ ..descriptor
+ },
+ );
+ }
+ RenderTaskLocation::Static { .. } => {
+ // Update the surface builder with the now current target for future primitives
+ tiles.insert(
+ key,
+ descriptor,
+ );
+ }
+ _ => {
+ panic!("bug: unexpected task location");
+ }
+ }
+ }
+ }
+ CommandBufferBuilderKind::Simple { render_task_id: ref mut parent_task_id, .. } => {
+ let parent_task = rg_builder.get_task_mut(*parent_task_id);
+
+ // Get info about the parent tile task location and params
+ let location = RenderTaskLocation::Existing {
+ parent_task_id: *parent_task_id,
+ size: parent_task.location.size(),
+ };
+ let pic_task = match parent_task.kind {
+ RenderTaskKind::Picture(ref mut pic_task) => {
+ let cmd_buffer_index = cmd_buffers.create_cmd_buffer();
+
+ let new_pic_task = pic_task.duplicate(cmd_buffer_index);
+
+ // Add the resolve src to copy from tile -> picture input task
+ src_task_ids.push(*parent_task_id);
+
+ new_pic_task
+ }
+ _ => panic!("bug: not a picture"),
+ };
+
+ // Make the existing surface an input dependency of the resolve target
+ rg_builder.add_dependency(
+ resolve_task_id,
+ *parent_task_id,
+ );
+
+ // Create the new task to replace the parent surface task
+ let new_task_id = rg_builder.add().init(
+ RenderTask::new(
+ location, // draw to same place
+ RenderTaskKind::Picture(pic_task),
+ ),
+ );
+
+ // Ensure that the parent task will get scheduled earlier during
+ // pass assignment since we are reusing the existing surface,
+ // even though it's not technically needed for rendering order.
+ rg_builder.add_dependency(
+ new_task_id,
+ *parent_task_id,
+ );
+
+ // Update the surface builder with the now current target for future primitives
+ *parent_task_id = new_task_id;
+ }
+ CommandBufferBuilderKind::Invalid => {
+ unreachable!();
+ }
+ }
+
+ let dest_task = rg_builder.get_task_mut(resolve_task_id);
+
+ match dest_task.kind {
+ RenderTaskKind::Picture(ref mut dest_task_info) => {
+ assert!(dest_task_info.resolve_op.is_none());
+ dest_task_info.resolve_op = Some(ResolveOp {
+ src_task_ids,
+ dest_task_id: resolve_task_id,
+ })
+ }
+ _ => {
+ unreachable!("bug: not a picture");
+ }
+ }
+ }
+
+ // This can occur if there is an edge case where the resolve target is found
+ // not visible even though the filter chain was (for example, in the case of
+ // an extreme scale causing floating point inaccuracies). Adding a dependency
+ // here is also a safety in case for some reason the backdrop render primitive
+ // doesn't pick up the dependency, ensuring that it gets scheduled and freed
+ // as early as possible.
+ match self.builder_stack.last().unwrap().kind {
+ CommandBufferBuilderKind::Tiled { ref tiles } => {
+ // For a tiled render task, add as a dependency to every tile.
+ for (_, descriptor) in tiles {
+ rg_builder.add_dependency(
+ descriptor.current_task_id,
+ child_root_task_id.unwrap_or(child_render_task_id),
+ );
+ }
+ }
+ CommandBufferBuilderKind::Simple { render_task_id: parent_task_id, .. } => {
+ rg_builder.add_dependency(
+ parent_task_id,
+ child_root_task_id.unwrap_or(child_render_task_id),
+ );
+ }
+ CommandBufferBuilderKind::Invalid => {
+ unreachable!();
+ }
+ }
+ }
+ }
+ } else {
+ match builder.kind {
+ CommandBufferBuilderKind::Tiled { ref tiles } => {
+ for (_, descriptor) in tiles {
+ if let Some(composite_task_id) = descriptor.composite_task_id {
+ rg_builder.add_dependency(
+ composite_task_id,
+ descriptor.current_task_id,
+ );
+
+ let composite_task = rg_builder.get_task_mut(composite_task_id);
+ match composite_task.kind {
+ RenderTaskKind::TileComposite(ref mut info) => {
+ info.task_id = Some(descriptor.current_task_id);
+ }
+ _ => unreachable!("bug: not a tile composite"),
+ }
+ }
+ }
+ }
+ CommandBufferBuilderKind::Simple { render_task_id: child_task_id, root_task_id: child_root_task_id, .. } => {
+ match self.builder_stack.last().unwrap().kind {
+ CommandBufferBuilderKind::Tiled { ref tiles } => {
+ // For a tiled render task, add as a dependency to every tile.
+ for (_, descriptor) in tiles {
+ rg_builder.add_dependency(
+ descriptor.current_task_id,
+ child_root_task_id.unwrap_or(child_task_id),
+ );
+ }
+ }
+ CommandBufferBuilderKind::Simple { render_task_id: parent_task_id, .. } => {
+ rg_builder.add_dependency(
+ parent_task_id,
+ child_root_task_id.unwrap_or(child_task_id),
+ );
+ }
+ CommandBufferBuilderKind::Invalid => {
+ unreachable!();
+ }
+ }
+ }
+ CommandBufferBuilderKind::Invalid => {
+ unreachable!();
+ }
+ }
+ }
+
+ // Step through the dependencies for this builder and add them to the finalized
+ // render task root(s) for this surface
+ match builder.kind {
+ CommandBufferBuilderKind::Tiled { ref tiles } => {
+ for (_, descriptor) in tiles {
+ for task_id in &builder.extra_dependencies {
+ rg_builder.add_dependency(
+ descriptor.current_task_id,
+ *task_id,
+ );
+ }
+ }
+ }
+ CommandBufferBuilderKind::Simple { render_task_id, .. } => {
+ for task_id in &builder.extra_dependencies {
+ rg_builder.add_dependency(
+ render_task_id,
+ *task_id,
+ );
+ }
+ }
+ CommandBufferBuilderKind::Invalid { .. } => {}
+ }
+
+ // Set up the cmd-buffer targets to write prims into the popped surface
+ self.current_cmd_buffers.init(
+ self.builder_stack.last().unwrap_or(&CommandBufferBuilder::empty()), rg_builder
+ );
+ }
+
+ pub fn finalize(self) {
+ assert!(self.builder_stack.is_empty());
+ }
+}