Enum RenderError 

#[non_exhaustive]
pub enum RenderError {
    Gpu(GpuError),
    Acceleration(BvhBuildError),
    Entity(EntityIdError),
    Picking(PickingError),
    Dataset(DatasetError),
    PickingOwnerMissing,
    PickingPageMissing {
        dataset: DatasetId,
        kind: EntityKind,
    },
    RelationSourceMissing {
        domain: RowDomain,
    },
    Packing(PackingError),
    GraphCycle {
        pass: &'static str,
    },
    UnknownResource {
        pass: &'static str,
        resource: u32,
    },
    InvalidImageSize,
    SourceCapabilityMissing {
        capability: &'static str,
    },
    InvalidSequence {
        reason: &'static str,
    },
    SequenceBackpressure {
        max_in_flight: u8,
    },
    InvalidFocusTarget {
        reason: &'static str,
    },
    ImageEncoding {
        summary: String,
    },
    SessionEncoding {
        summary: String,
    },
    Residency {
        reason: &'static str,
    },
    ChunkResidency(ChunkResidencyError),
    BrickAtlas(BrickAtlasError),
    AssetIdentityCollision {
        dataset: DatasetId,
        resident_fingerprint: u64,
        incoming_fingerprint: u64,
    },
    SurfaceComponents {
        reason: &'static str,
    },
    AssetArena(AssetArenaError),
}

Everything that can go wrong constructing or driving the engine.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Gpu(GpuError)

A device-level failure, carried upward with its own code.

Acceleration(BvhBuildError)

A CPU-built hierarchy exceeded the compact GPU index layout.

Entity(EntityIdError)

A logical entity row cannot be encoded in a chunk-local GPU identity.

Picking(PickingError)

A bounded global picking page transition or readback was invalid.

Dataset(DatasetError)

A chunk span used by a resident pick page was invalid.

PickingOwnerMissing

A visible scene entity references a structure that is no longer resident.

PickingPageMissing

A GPU record requested a namespace absent from the bounded page table.

Fields

dataset: DatasetId

Dataset whose page was required.

kind: EntityKind

Entity namespace whose page was required.

RelationSourceMissing

A validated dynamic relation source is not resident in the GPU scene.

Fields

domain: RowDomain

Spatial table required by the relation stream.

Packing(PackingError)

CPU lowering exceeded a compact GPU record field.

GraphCycle

The render graph contains a dependency cycle.

Fields

pass: &'static str

A pass on the cycle.

UnknownResource

A pass referenced a resource id the graph never declared.

Fields

pass: &'static str

The offending pass.

resource: u32

The undeclared id.

InvalidImageSize

Off-screen dimensions overflowed a portable texture/readback layout.

SourceCapabilityMissing

A physical representation requires source annotations not exposed by its provider.

Fields

capability: &'static str

Required provider capability.

InvalidSequence

Sequence timestamps or buffering parameters violate the deterministic contract.

Fields

reason: &'static str

Stable caller-actionable reason.

SequenceBackpressure

The caller must drain a completed sequence frame before submitting more work.

Fields

max_in_flight: u8

Configured bounded readback depth.

InvalidFocusTarget

A scene-tracked optical target is stale, empty, or behind the camera.

Fields

reason: &'static str

Stable, caller-actionable reason.

ImageEncoding

The mapped image could not be encoded for publication.

Fields

summary: String

Encoder-provided diagnostic.

SessionEncoding

A render session could not be encoded or decoded.

Fields

summary: String

Serializer-provided diagnostic.

Residency

Fixed residency capacity or lifecycle state rejected frame work.

Fields

reason: &'static str

Stable failure category without backend-specific text allocation.

ChunkResidency(ChunkResidencyError)

Provider chunk residency failed with a typed lifecycle or capacity error.

BrickAtlas(BrickAtlasError)

Sparse volume atlas validation, capacity or lifecycle failure.

AssetIdentityCollision

One caller-owned dataset id was reused for different immutable data.

Fields

dataset: DatasetId

Caller-owned dataset identity that collided.

resident_fingerprint: u64

Fingerprint already resident for the dataset.

incoming_fingerprint: u64

Fingerprint supplied by the incoming placement.

SurfaceComponents

Sampled-surface component lowering exceeded its bounded working set.

Fields

reason: &'static str

Stable validation or capacity reason.

AssetArena(AssetArenaError)

Immutable GPU storage could not allocate or relocate safely.

Implementations

impl RenderError

pub fn code(&self) -> &'static str

The stable registry code for this condition.

Trait Implementations

impl Debug for RenderError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for RenderError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for RenderError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<BrickAtlasError> for RenderError

fn from(source: BrickAtlasError) -> Self

Converts to this type from the input type.

impl From<BvhBuildError> for RenderError

fn from(source: BvhBuildError) -> Self

Converts to this type from the input type.

impl From<ChunkResidencyError> for RenderError

fn from(source: ChunkResidencyError) -> Self

Converts to this type from the input type.

impl From<DatasetError> for RenderError

fn from(source: DatasetError) -> Self

Converts to this type from the input type.

impl From<EntityIdError> for RenderError

fn from(source: EntityIdError) -> Self

Converts to this type from the input type.

impl From<GpuError> for RenderError

fn from(source: GpuError) -> Self

Converts to this type from the input type.

impl From<PackingError> for RenderError

fn from(source: PackingError) -> Self

Converts to this type from the input type.

impl From<PickingError> for RenderError

fn from(source: PickingError) -> Self

Converts to this type from the input type.