Struct re_renderer::context::RenderContext

pub struct RenderContext {

    pub device: Arc<Device>,
    pub queue: Arc<Queue>,
    pub config: RenderContextConfig,
    pub(crate) global_bindings: GlobalBindings,
    renderers: RwLock<Renderers>,
    pub(crate) resolver: RecommendedFileResolver,
    pub texture_manager_2d: TextureManager2D,
    pub(crate) cpu_write_gpu_read_belt: Mutex<CpuWriteGpuReadBelt>,
    pub gpu_readback_belt: Mutex<GpuReadbackBelt>,
    inflight_queue_submissions: Vec<SubmissionIndex>,
    pub active_frame: ActiveFrameContext,
    frame_index_for_uncaptured_errors: Arc<AtomicU64>,
    top_level_error_tracker: Arc<ErrorTracker>,
    pub gpu_resources: WgpuResourcePools,
}

Any resource involving wgpu rendering which can be re-used across different scenes. I.e. render pipelines, resource pools, etc.

Fields

device: Arc<Device>

queue: Arc<Queue>

config: RenderContextConfig

global_bindings: GlobalBindings

Global bindings, always bound to 0 bind group slot zero. Renderer are not allowed to use bind group 0 themselves!

renderers: RwLock<Renderers>

resolver: RecommendedFileResolver

texture_manager_2d: TextureManager2D

cpu_write_gpu_read_belt: Mutex<CpuWriteGpuReadBelt>

gpu_readback_belt: Mutex<GpuReadbackBelt>

inflight_queue_submissions: Vec<SubmissionIndex>

List of unfinished queue submission via this context.

This is currently only about submissions we do via the global encoder in ActiveFrameContext TODO(andreas): We rely on egui for the “primary” submissions in re_viewer. It would be nice to take full control over all submissions.

active_frame: ActiveFrameContext

frame_index_for_uncaptured_errors: Arc<AtomicU64>

Frame index used for [wgpu::Device::on_uncaptured_error] callbacks.

Today, when using wgpu-core (== native & webgl) this is equal to the current ActiveFrameContext::frame_index since the content timeline is in sync with the device timeline, meaning everything done on [wgpu::Device] happens right away. On WebGPU however, the content timeline may be arbitrarily behind the device timeline! See https://www.w3.org/TR/webgpu/#programming-model-timelines.

top_level_error_tracker: Arc<ErrorTracker>

Error tracker used for top_level_error_scope and [wgpu::Device::on_uncaptured_error].

gpu_resources: WgpuResourcePools

Implementations

impl RenderContext

const CPU_WRITE_GPU_READ_BELT_DEFAULT_CHUNK_SIZE: Option<BufferSize> = _

Chunk size for our cpu->gpu buffer manager.

32MiB chunk size (as big as a for instance a 2048x1024 float4 texture) (it’s tempting to use something smaller on Web, but this may just cause more buffers to be allocated the moment we want to upload a bigger chunk)

const GPU_READBACK_BELT_DEFAULT_CHUNK_SIZE: Option<BufferSize> = _

Chunk size for our gpu->cpu buffer manager.

We expect large screenshots to be rare occurrences, so we go with fairly small chunks of just 64 kiB. (this is as much memory as a 128x128 rgba8 texture, or a little bit less than a 64x64 picking target with depth) I.e. screenshots will end up in dedicated chunks.

const MAX_NUM_INFLIGHT_QUEUE_SUBMISSIONS: usize = 4usize

Limit maximum number of in flight submissions to this number.

By limiting the number of submissions we have on the queue we ensure that GPU stalls do not cause us to request more and more memory to prepare more and more submissions.

Note that this is only indirectly related to number of buffered frames, since buffered frames/blit strategy are all about the display<->gpu interface, whereas this is about a particular aspect of the cpu<->gpu interface.

Should be somewhere between 1-4, too high and we use up more memory and introduce latency, too low and we may starve the GPU.

pub fn new( adapter: &Adapter, device: Arc<Device>, queue: Arc<Queue>, config: RenderContextConfig ) -> Result<Self, RenderContextError>

fn poll_device(&mut self)

pub fn begin_frame(&mut self)

Call this at the beginning of a new frame.

Updates internal book-keeping, frame allocators and executes delayed events like shader reloading.

pub fn before_submit(&mut self)

Call this at the end of a frame but before submitting command buffers (e.g. from crate::view_builder::ViewBuilder)

pub fn renderer<R: 'static + Renderer + Send + Sync>( &self ) -> MappedRwLockReadGuard<'_, R>

Gets a renderer with the specified type, initializing it if necessary.

pub(crate) fn read_lock_renderers(&self) -> RwLockReadGuard<'_, Renderers>

Read access to renderers.

pub fn active_frame_idx(&self) -> u64

Returns the global frame index of the active frame.

pub fn device_caps(&self) -> &DeviceCaps

Returns the device’s capabilities.