Struct PerformancePolicy 

pub struct PerformancePolicy {
    pub preset: Option<QualityPreset>,
    pub target_fps: Option<f32>,
    pub min_render_scale: f32,
    pub max_render_scale: f32,
    pub allow_dynamic_resolution: bool,
    pub allow_shadow_reduction: bool,
    pub allow_volume_quality_reduction: bool,
    pub allow_effect_throttling: bool,
}

Controls what quality reductions the viewport is allowed to apply under load.

Set once via crate::ViewportRenderer::set_performance_policy. The internal adaptation controller reads target_fps and adjusts render scale within [min_render_scale, max_render_scale] when allow_dynamic_resolution is true.

Pass-specific flags (allow_shadow_reduction, allow_volume_quality_reduction, allow_effect_throttling) gate concrete quality reductions that kick in when the previous frame missed the target budget, applied in order via a tiered degradation ladder (render scale first, then shadows, then volumes, then effects).

Set preset to a QualityPreset to configure bounds and flags as a unit.

Fields

preset: Option<QualityPreset>

Coarse quality tier. When Some, overrides min_render_scale, max_render_scale, and all allow_* flags for the duration of the frame. Set to None to use the individual fields directly.

target_fps: Option<f32>

Target frames per second. None means uncapped; missed_budget is always false.

min_render_scale: f32

Lower bound for dynamic render scale (e.g. 0.5 = half resolution).

Ignored when preset is Some; the preset’s bounds are used instead.

max_render_scale: f32

Upper bound for dynamic render scale (1.0 = native).

Ignored when preset is Some; the preset’s bounds are used instead.

allow_dynamic_resolution: bool

Allow the viewport to adjust render scale automatically when budget is exceeded.

When false, the internal controller is inactive and render scale can be set manually via crate::ViewportRenderer::set_render_scale.

The controller uses FrameStats::gpu_frame_ms as the cost signal when GPU timestamp queries are available (excludes vsync wait). When GPU timestamps are unavailable it falls back to total_frame_ms, which reflects wall-clock frame duration and correctly fires over-budget at low frame rates.

LDR path only. Dynamic resolution applies when the scene is rendered via crate::ViewportRenderer::paint_to or crate::ViewportRenderer::paint_viewport (i.e. PostProcessSettings::enabled is false). When the HDR post-processing path is active (render / render_viewport), render scale has no effect on output quality and the adaptation controller is suppressed. FrameStats::render_scale will report 1.0 in that case.

allow_shadow_reduction: bool

Allow the viewport to skip the shadow pass under load.

When true and the previous frame exceeded the target budget, the shadow depth pass is skipped entirely. Shadows reappear as soon as the frame is within budget. Ignored when preset is Some.

allow_volume_quality_reduction: bool

Allow the viewport to reduce volume raymarch quality under load.

When true and the previous frame exceeded the target budget, the per-volume step size is doubled (half the number of samples), reducing GPU cost at the cost of coarser volume appearance. Ignored when preset is Some.

allow_effect_throttling: bool

Allow the viewport to skip non-essential HDR effect passes under load.

When true and the previous frame exceeded the target budget, the SSAO, contact shadow, and bloom passes are skipped for that frame. Ignored when preset is Some.

Trait Implementations

impl Clone for PerformancePolicy

fn clone(&self) -> PerformancePolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PerformancePolicy

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

Formats the value using the given formatter.

impl Default for PerformancePolicy

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PerformancePolicy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PerformancePolicy

fn eq(&self, other: &PerformancePolicy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PerformancePolicy

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for PerformancePolicy

impl StructuralPartialEq for PerformancePolicy