Struct GraphicsConfig 

pub struct GraphicsConfig {
    pub max_frames: Option<u64>,
    pub frames_in_flight: u32,
    pub vsync: bool,
    pub fps_cap: u32,
    pub clear_color: [f32; 4],
    pub shadow_map_size: u32,
    pub shadow_update: ShadowUpdate,
    pub shadow_distance: u32,
    pub shadow_cascades: u32,
    pub anisotropy: u32,
}

Rendering settings for the world: frame pacing, shadows, and clear colour. One per world. The GPU backend is chosen by the engine for the platform and is not user-configurable.

The shadow and anisotropy defaults describe the quality capable hardware runs, not what every GPU runs: the Auto graphics quality preset resolves the detected GPU into a ceiling that caps them tier by tier. Frame pacing (vsync, fps_cap, frames_in_flight) is a user preference rather than a quality tier, so no preset touches it.

{
  "name": "gfx",
  "type": "GraphicsConfig",
  "args": { "clear_color": [0.1, 0.1, 0.15, 1.0], "frames_in_flight": 2 }
}

Fields

max_frames: Option<u64>

Cap the render loop at this many frames, then exit. Unset runs until the window is closed.

frames_in_flight: u32

Preferred number of frames in flight (1-3). Higher can smooth pacing at the cost of input latency.

vsync: bool

Cap the frame rate to the display refresh (vsync). Defaults to false: the render loop runs uncapped (DirectX presents with tearing allowed, Vulkan uses a mailbox present mode), which is what a benchmark wants. Set to true to lock presentation to the monitor refresh, eliminating tearing and the wasted frames that never reach the screen.

fps_cap: u32

Cap the frame rate to this many frames per second. 0 (default) leaves the loop uncapped. The cap is a CPU-side frame pacer, so it composes with vsync: the more restrictive of the two wins. Useful for limiting heat, fan noise, and power draw, or matching a fixed refresh.

clear_color: [f32; 4]

Background clear colour [r, g, b, a] in linear 0..1 space.

shadow_map_size: u32

Shadow map resolution in texels. 4096 by default, capped by the quality preset down to 1024 on the lowest tier. Set to 0 to disable shadows.

shadow_update: ShadowUpdate

How often shadow cascades are re-rendered. every_frame (default) refreshes them all every frame; hybrid amortizes the far cascades across frames. Only the top quality tier permits every_frame, so everything below it runs hybrid.

shadow_distance: u32

How far from the camera shadows are cast, in world units (e.g. 80). The cascades cover from the near plane out to this distance; a larger value shadows more of the scene but spreads the same shadow-map resolution over more area (softer, blockier shadows). Capped at the camera far plane.

shadow_cascades: u32

Number of shadow cascades, 1 to 4 (4 is the default and the maximum). More cascades keep distant shadows sharper by splitting the view range into finer slices, at the cost of an extra shadow-map render per cascade; fewer is cheaper but blockier far from the camera. The slice count covers the same shadow_distance regardless.

anisotropy: u32

Maximum anisotropic-filtering degree for the scene texture sampler (albedo + normal maps), e.g. 8. Higher keeps textures viewed at a grazing angle (floors, walls receding into the distance) sharp instead of blurring along the minor axis, at a small sampling cost. 1 disables anisotropy (plain trilinear). 16 by default, capped by the quality preset down to 4 on the lowest tier. Clamped to the GPU’s supported range (1..16) at init.

Trait Implementations

impl Clone for GraphicsConfig

fn clone(&self) -> GraphicsConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for GraphicsConfig

const NAME: &'static str = "GraphicsConfig"

The registry name a world authors this component under.

fn from_baked(bytes: &[u8]) -> Result<Self, CnResult>

Reconstruct this component from a blob record, whose bytes are the serialized runtime component (cook already ran the asset -> component translation). The default rejects: runtime-only components are never stored in a blob, so only loadable types provide an implementation.

fn inject_locator(&mut self, _locator: PayloadLocator)

Called after construction to inject the payload locator from the blob def. Only meaningful for components with a compiled payload. The default implementation does nothing (correct for most components).

fn inject_name(&mut self, _id: AssetId)

Called after construction to inject the asset’s identity from the blob def. Only meaningful for components that look themselves up by id at runtime. The default implementation does nothing.

impl ComponentSlot for GraphicsConfig

const DISCRIMINANT: u8

The component type’s stable id, used as its ComponentId.

fn slot(s: &ComponentStorage) -> &Column<Self>

Borrow this type’s column out of the storage.

fn slot_mut(s: &mut ComponentStorage) -> &mut Column<Self>

Mutably borrow this type’s column out of the storage.

impl Debug for GraphicsConfig

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

Formats the value using the given formatter.

impl Default for GraphicsConfig

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for GraphicsConfig

where GraphicsConfig: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<GraphicsConfig> for ComponentAsset

fn from(c: GraphicsConfig) -> Self

Converts to this type from the input type.

impl RuntimeComponent for GraphicsConfig

impl Serialize for GraphicsConfig

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

where __S: Serializer,

Serialize this value into the given Serde serializer.