Struct webrender::render_target::RenderTargetList

pub struct RenderTargetList<T> {
    pub format: ImageFormat,
    pub targets: Vec<T>,
}

A series of RenderTarget instances, serving as the high-level container into which RenderTasks are assigned.

During the build phase, we iterate over the tasks in each RenderPass. For each task, we invoke allocate() on the RenderTargetList, which in turn attempts to allocate an output region in the last RenderTarget in the list. If allocation fails (or if the list is empty), a new RenderTarget is created and appended to the list. The build phase then assign the task into the target associated with the final allocation.

The result is that each RenderPass is associated with one or two RenderTargetLists, depending on whether we have all our tasks have the same RenderTargetKind. The lists are then shipped to the Renderer, which allocates a device texture array, with one slice per render target in the list.

The upshot of this scheme is that it maximizes batching. In a given pass, we need to do a separate batch for each individual render target. But with the texture array, we can expose the entirety of the previous pass to each task in the current pass in a single batch, which generally allows each task to be drawn in a single batch regardless of how many results from the previous pass it depends on.

Note that in some cases (like drop-shadows), we can depend on the output of a pass earlier than the immediately-preceding pass.

Fields

format: ImageFormat

targets: Vec<T>

Implementations

impl<T: RenderTarget> RenderTargetList<T>

pub fn new(format: ImageFormat) -> Self

pub fn build( &mut self, ctx: &mut RenderTargetContext<'_, '_>, gpu_cache: &mut GpuCache, render_tasks: &RenderTaskGraph, prim_headers: &mut PrimitiveHeaders, transforms: &mut TransformPalette, z_generator: &mut ZBufferIdGenerator, prim_instances: &[PrimitiveInstance], cmd_buffers: &CommandBufferList, gpu_buffer_builder: &mut GpuBufferBuilder )

pub fn needs_depth(&self) -> bool

Trait Implementations

impl<T> Serialize for RenderTargetList<T>where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.