Console variables

All 906 console variables the engine and editor register, with type, default and help text.

Last updated Nov 5, 2026Version 1.0.0

Every console variable registered in the engine, the editor and the first-party plugins: 906 in total, grouped by prefix. Set one from the console (r.VSM 1), the command line (-r.VSM=1) or the [ConsoleVariables] section of a config file.

Flags: Cheat variables are refused from the console and the command line when cheats are off (the Shipping default). ReadOnly variables are set by code and config only.

a

NameTypeDefaultDescription
a.BudgetMaxDeferFramesint8Frames in a row the budget may defer one animator before it must evaluate Game
a.BudgetMsfloat0.0fEvaluation budget in ms per frame; the lowest-priority animators are deferred with their dt banked. 0 = no budget (UE AnimationBudgetAllocator) Game
a.EvalDuringPhysicsint1Evaluate the animators nothing reads before the physics step (no root motion consumed by movement, no morph channels) beside that step, when the scene overlaps it (p.OverlapDuringPhysics); foot IK raycasts run after the step against the stepped world. 0 = every animator evaluates ahead of the step Game
a.LODint-1Animator update-rate LOD around the focus: -1=on while a focus is set, 0=off, 1=on Game
a.LODBoneMaskint1Apply the skeleton's per-LOD required-bone sets (Skeleton::SetLodBonesToRemove); 0 animates every bone at every LOD Game
a.LODFarIntervalint16Frame interval beyond the far radius Game
a.LODFarRadiusfloat120.0fAnimators beyond this sample every a.LODFarInterval frames Game
a.LODNearIntervalint4Frame interval between the near and far radius Game
a.LODNearRadiusfloat30.0fFull-rate radius; animators beyond it sample every a.LODNearInterval frames Game
a.OffscreenIntervalint0Frame interval for an animator the scene has not drawn inside the camera frustum for two updates; 0 = visibility does not throttle (UE VisibilityBasedAnimTickOption) Game

ai

NameTypeDefaultDescription
ai.AutoBodyFoundint1Raise a dormant BodyFound situation when a crowd member or perceivable entity dies AINavigation
ai.Crowdint1Crowd system: 0=off, 1=on (tier assignment, particle flow, bulk brains, spawners) AINavigation
ai.Crowd.Debugint0Log crowd tier counts and pass timings every 60 frames AINavigation
ai.Crowd.FleeDistancefloat12.0fHow far a broadcast reaction pushes members away from the epicenter AINavigation
ai.Crowd.FleeDurationfloat6.0fSeconds a member stays panicked after a broadcast reaction AINavigation
ai.Crowd.FleeSpeedScalefloat2.0fWalk-speed multiplier while a member is panicked AINavigation
ai.Crowd.MaxBulkint128Hard cap of bulk-tier crowd members (shared state machine + dtCrowd nav, no perception) AINavigation
ai.Crowd.MaxFullint24Hard cap of full-tier crowd members (real AI: perception + behavior tree + dtCrowd nav) AINavigation
ai.Crowd.SeparationRadiusfloat0.9fParticle-tier neighbor separation radius in meters AINavigation
ai.Crowd.SeparationWeightfloat1.5fParticle-tier separation steering weight AINavigation
ai.Crowd.SpawnPerFrameint64Crowd members instantiated per spawner per frame (streaming-friendly ramp-up) AINavigation
ai.Crowd.TierDwellfloat1.0fSeconds a member must stay in its tier before it can be promoted (hysteresis; demotions to respect caps are immediate) AINavigation
ai.Crowd.TierStickinessfloat0.05fScore bonus incumbents get when ranked against challengers at a tier boundary; a challenger must beat an incumbent by this margin to swap tiers AINavigation
ai.FootstepNoiseint1Footsteps report AI perception noise events, scaled louder when sprinting and quieter when crouching (0 = off) Game
ai.NoiseMapint1Spread every sound and scan the AI hears over a decaying noise map the director reads; 0 = no map AINavigation
ai.NoiseMap.CellSizefloat4.0fEdge of one noise map cell, in metres AINavigation
ai.NoiseMap.HalfLifefloat6.0fSeconds for the noise map to fall to half AINavigation
ai.NoiseMap.Reachfloat24.0fHow far one unit of loudness spreads over the noise map before walls and doors take their share, in metres AINavigation
ai.PerceptionMaxRaysPerFrameint64Maximum sight line-of-sight raycasts per frame across all AI perceivers; nearest candidates win, the rest coast on their last visibility AINavigation
ai.ScanFlashReachfloat30.0fHow far a LiDAR scan's flash is seen by AI facing it with a clear line of sight, in metres; 0 = scans are invisible to AI AINavigation
ai.ScanPulseReachfloat20.0fHow far in metres a scan pulse carries to AI hearing before walls and portals take their share; 0 = scans are silent to AI Game
ai.Scheduleint1NPC schedule system: 0=off, 1=on (time-of-day acts, smart-point claiming, activity movement) AINavigation
ai.Schedule.ArriveRadiusfloat0.7fDistance in meters at which a scheduled agent counts as arrived at its activity point AINavigation
ai.Schedule.Debugint0Log schedule act changes and point claims AINavigation
ai.Schedule.HourOverridefloat-1.0fForces the schedule hour to this value when >= 0 (debug/ToD scrubbing); -1 reads the scene's DayNight component AINavigation
ai.Schedule.LoopDwellfloat4.0fSeconds a GoToAndLoop agent dwells at a point before re-picking another point of the same tag AINavigation
ai.Schedule.WanderRadiusfloat8.0fWander-behavior disc radius for agents without a crowd home area AINavigation
ai.Significanceint1AI significance manager: 0=off, 1=on; consumers fall back to their distance heuristics when off Game
ai.SignificanceAudioint1Feed significance into audio voice priority (scales priority 0.5x-1x by score) Game
ai.SignificanceBTLowIntervalfloat0.6fMinimum behavior-tree tick interval for low-significance agents Game
ai.SignificanceBTMidIntervalfloat0.2fMinimum behavior-tree tick interval for mid-significance agents Game
ai.SignificanceBudgetint128Entities re-scored per frame, round-robin; the rest keep their last score Game
ai.SignificanceHighThresholdfloat0.66fScores at or above this are high significance (full consumer rates) Game
ai.SignificanceLowThresholdfloat0.33fScores below this are low significance (coarsest consumer rates) Game
ai.SignificancePerceptionIntervalint4Low-significance perceivers run AI perception every Nth frame Game
ai.Situationint1Situation system: 0=off, 1=on (raise/decay, witness knowledge, propagation, trespass volumes) AINavigation
ai.Situation.BodyFoundRadiusfloat15.0fReaction radius of an auto-raised BodyFound situation AINavigation
ai.Situation.ConversationRangefloat4.0fDistance in meters within which two full AI agents can exchange situation knowledge AINavigation
ai.Situation.ConversationTimefloat1.5fSeconds two agents must stay within earshot (conversation range scaled by the walls and portals between them) before situation knowledge propagates AINavigation
ai.Situation.Debugint0Log situation raises, discoveries, propagation and decay AINavigation
ai.Situation.DormantChecksPerFrameint8Dormant-situation sight tests per frame (BodyFound discovery), round-robin over perceivers AINavigation
ai.Situation.ExplosionLifetimefloat45.0fSeconds before an Explosion situation decays AINavigation
ai.Situation.GunshotLifetimefloat30.0fSeconds before a Gunshot situation decays AINavigation
ai.Situation.PropagationAgentsPerFrameint8Agents whose conversation pairs are checked per frame (round-robin stagger, never N^2) AINavigation
ai.Situation.Raisestringstd::string()Debug raise consumed on the next situation tick: 'Type x y z radius severity' (e.g. 'Gunshot 0 0 0 25 1') AINavigation
ai.Situation.SuspiciousLifetimefloat20.0fSeconds before a Suspicious (or Custom) situation decays AINavigation
ai.Situation.TrespassLifetimefloat30.0fSeconds before a Trespass situation decays AINavigation
ai.Situation.VandalismLifetimefloat60.0fSeconds before a Vandalism situation decays AINavigation

arc

NameTypeDefaultDescription
arc.DeferredPopupReleasebooltrueFree a closed menu's popup window once the GPU has retired its frames instead of tearing its swapchain down on the spot, which waits for the whole device several times per close. 0 = the old immediate teardown (for measuring it). Read once at Arc startup. Arc
arc.Densityint1UI density: 0 = Compact, 1 = Default, 2 = Comfortable (Preferences > Appearance > Density). Applies live: every measure is dropped and the UI re-lays out. Arc
arc.OSPopupsbooltrueHost menus and tooltips in their own topmost OS windows (overhang the owning window like native apps). 0 = legacy in-window overlays. Read once at Arc startup. Arc
arc.PopupsInWindowbooltruePaint a menu or tooltip that fits inside its owning window there, and give an OS window only to one that must overhang it. 0 = every menu and tooltip in its own OS window. Read once at Arc startup. Arc
arc.RetainedPaintbooltrueReplay retained draw slices for opted-in widget subtrees on clean frames. 0 = paint every widget every frame, the ground truth a suspected stale-pixel bug is compared against. Arc
arc.ShapingbooltrueHarfBuzz text shaping for Arc UI text (GPOS kerning, ligatures, mark placement). 0 = legacy FreeType kern-table path. Arc
arc.SkipUnchangedWindowsint1Skip a window's layout, paint and buffer upload on frames where nothing in it changed (every window still records over its scene and presents). 2 = an owned window that samples nothing live also skips its record and present. 0 = paint every window every frame. Arc
arc.SkipUnchangedWindows.LogFramesint0Every this many frames, log the main window's average produce time (layout, paint, snapshot) and how many window paints and presents the skip saved over them. 0 = off. Arc
arc.SkipUnchangedWindows.VerifyFramesint8A window that skips its paint paints anyway after this many skipped frames and compares the result with the frame it was replaying; a difference makes it paint every frame for a while. Arc
arc.TextContrastfloatCArcTextContrast::DEFAULT_CONTRASTContrast added to text coverage before the gamma blend (0 to 1), strongest for dark text. Arc
arc.TextFloatingContrastfloatCArcTextContrast::DEFAULT_FLOATING_CONTRASTarc.TextContrast for text inside a floating surface (0 to 1). Arc
arc.TextFloatingGammafloatCArcTextContrast::DEFAULT_FLOATING_GAMMAarc.TextGamma for text inside a floating surface (a popover, a confirm), which the design's browser draws on its own layer with less of the lift. Arc
arc.TextGammafloatCArcTextContrast::DEFAULT_GAMMAGamma text coverage is blended in, as a browser blends it (1 = the target's sRGB-encoded space, up to 3). Light text on a dark ground gains weight, dark text on a light ground loses some. Arc
arc.TextStemDarkeningfloatCArcFontManager::TEXT_STEM_DARKEN_EMStem darkening of the design faces below 14 device px, as a fraction of the em. Read once when the fonts load. Arc
arc.ThemeRemapbooltrueAfter a live theme switch, repaint colours that widgets copied from the previous theme's tokens in the new theme's values. 0 = only widgets built after the switch take the new theme. Arc
arc.UIScalefloat-1.0fOverride the DPI-derived UI scale (1.0 = 96 DPI, 2.0 = 192 DPI). Negative keeps the auto-detected value. Read once at Arc startup. Arc

asset

NameTypeDefaultDescription
asset.MemoryBudgetMBint0Resident asset budget in MB the LRU eviction keeps under; 0 = the manager's own (4 GB). The runtime and the editor claim it from the device's VRAM at startup unless config or the command line set it AssetSystem
asset.UploadMBPerFrameint32Max megabytes of whole-asset GPU uploads (CreateGPU) an AssetManager drains per frame, on top of asset.UploadsPerFrame; the first upload of a frame always lands; <= 0 = unbounded AssetSystem
asset.UploadsPerFrameint8Max GPU asset uploads (CreateGPU) an AssetManager drains per frame; <= 0 = unbounded AssetSystem

au

NameTypeDefaultDescription
au.Debug.AttenuationboolfalseDraw every playing spatial voice's min and max distance in the viewport (Audio debug-draw category) Audio

audio

NameTypeDefaultDescription
audio.Acousticsint1Geometric acoustics: occlusion through the scan hierarchy, reverb and early reflections traced from the level, echolocation; 0 = the physics material trace and the scanner's echo tail only Audio
audio.Acoustics.EchoClipstring""Clip each returning echo plays from where it bounced; empty = echoes are computed but not voiced Audio
audio.Acoustics.EchoConeDegreesfloat70.0fFull cone angle of an echolocation click, in degrees Audio
audio.Acoustics.EchoNoisefloat0.6fLoudness the AI hears an echolocation click at; 0 = clicks are silent to AI Audio
audio.Acoustics.EchoRangefloat40.0fHow far an echolocation click reaches, in metres Audio
audio.Acoustics.EchoRaysint128Rays one echolocation click sends out Audio
audio.Acoustics.Geometryint0What sound is traced against: 0 = the scan hierarchy when its plugin is loaded, else physics; 1 = scan hierarchy only; 2 = physics only Audio
audio.Acoustics.MaxDistancefloat80.0fLongest leg any acoustic ray follows, in metres Audio
audio.Acoustics.MaxReflectionsint16Early reflections kept per update, earliest first Audio
audio.Acoustics.ReflectionOrderint2Highest early-reflection order (surfaces per path, 1-3) Audio
audio.Acoustics.ReverbBouncesint4Bounces each reverb ray follows before it is retired Audio
audio.Acoustics.ReverbRaysint256Rays traced from the listener to measure the room's decay Audio
audio.Acoustics.UpdateHzfloat4.0fHow often per second the listener's reverb and early reflections are re-traced Audio
audio.AutoSubtitlesint0Subtitle speech nobody captioned — proximity voice and audio games push in — with the on-device speech recognizer; nothing leaves the machine Accessibility
audio.AutoSubtitles.Availableint0Project option read by mbt package: ship the speech recognizer (ONNX Runtime, this module, the 95 MB model) so players can turn auto-subtitles on Accessibility
audio.AutoSubtitles.MinConfidencefloat0.55fLines the recognizer is less sure of than this are not shown, 0..1 Accessibility
audio.AutoSubtitles.PauseSecondsfloat0.45fA pause this long ends a line Accessibility
audio.AutoSubtitles.Voiceint1Auto-subtitle what other players say over proximity voice and radio Accessibility
audio.ClosedCaptionsint0Also show non-speech sound descriptions such as [door creaks] Narrative
audio.DopplerMaxSpeedfloat100.0fTransform-derived speeds above this (m/s) are treated as teleports and contribute no doppler Audio
audio.DopplerScalefloat1.0fGlobal doppler intensity multiplier applied on top of each source's dopplerScale; 0 disables doppler entirely Audio
audio.EchoTailSubmixstring""Submix that carries the convolution reverb built from scan hits (FEchoTail); empty = no echo reverb Audio
audio.OcclusionRaycastBudgetint32Maximum source-to-listener occlusion raycasts per frame; nearest sources win Audio
audio.Spatializerstring"Native"Spatializer for 3D voices: Native (miniaudio), Panner (equal-power reference), or a plugin's registered name Audio
audio.SubtitleBackgroundOpacityfloat0.6fOpacity of the plate drawn behind subtitle text, 0 to 1 Narrative
audio.SubtitleMaxLinesint3Maximum subtitle lines shown at once Narrative
audio.Subtitlesint1Show subtitles for spoken dialogue and captioned voice cues Narrative
audio.SubtitleScalefloat1.0fSubtitle text size multiplier Narrative
audio.SubtitleSpeakerNamesint1Prefix each subtitle line with the speaker's name Narrative

cam

NameTypeDefaultDescription
cam.FOVint0Accessibility: the player's vertical field of view in degrees for the gameplay camera, 0 = each camera's authored value; a sequencer cut camera always keeps its own Camera
cam.ShakeScalefloat1.0fAccessibility: multiplier on every camera shake, trauma-driven and modifier-driven alike, 0 = still camera, 1 = as authored Camera

carry

NameTypeDefaultDescription
carry.BreakDistancefloat1.75fConstraint stretch (m) between hold point and carried object beyond which the carry breaks and the object drops Plugins.Combat
carry.MotorDampingfloat1.0fSpring damping of the carry hold motor Plugins.Combat
carry.MotorFrequencyfloat8.0fSpring frequency (Hz) of the carry hold motor that drags a carried object toward the hold point Plugins.Combat
carry.MotorMaxForcefloat900.0fPer-axis force limit (N) of the carry hold motor; heavy objects lag behind the hold point instead of snapping Plugins.Combat
carry.PerCarrierMaxForcefloat350.0fHold-motor force limit (N) of ONE carrier on a Heavy object. About what a person can lift one-handed-and-a-half: one carrier drags an 80 kg crate, two lift it. Plugins.Combat
carry.PlaceSnapMaxAngleDegfloat45.0fMaximum surface slope (degrees from up) a place-snap drop aligns to; steeper surfaces leave the dropped pose untouched Plugins.Combat
carry.PlaceSnapRayDistfloat2.5fDownward raycast distance (m) used by place-snap to find the surface under a dropped object Plugins.Combat

dd

NameTypeDefaultDescription
dd.AudiobooltrueDebug-draw layer: audio source ranges DebugDraw
dd.BoundsboolfalseDebug-draw layer: selected-entity world-space AABBs DebugDraw
dd.CoverboolfalseDebug-draw layer: AI cover points (markers, protection arcs, occupancy) DebugDraw
dd.DirectorboolfalseDebug-draw layer: AI director (spawn rings around players, tracked threat markers, pacing overlay line) DebugDraw
dd.NavigationboolfalseDebug-draw layer: navigation mesh overlay DebugDraw
dd.PerceptionboolfalseDebug-draw layer: AI perception (sight cones, LOS rays, hearing radii, last-known-position markers) DebugDraw

ddc

NameTypeDefaultDescription
ddc.AudioCookint-1Cache decoded audio as .maudio blobs in the DDC: -1=code default (ON), 0=off, 1=on AssetFormats
ddc.MaxSizeMBint4096Size cap on the project's derived data cache in MB; least recently used entries are evicted past it. 0 = uncapped Filesystem
ddc.MeshCookint-1Keep models built from source in the DDC, so a warm load skips the translation and the build: -1=code default (ON), 0=off, 1=on AssetSystem
ddc.TextureCookint-1Cache stb-decoded sources as cooked .mtex mip chains in the DDC so the editor shows the cooked texture: -1=code default (on), 0=off, 1=on AssetSystem

discord

NameTypeDefaultDescription
discord.ProvisionalAuthTypeint0How the game's identity token is presented for a provisional Discord account: 0 OIDC, 1 EOS access token, 2 EOS id token, 3 Steam session ticket, 4 Unity id token, 5 bot-issued access token, 6 Apple id token, 7 PlayStation id token Plugins.DiscordPlatform
discord.SocialboolfalseAsk Discord for the communication scopes at sign-in so the friends list and join invites work; off keeps the smaller presence-only consent screen. Read when the player signs in Plugins.DiscordPlatform
discord.Voice.AutoJoinCallbooltrueStart the lobby's Discord call when a Discord lobby is created or joined Networking
discord.Voice.AutomaticGainbooltrueAutomatic gain control on the Discord call microphone Networking
discord.Voice.EchoCancellationbooltrueEcho cancellation on the Discord call microphone Networking
discord.Voice.InputDevicestringstd::string()Discord call microphone device id; empty or a device that is gone uses the system default Networking
discord.Voice.InputVolumefloat1.0fMicrophone volume for Discord calls, 0 to 1 Networking
discord.Voice.Modeint0Discord call input mode: 0 voice activity, 1 push to talk (the game calls SetDiscordPushToTalk from its keybind) Networking
discord.Voice.NoiseSuppressionbooltrueNoise suppression on the Discord call microphone Networking
discord.Voice.OutputDevicestringstd::string()Discord call speaker device id; empty or a device that is gone uses the system default Networking
discord.Voice.OutputVolumefloat1.0fSpeaker volume for Discord calls, 0 to 2 (1 is the device level) Networking
discord.Voice.PttReleaseMsint20Milliseconds a Discord call keeps transmitting after the push-to-talk key is released Networking
discord.Voice.VadAutomaticbooltrueLet Discord pick the voice-activity threshold; off uses discord.Voice.VadThreshold Networking
discord.Voice.VadThresholdfloat-60.0fManual voice-activity threshold in dB, -100 to 0 Networking

ed

NameTypeDefaultDescription
ed.TickBudgetMsfloat4.0fMilliseconds per editor frame the edit world spends in AActor::TickInEditor (0 = unlimited); actors left over run first next frame Game

editor

NameTypeDefaultDescription
editor.AsyncImportGpuWorkPerFrameint24Max GPU work units (submesh meshes / materials) built per frame while draining async model imports; <= 0 = unbounded AssetSystem
editor.AsyncImportThreadsint0Editor async import loader threads; 0 = a quarter of the cores, between 2 and 4 AssetSystem
editor.AutosaveIntervalSecondsint300How often (seconds) the editor writes a crash-recovery autosave of the active dirty scene into Saved/Autosaves. 0 disables autosave. MowoEditor
editor.ContentWatchDebounceMsint400Quiet time after the last content-tree change before the registry reconciles; <= 0 disables the watcher AssetSystem
editor.ContentWatchMinIntervalMsint2000Shortest gap between two watcher-triggered registry reconciles AssetSystem
editor.DeferPaintUploadsbooltrueWhile the UI paints ahead of the render thread, queue the texture uploads the paint asks for (glyph atlas bands, lazily created images) and run them on the render thread before it records the UI. 0 = upload from the paint, which lost the D3D12 device in most Release runs. MowoEditor
editor.Details.LogRefreshint0Log each Details refresh: rows handed to the list, rows rebuilt, the row model's build time, and the time the list spent building row widgets. MowoEditor
editor.Details.PartialRefreshint1A property edit rebuilds only the Details rows whose content changed. 0 = every refresh rebuilds every row. MowoEditor
editor.IdleSceneSettleFramesint72Idle frames the viewports keep rendering after the last change before they hold their image, so TAA, GI and exposure converge first (72 = 3 s at the 24 Hz idle cap). MowoEditor
editor.IdleSkipSceneRenderbooltrueWhile the editor sits idle (the idle frame cap applies) and no camera, pane, entity or selection changed, stop rendering the level viewports once the temporal passes settled; the last image stays up. 0 = render every frame, idle or not. MowoEditor
editor.ImportAsPackagesint11 = a texture imports into a Texture package (.tex) and a sound into a Sound package (.sound) built from the source where it lies; 0 = the legacy copy into Content/ with a .mdfmeta sidecar. A texture asking for AI enhancement always takes the legacy path MowoEditor
editor.ImportModelsAsPackagesint11 = a model imports into SkeletalMesh/StaticMesh, Skeleton, AnimSequence and Texture packages built from the source where it lies; 0 = the legacy copy into Content/ with a .mdfmeta sidecar MowoEditor
editor.mcp.enabledboolfalseServe the editor's tools over MCP on a loopback HTTP port (Editor Preferences > MCP Server). MowoEditor
editor.mcp.portint52801Loopback port of the editor's MCP server; 0 takes any free port. MowoEditor
editor.MessageLog.OpenOnNewErrorint1Bring the Message Log to the front when a new error arrives. 0 leaves the panel where it is and raises a toast instead. MowoEditor
editor.OverlapStartupLoadsbooltrueRead and parse the start scene and index the Visual Script classes on their own threads while the project's asset registry loads or rebuilds. 0 = one after another on the editor thread, for comparing startup times MowoEditor
editor.SyncImportint0Editor model import: 0 = async (CPU on loader thread, GPU drained on the main thread), 1 = synchronous (blocking, legacy) AssetSystem
editor.Thumbnails.AsyncReadbackint1Read a rendered thumbnail back for the disk cache a few frames after its blit, polling a fence, instead of a synchronous readback that drains the GPU queue inside the editor frame: 1=on, 0=synchronous (A/B) MowoEditor
editor.UIPaintAheadbooltruePaint the editor UI for frame N+1 while the render thread still records frame N (double-buffered Arc batch); the uploads the paint asks for run on the record side (editor.DeferPaintUploads). 0 = paint only after the render thread drained. MowoEditor
editor.Undo.IncrementalRefreshint1An Undo or Redo that only changed property values refreshes the Details rows of the actors it touched instead of rebuilding the Outliner and Details. 0 = every step refreshes everything. MowoEditor
editor.Undo.LogRefreshint0Log how long the editor spent refreshing after each Undo or Redo, and whether the step took the incremental path. MowoEditor
editor.Viewport.RenderResolutionstringstd::string()Render the level viewport at a fixed WxH (e.g. 1920x1080) and stretch it into the panel; empty = the panel's own size MowoEditor

eqs

NameTypeDefaultDescription
eqs.ItemBudgetint512Environment-query item measurements EnvQuerySystem spends per frame across every queued query; a query that runs out resumes next frame where it stopped. <= 0 finishes the whole queue in one frame AINavigation

fx

NameTypeDefaultDescription
fx.Particles.Parallelint1Simulate CPU emitter trees and build their billboards on worker threads, one task per emitter: 0 = all on the calling thread Particles

game

NameTypeDefaultDescription
game.Rewindint0Time rewind: keep the last seconds of play and let gameplay (the Visual Script Rewind node) return to any of them Game
game.Rewind.BudgetMBint64Memory time rewind may hold; past it the oldest moments go first Game
game.Rewind.CaptureHzfloat10.0fMoments time rewind captures per second; a rewind lands on one of them Game
game.Rewind.Secondsfloat10.0fHow far back time rewind can go Game

i

NameTypeDefaultDescription
i.CursorConfineint-1Override how the cursor is confined to the window: -1 = whatever game code asked for, 0 = never, 1 = only while the game holds the cursor lock, 2 = always while focused. The lock takes the cursor into relative mode and confines it as a side effect, so only a game with a VISIBLE cursor needs 2 — without it that cursor walks onto the second monitor and the next click lands in another application. Focus gates every mode Input
i.DebugOverlayint0Draw the per-action input debug overlay (context, action, phase, value, trigger events, suppression) in the viewport Input
i.Gamepad0.StickDeadzonefloat-1.0fStick deadzone for slot 0; -1 = use i.StickDeadzone Input
i.Gamepad0.TriggerDeadzonefloat-1.0fTrigger deadzone for slot 0; -1 = use i.TriggerDeadzone Input
i.Gamepad1.StickDeadzonefloat-1.0fStick deadzone for slot 1; -1 = use i.StickDeadzone Input
i.Gamepad1.TriggerDeadzonefloat-1.0fTrigger deadzone for slot 1; -1 = use i.TriggerDeadzone Input
i.Gamepad2.StickDeadzonefloat-1.0fStick deadzone for slot 2; -1 = use i.StickDeadzone Input
i.Gamepad2.TriggerDeadzonefloat-1.0fTrigger deadzone for slot 2; -1 = use i.TriggerDeadzone Input
i.Gamepad3.StickDeadzonefloat-1.0fStick deadzone for slot 3; -1 = use i.StickDeadzone Input
i.Gamepad3.TriggerDeadzonefloat-1.0fTrigger deadzone for slot 3; -1 = use i.TriggerDeadzone Input
i.GamepadMotionbooltrueGamepad gyro and accelerometer: 0 keeps the sensors off and every motion read returns nothing Input
i.HoldToToggleint0Accessibility: a Hold trigger marked allow_toggle latches on its first press and releases on the next, instead of needing the key held down Input
i.MouseInvertYint0Invert the mouse Y delta axis Input
i.MouseSensitivityfloat1.0fMultiplier applied to both mouse-delta axes before any binding modifier (0.05..10) Input
i.RumbleScalefloat1.0fAccessibility: multiplier on every gamepad rumble and trigger-haptic request, 0 = off, 1 = as authored Input
i.StickDeadzonefloatGamepadInput::DefaultDeadzoneStick deadzone applied to every gamepad slot (0..1); the live range remaps to the full -1..1 Input
i.TriggerDeadzonefloatGamepadInput::DefaultTriggerDeadzoneAnalog trigger deadzone applied to every gamepad slot (0..1); the live range remaps to the full 0..1 Input

i18n

NameTypeDefaultDescription
i18n.Localestring"en"Active UI locale — tables load from <root>/<locale>/*.txt on change Filesystem
i18n.PseudoLocalizeboolfalsePseudo-localize every localized string (accented, a third longer, bracketed) to find text that was never localized and labels that will not fit a longer language Filesystem

import

NameTypeDefaultDescription
import.AutoCutoutAlphaint1Classify a material as alpha-masked when its base-colour alpha reads as authored cut-out coverage, for sources that declare no alphaMode and ship no opacity slot (ORCA/Falcor, DCC FBX foliage): 0=off, 1=on AssetSystem
import.ForceUpAxisint-1Rotate a source up-axis into engine +Y at import: -1=auto/off, 0=source X-up, 1=Y-up (no-op), 2=Z-up AssetSystem
import.UniformScalefloat-1.0fExtra uniform scale baked into every imported model's node transform: <=0 = off (use per-import), >0 = force this factor AssetSystem

interact

NameTypeDefaultDescription
interact.ConeDegfloat35.0fHalf-angle (degrees) of the view cone interactables must fall inside to be focusable Plugins.Combat
interact.Rangefloat3.0fDefault interaction reach (m) used when an Interactable leaves its own range at zero Plugins.Combat
interact.ScreenCenterWeightfloat1.5fFocus scoring weight of the angle to screen center relative to plain distance; higher favors what the camera looks at over what is merely close Plugins.Combat

job

NameTypeDefaultDescription
job.BackgroundWorkerReserveint3Workers kept free of Low-priority (background) jobs: they may hold at most workers minus this many at once, so High and Normal work always finds a worker. 0 = no cap Threading

lidar

NameTypeDefaultDescription
lidar.CatchupShotsPerTickint64Shots of history the host sends a late joiner per tick. Networking
lidar.HistoryMaxShotsint50000Shots the host keeps to replay to a late joiner; the oldest go first. 0 = unbounded. Networking
lidar.MaxOriginDistancefloat4.0fHow far (metres) a shot's origin may be from the shooter's pawn on the host. 0 = unchecked. Networking
lidar.MaxRaysPerSecondfloat60000.0fHost token bucket of LiDAR rays per player per second — what every peer pays to re-trace. 0 = unlimited. Networking
lidar.MaxRaysPerShotint16384Host cap on one replicated LiDAR shot's ray count; a larger shot is refused and not relayed. Networking
lidar.MaxShotRangefloat120.0fHost cap on a replicated LiDAR shot's range (metres). Networking
lidar.MaxShotsPerSecondfloat30.0fHost token bucket of LiDAR shots per player per second. 0 = unlimited. Networking

liveops

NameTypeDefaultDescription
liveops.ConfigUrlstring""Where the game fetches its signed remote config at start; empty = defaults and the cache only Game
liveops.TelemetryBatchint50Telemetry events sent per upload Game
liveops.TelemetryJournalint1Keep opted-in telemetry in Saved/Telemetry/events.jsonl as well, the file mbt liveops report reads Game
liveops.TimeoutSecondsint5How long a remote-config fetch or a telemetry upload may take Game

mdf

NameTypeDefaultDescription
mdf.Validateint-1MDF document validation on load. -1 = app default (editors on, runtime off), 0 = force off, 1 = force on. Reflection

meaf

NameTypeDefaultDescription
meaf.Verifyint-1MEAF payload verification: -1 = auto (2 when signed, else 1), 0 = off, 1 = per-entry CRC32 on load, 2 = also hash the data section at mount Filesystem

ml

NameTypeDefaultDescription
ml.ExecutionProviderstring"auto"Where on-device inference (AI texture enhancement, auto-subtitles) runs: auto takes the GPU through the WebGPU execution provider for texture enhancement and keeps the speech recognizer on the CPU (on the GPU it measured no faster and would share the game's frame), gpu puts every model on the GPU and warns when it has to fall back, cpu never touches the GPU. Applies to models loaded from then on ML

mods

NameTypeDefaultDescription
mods.Enabledint1Load mods from <package>/Mods, Saved/Mods and the providers (Steam Workshop) at start Game
mods.EnableNewint0A mod the enable list has never seen starts enabled; off, the player turns each new mod on Game
mods.RequireSignedint1Refuse a mod whose pak is not signed Game
mods.TrustedKeysstring""Comma-separated hex public keys trusted to sign any mod Game
mods.TrustedOnlyint0Accept only mods signed by mods.TrustedKeys or the game's own key, not by their author's Game

mowo

NameTypeDefaultDescription
mowo.GC.IncrementalbooltrueSpread the periodic GC across frames: the mark runs in mowo.GC.StepBudgetMs slices behind the TObjectPtr write barrier, then the sweep deletes at most mowo.GC.SweepBudget objects per frame. 0 = the old synchronous pass that marks AND deletes everything in one frame. EngineLoop
mowo.GC.IntervalSecondsfloat5.0fHow often (seconds) the GC fires. Set to 0 to disable periodic GC; manual Force Garbage Collect from the editor still works. EngineLoop
mowo.GC.StepBudgetMsfloat1.0fPer-frame marking budget (milliseconds) for the incremental GC. <= 0 = the mark completes atomically in one step (the old stop-the-world hitch). Budgeted marking became the DEFAULT once every engine MPROPERTY object ref went barriered (R5.1): TObjectPtr<T> fields barrier every store, the three raw-pointer MPROPERTY containers (world actors, actor components, attach children) shade their stores at the insertion sites, and SetOuter / actor spawn/attach call NotifyReferenceWrite. A game-module class that adds a plain T* MPROPERTY re-opens the hole — use TObjectPtr. EngineLoop
mowo.GC.SweepBudgetint128Max objects deleted per frame during the incremental GC sweep. <= 0 = unbounded (sweep completes in one step). EngineLoop
mowo.Profiler.Captureint0Retain the last N profiler frames (CPU scopes, GPU passes, memory tags) so they can be scrubbed and exported. Off by default - the ring copies every scope sample each frame. Core
mowo.Trace.Filestringstd::string()Stream every profiled frame to this .mtrace file (open it in MowoInsights). Empty stops the trace. --trace=<file> sets it at startup. Core
mowo.Trace.MaxSizeMBint2048Size of one .mtrace part in MB; past it the trace continues in <name>_001.mtrace, <name>_002.mtrace, ... 0 = one unbounded file. Core
NameTypeDefaultDescription
nav.ParallelTileBakeint1Bake the tiles of a tiled nav mesh on the job pool (1) or one after another (0); the result is the same either way AINavigation
nav.PathQueryBudgetint2048Detour search iterations NavAgentSystem spends per frame on queued gameplay path requests (RequestPathAsync); a request that runs out resumes next frame. <= 0 finishes the whole queue in one frame AINavigation
nav.Rebuildint1Rebuild tiled navmeshes at runtime where nav-relevant geometry moved, appeared or disappeared; 0 = the baked mesh stays as baked AINavigation
nav.Rebuild.MaxDelayfloat2.0fSeconds after which dirty navmesh areas rebuild even while geometry keeps moving AINavigation
nav.Rebuild.MaxTilesint16Most navmesh tiles one runtime rebuild pass bakes; further dirty areas wait for the next pass AINavigation
nav.Rebuild.SettleTimefloat0.3fSeconds the dirty navmesh areas must stay unchanged before their tiles rebuild, so a door swinging shut rebuilds once AINavigation
nav.StreamBySectorint1Keep only the navmesh tiles whose world-streaming sector is loaded in the live mesh: a tile leaves with its sector and comes back with it. Tiled, obstacle-free meshes only; a world with no streaming sectors keeps every tile AINavigation
nav.StreamTilesPerFrameint8Navmesh tiles NavAgentSystem adds or removes per lane per frame while streaming by sector. <= 0 = no limit AINavigation
nav.UseCrowdint1Steer agents through dtCrowd when it is up. 0 = single-agent path following on the budgeted path queue (the fallback a failed crowd init takes) AINavigation

net

NameTypeDefaultDescription
net.ack_probe_intervalint16Snapshot ticks between keep-alive probes sent to an ack-stalled peer. The probe is an empty header, so its cost does not scale with object count. Networking
net.AllowDirectHostint0Listen server with Steam up: 1 = also open the direct ENet UDP listener beside the Steam relay (LAN and --connect ip:port joins work; every peer sees the host's IP). 0 = relay only, unless the project's Network Privacy setting or the session asks for direct hosting. Dedicated servers always listen directly. Networking
net.BlobBytesPerSecondint32768Bytes per second the blob lane sends to one peer. 0 = unlimited (the window still bounds what is in flight). Networking
net.BlobBytesPerTickint0Most blob bytes one replication tick sends across all peers, so a burst of joiners cannot spend a whole frame's link budget. 0 = no cap. Networking
net.BlobChunkBytesint1024Payload bytes per blob chunk (256 to 16384). Keep chunk plus the 40 bytes of headers under the transport MTU; a larger chunk is fragmented by the transport and a single lost fragment resends all of it. Networking
net.BlobMaxQueuedBytesint16 * 1024 * 1024Payload bytes the blob lane queues for one peer before it refuses more: a slow or stalled client costs the host this much memory, not the whole world. 0 = no cap. Networking
net.BlobWindowChunksint32Blob chunks (1 KiB each) a sender may have unacknowledged per peer before it waits for the receiver. Networking
net.BlobZstdLevelint3zstd level for blobs queued from now on (RPCs of 64 KiB and up, bulk data). 0 sends them uncompressed; a blob that does not shrink by 5% is sent as it is anyway. Networking
net.CharacterPredictionbooltrueClient-side character prediction with server reconcile through the real Jolt character step. 0 = interpolation-only ghosts, no input receiver. Networking
net.CorrectionSmoothTimefloat0.1fTime constant (seconds) of the visual offset that hides a prediction correction on the local pawn. 0 = snap. Networking
net.CorrectionSnapDistancefloat2.0fA correction larger than this (meters) is a teleport and snaps instead of smoothing. Networking
net.cull_distancefloat100.0fDefault distance-relevancy radius (world units) for NetworkObjects that don't set net_cull_distance. Networking
net.encryptstring"on"ENet session encryption: on (every link, LAN included) | auto (non-private addresses only) | off Networking
net.gns.MaxSendRateint4096GameNetworkingSockets transport: the most a connection may send, in KB per second. GNS starts each connection at a rate derived from its round trip and never above this; 256 is the floor. Applies to connections opened after the change. Networking
net.graphint0The netgraph overlay: 0 off, 1 frame rate, ping, jitter, loss, bandwidth and server tick, 2 adds their graphs, 3 adds CPU/GPU temperature and load. Off by default in a packaged game; a project sets it in its INI, a player in the options menu. ArcUI
net.input_rate_limitint120Max client->server Input packets accepted per peer per second. 0 = unlimited. Networking
net.MaxBlobBytesint4 * 1024 * 1024Largest RPC (bytes) the blob lane sends, and the largest a client accepts from the host. Networking
net.MaxClientBlobBytesint256 * 1024Largest blob (bytes) a host reassembles from one client; a client that announces more is refused before any memory is reserved. Networking
net.MaxMoveDeltaTimefloat0.125fLongest time (seconds) the server steps for one client move; a longer claimed delta is clamped, as UE's MaxMoveDeltaTime. Networking
net.MaxQueuedMovesint64Moves the server holds per player before it drops the oldest. Networking
net.max_snapshot_bytesint1200Max snapshot packet bytes per client per tick. 0 = unlimited. Networking
net.max_unacked_sendsint64Snapshot packets a peer may go without acking before the server stops sweeping objects for it and falls back to a keep-alive probe. 0 = never stall (unbounded resend). Networking
net.max_updates_per_tickint64Max snapshot entries per client per tick. 0 = unlimited. Overflow is deferred, not dropped — staleness raises priority. Networking
net.MoveCombineSecondsfloat1.0f / 30.0fLongest time (seconds) one combined move may cover before it is sent; capped by net.MaxMoveDeltaTime. UE's ClientNetSendMoveDeltaTime. Networking
net.MoveCombiningbooltrueHold a client move back and merge the next one into it when both carry the same input, no jump press and no root motion, as UE's pending-move combining. Halves the moves sent while input is steady. Networking
net.MoveTimeBudgetfloat0.25fHow far (seconds) a client's moves may run ahead of the server's clock before the server makes them wait. Bounds speed hacks that claim more time than passed; UE's movement time discrepancy. Networking
net.OwnerPriorityBoostfloat4.0fPriority multiplier for an object the peer owns (its pawn, its carried prop) within the object's tier. UE's sphere-with-owner-boost prioritizer. 1 = no boost. Networking
net.peer_byte_budgetint6000Outgoing bytes per second the server will spend on one peer. Reliable traffic is charged but never dropped; the unreliable snapshot sweep is capped by what remains. 6000 B/s = 48 kbit/s, the per-client target. 0 = unlimited. Networking
net.peer_in_byte_budgetint8192Incoming bytes per second the server will accept from one peer, charged before the packet is decoded. The RPC and input limits count packets, not bytes, so without this one peer can hand the host megabytes a second inside a legal packet rate. 0 = unlimited. Networking
net.PredictionSendHzint60Client input command send rate. Frames between sends accumulate into the command's dt so replay integrates the same time span. Networking
net.PredictionTolerancefloat0.25fPositional divergence (meters) between the predicted pawn and the server's authoritative pose that triggers a rewind + replay correction. Networking
net.pskstring""Pre-shared key mixed into the ENet handshake KDF; a peer without it fails key confirmation. Empty = the host makes up a join key per session, which every peer from off this machine must present (host:port#KEY) Networking
net.QuantizeMovesbooltrueSnap a move's input axes to the grid the server simulates with (1/127 for movement, 1/100 for look) on both ends, so the client predicts with the exact values the server steps, as UE's acceleration quantization. Networking
net.rejoin_grace_secondsfloat60.0fSeconds the host holds a dropped player's slot, pawn and NetworkIds so the same identity can re-bind to them. 0 = a disconnect is a leave. Networking
net.relevancybooltruePer-client relevancy filtering, priority and the per-peer byte budget on the server. 0 = every peer sees every replicated object (legacy), still capped per packet by net.max_snapshot_bytes and the byte budget. Networking
net.rewind.framesintstatic_cast<int>(FNetRewindRecording::skDefaultCapacity)Frames the net rewind ring keeps per peer (1800 = a minute at 30 Hz). Networking
net.rewind.recordboolfalseKeep a ring of every replicated frame on this peer and write it to Saved/NetRecordings when the session ends, for the Net Rewind panel. Networking
net.Rollbackint0Rollback netcode for the play session: the ECS world runs as a deterministic fixed-step simulation, inputs are exchanged and predicted, mispredictions are rolled back and resimulated Game
net.Rollback.ChecksumIntervalint10Frames between desync checks (checksums of fully confirmed frames) Game
net.Rollback.InputDelayint2Frames a local input waits before it is simulated; each one is a frame of latency the remote input can hide in Game
net.Rollback.MaxPredictionint8Frames the simulation may run ahead of a peer's last input before it stalls Game
net.Rollback.OnDesyncint0What a desync does: 0 logs it and plays on, 1 logs it and ends the rollback session (net.Rollback off) so the machines stop simulating different worlds Game
net.Rollback.TickRateint60Rollback simulation frames per second Game
net.RpcBlobThresholdint0An RPC packet larger than this (bytes) goes through the blob lane: chunked on the reliable unordered channel under net.BlobBytesPerSecond and net.BlobWindowChunks, so it neither stalls the ordered reliable channel nor floods the link, but it is no longer ordered against the rest of the reliable stream. Arguments of 64 KiB or more, which the Rpc body cannot carry, always take it. 0 = only those. Networking
net.rpc_rate_limitint32Max client->server RPCs accepted per peer per second. 0 = unlimited (ENet applies no bandwidth limit of its own). Networking
net.rpc_rate_limit_highint200Max client->server RPCs per peer per second on methods registered as the HighRate channel class (a continuously-swept sensor, a held-trigger weapon). Separate bucket from net.rpc_rate_limit. 0 = unlimited. Networking
net.ServerForceMoveSecondsfloat0.5fA remote pawn that sends no move for this long is stepped by the server with no input, so it still falls and gets pushed. 0 = never. Networking
net.sim.dupfloat0.0fSimulated duplication, percent of frames delivered twice. 0 = off. Networking
net.sim.jitterint0Simulated jitter in milliseconds, uniform noise on top of net.sim.latency. 0 = off. Networking
net.sim.latencyint0Simulated one-way latency in milliseconds, added to every frame on send and on receive. 0 = off. Networking
net.sim.lossfloat0.0fSimulated packet loss, percent of frames dropped on send and on receive. 0 = off. Networking
net.sim.reorderfloat0.0fSimulated reordering, percent of frames held back so a later frame overtakes them. 0 = off. Networking
net.starvation_ticksint32A relevant object this many snapshot ticks stale outranks priority entirely. 0 = pure priority ordering (can starve). Networking
net.Transportstring"composite"Wire transport for sessions: composite (ENet, plus the platform relay for SteamID64 targets and dual-listen hosting) | enet | gns (GameNetworkingSockets over IP) | steam (platform relay only). Followed until a session hosts or joins, so a project config applied after startup still counts; an option this build cannot honour falls back to composite. Networking
net.ViewConeDegreesfloat60.0fHalf-angle (degrees) of the view cone net.ViewConePriorityBoost applies inside. Networking
net.ViewConePriorityBoostfloat2.0fPriority multiplier for an object inside the peer's view cone, fading to 1 at the cone's edge. UE's field-of-view prioritizer. 1 = off. Networking
net.voice_budget_sharefloat0.5fLargest share (0..1) of net.peer_byte_budget that voice relayed to a peer may spend; replication keeps the remainder. 0 = voice is not charged. Networking

p

NameTypeDefaultDescription
p.AsyncTickboolfalseStep Jolt on a worker between this frame's submit and the next frame's join; poses land one frame late and any call that reaches Jolt in between waits for the step Physics
p.CharacterEdgeRemovalboolfalseCharacter controllers spend extra effort removing ghost contacts on the internal edges of a triangle mesh, so a capsule slides smoothly over mesh seams and convex edges instead of catching; costs more per character step, read when a controller is created Physics
p.DebugboolfalseMaster switch for the physics debug visualizer Cheat. Physics
p.DebugAABBboolfalseDraw world-space bounding boxes when p.Debug is on Physics
p.DebugBroadPhaseboolfalseDraw body bounds tinted by object layer, dimmer for the non-moving broad phase layer, when p.Debug is on Physics
p.DebugCOMboolfalseDraw centre-of-mass crosses when p.Debug is on Physics
p.DebugConstraintsbooltrueDraw constraint anchors when p.Debug is on Physics
p.DebugContactsboolfalseDraw contact normals when p.Debug is on Physics
p.DebugIslandsboolfalseDraw a box around each simulation island (awake bodies joined by contacts or constraints) when p.Debug is on Physics
p.DebugShapesbooltrueDraw collider wireframes when p.Debug is on Physics
p.DebugVehiclesboolfalseDraw each wheel's suspension travel, contact point and contact normal when p.Debug is on Physics
p.DebugVelocityboolfalseDraw velocity arrows when p.Debug is on Physics
p.DeterministicboolfalseReproducible physics: Jolt's jobs run single-threaded in a fixed order and contact events are dispatched sorted by body pair, so the same inputs replay bit-identically on the same binary and CPU Physics
p.LODint-1Distance simulation LOD around the focus: -1=on while a focus is set, 0=off, 1=on Physics
p.LODSleepRadiusfloat150.0fDynamic bodies farther than this from the focus are force-deactivated Physics
p.LODWakeRadiusfloat120.0fLOD-frozen bodies wake when the focus comes back within this radius Physics
p.MaxSubstepsint8Upper bound on fixed-timestep substeps per frame; time beyond this is discarded rather than banked Physics
p.OverlapDuringPhysicsbooltrueKick the frame's physics steps onto a worker after the PrePhysics tick group and join after DuringPhysics, so those actor ticks overlap the solver; the world systems ordered ahead of physics still run before the kick, and what a DuringPhysics tick moves is seen by the next step, as in UE Physics
p.PositionStepsint2Solver position iterations per physics step (Jolt default 2): how hard penetrations are pushed apart; read when the world comes up Physics
p.SnapshotFramesint128Whole-world physics snapshots the rollback ring keeps (0 turns capturing off). Only ticks gameplay captures are stored, each a full copy of the simulation state; read when the ring is first used Physics
p.Statsint0Log the physics stats snapshot every N frames (0=off) Physics
p.Threadsint-1Upper bound on the workers Jolt splits a step across (-1 = the whole engine pool); ignored under p.Deterministic Physics
p.VelocityStepsint10Solver velocity iterations per physics step (Jolt default 10). Raise to settle tall stacks and piles harder, lower to trade stability for step time; read when the world comes up Physics

pcg

NameTypeDefaultDescription
pcg.NodeCacheint1Reuse a PCG node's points when its inputs, parameters, seed, bounds, landscape and splines hash to a result already computed, so a regeneration only reruns the nodes downstream of what changed. 0 = recompute every node PCG
pcg.NodeCacheEntriesint512Node results the PCG cache keeps across every volume before it drops the least recently used PCG

phys

NameTypeDefaultDescription
phys.Debris.MaxCountint256Destruction debris budget per scene: the oldest shard is recycled when a break would exceed it. Destruction
phys.Debris.MaxLifetimefloat20.0fSeconds a destruction shard may exist before it is recycled, whatever its component asks for (0 on the component means this cap). Destruction
phys.Debris.MaxSpawnPerFrameint64Destruction shards one frame may spawn across every break; a break past it produces fewer pieces instead of a hitch. Destruction

r

NameTypeDefaultDescription
r.AO.Divisorint-1Resolution divisor for the AO trace and its horizontal blur; the vertical blur stays full-res and doubles as the bilateral upsample: -1=tier value, 1=full res, 2=half SceneRenderer
r.AsyncCompute.AvoidAluOverlapint1Join an async-compute lane before the first ALU-heavy pass (GTAO, RT sun shadow, MegaLights) instead of at its first consumer: 1 = join early (the lane only overlaps raster-bound work), 0 = overlap until the consumer SceneRenderer
r.Atmosphere.SunTransmittanceint1Modulate the directional light by the atmospheric transmittance along the sun ray (reddens + dims the sun toward the horizon; the authored light color stays the artist's base): 0=off, 1=on SceneRenderer
r.AutoExposure.EVfloat0.0fEV compensation added on top of the scene's auto-exposure EV (photographic stops); 0 keeps scene authority SceneRenderer
r.AutoExposure.HighPercentfloat-1.0fPercentile metering (mode 3): where the metered window closes, in percent of the pixels ordered by luminance. -1 = the scene's own value SceneRenderer
r.AutoExposure.LowPercentfloat-1.0fPercentile metering (mode 3): where the metered window opens, in percent of the pixels ordered by luminance. -1 = the scene's own value SceneRenderer
r.AutoExposure.MaxEVfloat999.0fBrightest adapted exposure the eye adaptation may settle at, in stops (multiplier = 2^EV). Lower it to stop a dark scene being lifted to grey. 999 = the scene's own value SceneRenderer
r.AutoExposure.Meteringint-1Auto-exposure metering override: -1=scene setting, 0=average, 1=spot (center circle), 2=center-weighted, 3=histogram percentile SceneRenderer
r.AutoExposure.MinEVfloat999.0fDarkest adapted exposure the eye adaptation may settle at, in stops (multiplier = 2^EV). 999 = the scene's own value SceneRenderer
r.AutoExposure.SpeedDownfloat-1.0fAdaptation rate toward darker scenes (exposure rising), 1/s — dark adaptation is slower. -1 = the scene's own value SceneRenderer
r.AutoExposure.SpeedUpfloat-1.0fAdaptation rate toward brighter scenes (exposure falling), 1/s — eyes adapt to light fast. -1 = the scene's own value SceneRenderer
r.AutoInstancingint-1Collapse identical (mesh, material, LOD) static draws into instanced draws: -1=code default, 0=off, 1=on SceneRenderer
r.AutoQuality.ForceCoresint-1GPU auto-tier: simulate this logical core count (-1 = real machine) SceneRenderer
r.AutoQuality.ForceDeviceIdint-1Device profiles: simulate this PCI device id (-1 = real device) SceneRenderer
r.AutoQuality.ForceDriverstring""Device profiles and the driver blocklist: simulate this driver version (empty = real driver) SceneRenderer
r.AutoQuality.ForceIntegratedint-1GPU auto-tier: simulate device type — 0=discrete 1=integrated (-1 = real device) SceneRenderer
r.AutoQuality.ForceNamestring""GPU auto-tier: simulate this device name (empty = real device) SceneRenderer
r.AutoQuality.ForceRamMBint-1GPU auto-tier: simulate this system RAM size in MB (-1 = real machine) SceneRenderer
r.AutoQuality.ForceVendorstring""Upscaler auto-pick: simulate this GPU vendor string (empty = real device) SceneRenderer
r.AutoQuality.ForceVendorIdint-1Device profiles: simulate this PCI vendor id (-1 = real device) SceneRenderer
r.AutoQuality.ForceVRAMMBint-1GPU auto-tier: simulate this VRAM size in MB (-1 = real device) SceneRenderer
r.AutoQuality.VendorUpscalersint0Let the upscaler auto-pick choose a vendor scaler (DLSS/FSR/XeSS) instead of the engine's own TSR. Off by default: the vendor SDKs interpose the graphics API and their process-exit handlers have already proved fragile. SceneRenderer
r.Bake.MeshCardsint1Cluster mesh surfaces into GI surface-cache card sets in cooked .mmodel (v11): 0=off (the runtime fits one box per instance), 1=on AssetFormats
r.Bake.MeshSdfint1Bake a per-mesh signed distance field into cooked .mmodel (v6): 0=off, 1=on AssetFormats
r.Bake.MeshSdf.LiveMaxTrianglesint250000Triangle budget for baking a mesh SDF during a live (non-cooked) import; 0 = never bake live, cooked .mmodel only AssetSystem
r.Bake.MeshSdfThreadsint0Threads baking mesh SDFs for one model: 0 = every hardware thread, 1 = serial AssetFormats
r.BcHdrTexturesint1Block-compress HDR texture sources to BC6H at texture cook (DDC-cached, mips end-to-end): 0=off (raw RGBA16F), 1=on AssetSystem
r.BcModelTexturesint1Block-compress decoded model textures at import (albedo/data BC7, normals BC5; DDC-cached): 0=off, 1=on AssetSystem
r.BcModelTexturesBC1int0Fast-path fully-opaque sRGB model textures (albedo/emissive) to BC1 instead of BC7 — half the VRAM of BC7, much faster encode, 565 endpoint quality: 0=off, 1=on AssetSystem
r.BindlessAlbedoint-1Bindless GBuffer material table (albedo + normal/MRA/detail/mask/height): -1=code default, 0=off, 1=on SceneRenderer
r.Bloom.Mipsint-1Bloom mip chain length processed (1..6): -1=tier value SceneRenderer
r.CapsuleShadowsint1Capsule shadows from skinned meshes with Capsule Shadows on: 0 = off, 1 = on SceneRenderer
r.CapsuleShadows.DirectStrengthfloat0.85fHow much a capsule shadows the sun (0..1) SceneRenderer
r.CapsuleShadows.IndirectStrengthfloat0.8fHow much a capsule occludes the sky / indirect light (0..1) SceneRenderer
r.CapsuleShadows.MaxDistancefloat4.0fWorld distance along the sun ray over which a capsule shadow fades out SceneRenderer
r.CapsuleShadows.SoftnessAnglefloat12.0fHalf-angle in degrees of the sun cone a capsule shadow is traced with: wider = softer, further-reaching penumbra SceneRenderer
r.Clouds.ShadowFootprintfloat4000.0fWorld size of the sun-aligned cloud shadow footprint around the camera, snap-stabilized like CSM SceneRenderer
r.Clouds.ShadowMapSizeint512Cloud shadow map resolution in texels (per side) SceneRenderer
r.Clouds.Shadowsint-1Sun-space cloud transmittance map multiplied into the deferred sun term + froxel fog in-scatter (raymarched clouds only): -1=scalability tier default (High+), 0=off, 1=on SceneRenderer
r.Clouds.ShadowSamplesint4Density samples of the vertical transmittance integral through the cloud slab (2..8) SceneRenderer
r.Clouds.ShadowStrengthfloat1.0fBlend of the cloud transmittance into the sun visibility (0 = no darkening, 1 = full) SceneRenderer
r.Color.Temperaturefloat-1000.0fWhite-balance override in [-1,1] (cool..warm); < -900 uses the scene's own value SceneRenderer
r.Color.Tintfloat-1000.0fWhite-balance tint override in [-1,1] (green..magenta); < -900 uses the scene's own value SceneRenderer
r.ColorBlind.Modeint0Accessibility: colour-vision correction after the tonemap, 0 = off, 1 = protanopia, 2 = deuteranopia, 3 = tritanopia (Machado 2009 simulation, the lost difference folded into the channels the viewer keeps) SceneRenderer
r.ColorBlind.Simulateint0Accessibility preview: show the frame as a viewer with a colour-vision deficiency sees it, after any correction; 0 = off, 1 = protanopia, 2 = deuteranopia, 3 = tritanopia SceneRenderer
r.ColorBlind.Strengthfloat1.0fAccessibility: how much of the colour-vision correction is applied, 0..1 SceneRenderer
r.ColorGradingLUTstring""Color-grading .cube 3D LUT path override: empty=scene setting SceneRenderer
r.ContactShadowStepsint-1Screen-space contact shadow march steps: -1=tier value SceneRenderer
r.D3D11.RenderThreadint1D3D11 with the render and RHI threads: 1 = the render thread owns the immediate context and records frame N-1 while the game thread produces N, other threads' buffer/texture writes queue for the next frame's start (FD3D11UploadQueue), 0 = D3D11 runs the frame on the game thread as before. Read when the host starts RHI
r.D3D12.AsyncComputeint1Enable the D3D12 async-compute lane (latched at first use). On by default; 0 records every r.AsyncCompute candidate inline on the direct queue (the escape hatch for a driver whose compute queue is slower than its graphics queue): 0=off, 1=on D3D12RHI
r.D3D12.AsyncCompute.SyncSubmitint01 = issue the async-compute fork, hand-off and join splits through FRHIThread::ExecuteSync (the render thread waits for the whole RHI queue each time, the pre-2026-10-19 path), 0 = record the split on the render thread and queue only the execute/signal/wait D3D12RHI
r.D3D12.AsyncUploadsint1Create-with-data uploads on D3D12 (static buffers, texture data) submit their single-time list and return without waiting for the GPU; the staging is released once the list's fence passes. 0 = wait for every upload (the old blocking path) D3D12RHI
r.D3D12.CopyQueueUploadsint1Create-with-data uploads on D3D12 (fresh static buffers and textures) copy on the COPY queue, and the direct queue waits for them on the GPU instead of running the copies itself. 0 = copy on the direct queue (requires r.D3D12.AsyncUploads to stay non-blocking) D3D12RHI
r.D3D12.FrameLatencyWaitableint1Create the D3D12 swapchain with a frame-latency waitable object and block BeginFrame on it, as D3D11 does. Without it the only throttle is the frame fence, which lets DXGI queue its default three presents ahead of the display: 0=off, 1=on (not with a frame-generation proxy swapchain, which owns pacing) D3D12RHI
r.D3D12.MaxFrameLatencyint2Presents the D3D12 swapchain may queue ahead of the display when r.D3D12.FrameLatencyWaitable is on: 1 = lowest latency, risks a GPU bubble when the CPU frame is long; 0 = FramesInFlight; clamped to FramesInFlight D3D12RHI
r.DDGIint-1GI DDGI probe-field indirect diffuse (needs the world SDF it traces): -1=tier value, 0=off, 1=on SceneRenderer
r.DDGI.ProbesPerAxisint-1DDGI probes along each grid axis (8..16, bounds-fit so more = denser): -1=tier value. Applied at startup; a change takes effect on the next launch SceneRenderer
r.DDGI.RaysPerProbeint-1DDGI rays traced per probe per frame: -1=tier value (live buffer recreate, GI history reset) SceneRenderer
r.DepthPrepassint-1Depth prepass before the G-buffer (eligible opaque static draws; the G-buffer then shades each visible pixel once): -1=tier value (High+), 0=off, 1=on SceneRenderer
r.DeviceProfile.Enableint1Match the GPU against DeviceProfiles.ini and apply the winning profile's tier cap and cvars (1). 0 = no device profile. SceneRenderer
r.DeviceProfile.Forcestring""Use this [DeviceProfile <Name>] whatever the GPU is (empty = match the device). SceneRenderer
r.DisplayGammafloat2.2fAccessibility: the gamma the player's panel is assumed to have, 1.8..2.6; the SDR image is re-encoded from 2.2 so a darker panel gets its shadows back SceneRenderer
r.DisplayLUTstring""OCIO-style display-transform .cube LUT for tonemap operator 5, indexed by the engine's log2 shaper (log2(x / 0.18) from -10 to +6.5 stops): empty=scene setting SceneRenderer
r.DLSS.Presetint0DLSS Super Resolution network preset: 0 = driver default, 1 = J (least ghosting, more flicker), 2 = K (transformer, DLAA/Quality/Balanced default), 3 = L (Ultra Performance default, most expensive), 4 = M (Performance default) SceneRenderer
r.DLSS.RayReconstructionint0DLSS Ray Reconstruction: while DLSS is the upscaler and the GPU supports it, one NVIDIA model denoises every ray-traced signal (RT reflections, RT/GI, RT shadows, RTAO, MegaLights) and upscales in the same pass; the engine's own denoisers are skipped. 0=off (engine denoisers), 1=on RHI
r.DoF.Bokehint-1DoF blur kernel: -1=scalability tier (Epic+ take the disk), 0=separable gaussian, 1=circular bokeh disk gather + fill SceneRenderer
r.DriverBlocklist.Promptint1Tell the player when their graphics driver is on the driver blocklist (1). 0 = log only. SceneRenderer
r.DynamicResint-1Dynamic resolution: -1=auto (the shipped runtime turns it on, the editor viewport leaves it off), 1=drive the render scale toward r.DynamicRes.TargetMs from the measured GPU frame time, 0=off (static scale) SceneRenderer
r.DynamicRes.MaxScalefloat1.0fDynamic resolution upper render-scale bound (0.25..1.0) SceneRenderer
r.DynamicRes.MinScalefloat0.6fDynamic resolution lower render-scale bound (0.25..1.0). 0.6 rather than 0.5: below about 60% the drop stops being something the upscaler can hide, and a visibly soft frame reads as a broken game rather than a busy one. SceneRenderer
r.DynamicRes.TargetMsfloat16.6fDynamic resolution GPU frame-time target in milliseconds SceneRenderer
r.Effects.CullDistanceScalefloat-1.0fMultiplier on every emitter's authored cull distance: -1=tier value SceneRenderer
r.Effects.LogStatsint0Log particle submission, fill-budget and collision counters every N views (0 = off) SceneRenderer
r.Effects.MaxActiveEmittersint-1Emitters submitted per view, nearest first: -1=tier value, 0=unlimited SceneRenderer
r.Effects.MaxParticleScalefloat-1.0fMultiplier on every emitter's authored pool size: -1=tier value SceneRenderer
r.Effects.OverdrawBudgetfloat-1.0fScreens of particle fill admitted per view: -1=tier value, 0=unlimited SceneRenderer
r.Effects.SpawnRateScalefloat-1.0fMultiplier on every emitter's authored spawn rate and burst: -1=tier value SceneRenderer
r.Foliage.DensityScalefloat1.0fFoliage scatter density multiplier (scalability tier hook, rebuilds foliage on change) SceneTypes
r.Foliage.GPUint1GPU-instanced foliage: 1 = per-instance GPU culling + indirect draws (default), 0 = legacy CPU-baked cell meshes SceneTypes
r.Foliage.GrassDistancefloat60.0fMax grass draw distance in world units; blades shrink-fade over the last 25% SceneRenderer
r.Foliage.ImpostorDistancefloat90.0fDistance at which foliage tree meshes hand off to camera-facing impostor cards SceneTypes
r.Foliage.LocalShadowsint1GPU grass casts into point/spot shadow atlas tiles whose frustum reaches the field (0 = off; also off when foliage shadow cascades resolve to 0) SceneRenderer
r.Foliage.ShadowCascadesint-1CSM cascades GPU grass casts into (0 = grass shadows off, -1 = scalability tier default; grass sits inside r.Foliage.GrassDistance so the near cascades cover it) SceneRenderer
r.FrameGenerationint0Frame generation: 0=off 1=on (swapchain recreates on change) RHI
r.FrameGeneration.AutoHoldint11 = under VSync, hold frame generation off while the scene already renders at the display refresh (generated frames could not be presented), 0 = engage whenever r.FrameGeneration is on RHI
r.FrameGeneration.AutoHold.EngageRatiofloat1.15fFrame generation engages once the measured base frame interval exceeds the refresh period times this ratio RHI
r.FrameGeneration.Backendint0Frame-generation backend preference: 0=auto (prefer DLSS-G, then FSR3), 1=FSR3, 2=DLSS-G, 3=XeSS-FG RHI
r.FrameGeneration.Dynamicint0DLSS-G dynamic multi frame generation: 1 = vary the multiplier to hold r.FrameGeneration.TargetFps (needs driver support), 0 = fixed multiplier RHI
r.FrameGeneration.EnableForProjectint0Project switch: 1 = this project offers frame generation (DLSS-G, FSR3, XeSS-FG, MetalFX). 0 = r.FrameGeneration is ignored and the player's options hide it RHI
r.FrameGeneration.Multiplierint2Frame generation output multiplier, 2-6 (presented frames per rendered frame). Clamped to what the backend reports for this GPU: DLSS 4 MFG reaches 4x, DLSS 4.5 6x, FSR3 and MetalFX stay at 2x RHI
r.FrameGeneration.TargetFpsfloat0.0fTarget presented frame rate for dynamic frame generation, 0 = the display refresh rate RHI
r.FSR1.Sharpnessfloat0.25fFSR1 spatial upscaler RCAS sharpening applied after EASU: 0 = off, 1 = full lobe RHI
r.GaussianSplat.MaxPerInstanceint1 << 20Most splats one Gaussian splat instance sorts and draws; the LOD chain steps coarser until a level fits (power of two padding, so 1M sorts as 1M) SceneRenderer
r.GI.AlphaTestedint1Alpha-masked (cutout) geometry in GI/RT. 1 (default) = coverage-aware: the SDF voxelizer dithers a masked draw's occupancy+albedo splat by the albedo texture's average alpha (a 30%-coverage fence registers ~30% of its voxels — occlusion AND bounce scale together), masks sparser than 0.15 skip the distance/albedo splat entirely, and TLAS instances are marked non-opaque so RT reflection/AO ray queries stochastically accept candidates with probability = coverage; 2 = same but very sparse masks (<0.15) still dither instead of skipping (A/B for the sparse verdict); 0 = legacy fully-opaque bias. Flipping forces the next SDF rebuild SceneRenderer
r.GI.AOWeightfloat1.0fHow strongly the screen-space AO term (GTAO/RTAO) occludes the DDGI indirect at composite (0=unoccluded probe fill, 1=fully AO-modulated) SceneRenderer
r.GI.AsyncComputeint1Record the GI volume update (SDF build, radiance cascades, DDGI probe trace + integrate) on the async-compute lane: forked before the shadow depths, overlapping the raster-bound passes, joined before the first ALU-heavy pass (GTAO, RT sun shadow, MegaLights) or its first consumer (lighting), whichever comes first. 0 = inline, 1 = lane when r.RDG.AsyncCompute allows and the backend has a real second queue SceneRenderer
r.GI.AsyncCompute.MaxMarchMillionsfloat32.0f...and at most this: longer than the raster-bound window it overlaps, the lane makes the first ALU-heavy pass wait for it and the frame loses; 0 = no upper limit SceneRenderer
r.GI.AsyncCompute.MinMarchMillionsfloat0.25fThe GI update opts into the async lane only while its per-frame probe march (probes x rays per probe x trace steps / radiance-cascade interval, in millions) is at least this: less work than this cannot hide the cross-queue sync it costs SceneRenderer
r.GI.AsyncGatherint1Run the SDF triangle gather (mesh iteration + soup-cache lookups + shell AABB filter + upload-buffer assembly) on an FTaskGraph worker instead of the render thread. 1=async — submit on the scroll/rebuild/cascade event frame, consume the finished soup when the job lands (the 8-cell scroll dead band absorbs the ~1-frame latency); 0=synchronous (A/B + debugging). The FIRST SDF build always gathers synchronously (startup/PIE/scene-switch correctness over latency) SceneRenderer
r.GI.Bakedint1Sample the scene's baked GI field (<scene>.mgi) on a tier with live DDGI off: 1 = when present, 0 = never (flat sky ambient, the old Low look) SceneRenderer
r.GI.BakedSdf.DetailTraceint1Two-level near detail trace: when the baked composite is active, upload the resident per-mesh baked fields to a GPU atlas + instance table and, in the screen-probe gather and SDF reflections, march the nearby instance fields at their baked resolution BEFORE the 0.25 m global clipmap (per-ray instance list cull). Resolves thin features (wires, fences, mullions, grates) the clipmap fattens or drops. 1=on (default); 0=clipmap-only (A/B). Inert unless the baked composite ran this frame SceneRenderer
r.GI.BentNormal.Divisorint-1Resolution divisor for the bent-normal filter (floored at r.AO.Divisor); below full res the GI composite upsamples it with a 4-tap depth bilateral: -1=tier value, 1=full res, 2=half SceneRenderer
r.GI.BentNormalAOfloat1.0fDirectional bent-normal cone occlusion of the GI gather. 0 = scalar AO multiply (the r.GI.AOWeight fallback), >0 = strength of the extra geometry-directed occlusion where the bent normal (average unoccluded dir from GTAO/RTAO) tilts away from the surface normal in creases/contacts. 1 = full SceneRenderer
r.GI.DDGI.ColdStartEaseint1With the static SDF no longer scrolling (baked composite), ease the residual DDGI probe cold-start — a freshly-exposed/scrolled probe seeds its irradiance+depth history from the average of its nearest CONVERGED (non-fresh) physical neighbours and eases in (hysteresis 0.75) instead of restarting from 0, so indirect light does not visibly fade in behind camera motion. 1=on (default); 0=legacy cold restart (A/B) SceneRenderer
r.GI.DDGI.ConvergedFramesint150Frames with an unchanged light set, SDF and probe grid before the DDGI update is spread across frames (~2x the 0.96 hysteresis' 95 % convergence) SceneRenderer
r.GI.DDGI.ConvergedIntervalint4Once the DDGI inputs have been static for r.GI.DDGI.ConvergedFrames, each frame traces one probe in this many (each probe updates one frame in this many, at most 15); 1 = every probe every frame SceneRenderer
r.GI.DDGI.Hysteresisfloat-1.0fSteady-state temporal blend weight of the DDGI probe atlas, in the perceptual space the blend runs in. Lower converges faster and traces noisier; -1 = the 0.96 default (~73 frames to 95% on its own). r.GI.DDGI.React is what shortens it while a change is actually happening SceneRenderer
r.GI.DDGI.Reactfloat-1.0fHow sharply a DDGI probe texel shortens its temporal blend when the radiance arriving at it actually changes (per unit relative luma delta above the noise floor of the per-texel change tracker). Without it the blend is a fixed time constant, so a light switching on takes as long to arrive as a 1% drift. 0 = fixed hysteresis (legacy A/B), -1 = tier default SceneRenderer
r.GI.DDGI.Relocateint1Nudge each DDGI probe out of geometry along the SDF gradient before it traces: 1=on (default), 0=probes stay on the lattice (A/B — a probe sitting in a wall poisons its whole interpolation cell) SceneRenderer
r.GI.Denoiseint-1GI/reflection denoise mode: -1=tier value, 0=off (raw probe field composited 1:1 — debug/bisect), 1=SVGF-lite (velocity reprojection + disocclusion mask + variance-guided a-trous after temporal) SceneRenderer
r.GI.DenoiseCompositeTapsint3Taps of the filtering GI composite (the full-resolution upsample into the HDR): 5 = 5x5, 3 = 3x3 a-trous over the same footprint SceneRenderer
r.GI.DenoiseHalfResint11 = run the SVGF temporal and a-trous passes at half resolution and upsample in the filtering composite (r.GI.DenoiseIterations 2 only), 0 = full resolution (A/B) SceneRenderer
r.GI.DenoiseIterationsint2SVGF a-trous iteration count including the filtering composite (2 or 3). Default 2: measured pixel-equal to 3 on the DDGI room once the variance-guided kernel runs AFTER temporal accumulation, and it keeps the SVGF chain at legacy cost; 3 = the wider (1,2,4) kernel for content that needs it SceneRenderer
r.GI.EmissiveLightsint1Inject emissive meshes as analytic lights into the DDGI/radiance-cache light list so small/thin emitters that the 0.25 m voxel albedo quantizes away still contribute bounce light. 1=on (default), 0=voxel-emissive only (A/B) SceneRenderer
r.GI.EmissiveLights.RangeScalefloat3.0fAttenuation range of an injected emissive light as a multiple of the mesh bounds radius (clamped to bounds+1 m minimum). SceneRenderer
r.GI.EmissiveLights.Scalefloat1.0fRadiance scale on injected emissive-mesh lights (emissiveColor * emissiveStrength * scale). Tune down if large emitters over-brighten against their voxel-baked emissive term. SceneRenderer
r.GI.FarCascadeScaleint4Cell of the far GI cascade relative to the near one: 2 = a window twice the near one (64-cell grid at 0.25 m: 32 m), 4 = four times (64 m) at a coarser far field. The near window stays as it is; rays past it march the far field instead of returning sky SceneRenderer
r.GI.FinalGatherint-1GI final gather architecture: -1=tier value (Low/Medium=legacy, High/Epic=screen probes), 0=legacy per-pixel world-probe sampling (DdgiSample), 1=screen-space probe gather (16px tiles + adaptive 8px, SDF-traced, filtered between probes — no probe lattice) SceneRenderer
r.GI.FoliageMinHeightfloat1.0fShortest foliage (unscaled mesh height, metres) that enters the GI distance field. Grass clumps stay out: a field of them would fill the cells above the ground with solid SceneRenderer
r.GI.HWRTGatherint-1Hardware ray-traced screen-probe final gather — a ray-query variant of the screen-probe trace casts each gather ray at the resident scene TLAS instead of sphere-marching the SDF cascade, then shades the hit from the SAME radiance cache (incl. the r.GI.NearCascade fine cascade), falling back to the flat instance record where the cache is invalid and to sky x SkyScale on miss. Removes SDF quantization from the near-field gather. Importance sampling + MIS integrate + SVGF are unchanged (only the trace backend differs). The Epic and Cinematic rows enable Options.GiHwrtGather; needs the TLAS and falls back to the SDF screen-probe trace (logged once with the reason) when ray query is unavailable. -1=tier value (default), 0=SDF trace, 1=HWRT gather on any tier that runs the screen probes SceneRenderer
r.GI.ImportanceSampleint1Steer each screen probe's gather rays toward the previous frame's bright octahedral irradiance (the IrrHist guide, already SVGF/temporally smoothed) instead of the uniform octahedral texel set. Each anchor ray inverts the guide's luminance CDF (+ a uniform floor so newly-lit directions are never starved) at a stratified R2 position; the sampled direction + a uniform-relative MIS weight are stored per ray and the integrate pass reconstructs an unbiased cosine-weighted mean — concentrating rays where light is drops variance at equal ray count. Adaptive probes (unstable slots) always sample uniformly. 1=on (default); 0=uniform octahedral (A/B). Requires GiFinalGather; inert on the first frames until the guide history is valid SceneRenderer
r.GI.ImportanceSample.Floorfloat0.5fUniform floor fraction folded into the importance guide pdf (per-cell luminance floor = Floor x mean guide luminance). ~Floor/(1+Floor) of the probability mass stays uniform so freshly-lit directions the guide has not seen yet are still sampled and can enter the temporal history. 0 = pure luminance-proportional (starves new lights), higher = closer to uniform SceneRenderer
r.GI.LogVerboseint0Per-scroll/per-gather GI telemetry (SDF scroll, cascade scroll, DDGI probe scroll, async gather consume): 0=off, 1=on SceneRenderer
r.GI.NearCascadeint1An optional FINER near radiance cascade for reflection HITS — a second RGBA16F 64^3 cache re-lighting the coarse SDF/albedo at half the near cell (r.GI.NearCascade.Cell, default 0.125 m) over a dim*cell (8 m) window centered on the camera. SdfReflect + RTReflections sample it first at the hit, so near mirror/glossy reflections read the lit surface at 2x the 0.25 m voxel resolution, falling back to the existing cascades outward. Epic-only (the preset row enables Options.GiNearCascade; this cvar gates it within Epic). 1=on (default at Epic); 0=off (A/B). ~2 MB at Epic, zero elsewhere SceneRenderer
r.GI.NearCascade.Cellfloat0.125fThe finer near radiance cascade's cell size in world units (default 0.125 m = half the 0.25 m near clipmap). The window extent is dim*cell (8 m at 64^3), so a smaller cell sharpens reflections over a smaller near volume. Clamped to [0.03125, 0.25] SceneRenderer
r.GI.NeuralCacheint0Neural irradiance cache: 1 = the GI buffer's indirect diffuse comes from a hash-grid + MLP trained online from one-bounce rays traced off the G-Buffer every frame (NRC-style), instead of the DDGI field / screen-probe gather; 0 = off SceneRenderer
r.GI.NeuralCache.Emafloat0.9fDecay of the exponential moving average of the weights the per-pixel query reads (0 = the raw weights; higher is steadier and slower to follow a change) SceneRenderer
r.GI.NeuralCache.GridLearningRatefloat0.02fAdam learning rate of the neural cache's hash-grid features SceneRenderer
r.GI.NeuralCache.LearningRatefloat0.003fAdam learning rate of the neural cache's MLP weights SceneRenderer
r.GI.NeuralCache.Samplesint8192Training rays a frame for the neural irradiance cache (1024..65536) SceneRenderer
r.GI.ProbeTraceStepsint-1Sphere-march step cap for DDGI world-probe rays (far cascade adds +1/3): -1=tier value SceneRenderer
r.GI.RadianceBlendfloat0.5fFraction of the PREVIOUS radiance-cache bake a cadence bake keeps while the lighting is still converging. The cache is a step input to reflections and the screen-probe gather, so a bake that lands the whole change at once pops; keeping part of it turns the cadence into a geometric ramp. 0 = legacy hard replace, 0.5 (default) = halve every tick. The first bake, a geometry edit and the idle refresh always replace SceneRenderer
r.GI.RadianceDirtyint1Dirty-region radiance-cache rebake: 1 = light-hash gated (full bakes only during the post-change convergence window + a slow heartbeat; toroidal scrolls re-bake just the exposed slabs), 0 = legacy full-volume bake every GiRadianceInterval frames (A/B) SceneRenderer
r.GI.RadianceHeartbeatSlicesint4How many interleaved phases the idle radiance-cache refresh is split into. Outside the convergence window the cache drifts against the probe field; refreshing the whole volume in one dispatch is a hard discontinuity roughly once a second. Each slice re-bakes 1/N of the voxels on a diagonal phase pattern, N times as often, so a trilinear fetch always mixes refreshed and retained voxels. 1 = legacy single full refresh SceneRenderer
r.GI.RadianceIntervalint-1Frames between surface radiance-cache rebuilds: -1=tier value, 1=every frame SceneRenderer
r.GI.RayTerminateCacheint1A screen-probe ray with no NEAR hit inside a small fine-march budget terminates into the far-cascade world radiance cache — a bounded coarse march of the far SDF, shaded from the far radiance cascade (which already carries multibounce via the DDGI probe feedback) — instead of fine-marching the full clipmap chain. Bounds the fine-step cost AND gives cache-fed near-infinite bounce. The far cache is coarse: an accepted bias for the far/indirect tail. 1=on (default); 0=full-chain march (A/B). Only active when a far cascade exists (fitting scenes run a single cascade in either SDF mode; non-fitting baked scenes composite a far cascade too, so this is live on cooked content) SceneRenderer
r.GI.ReflectTraceStepsint-1Sphere-march step cap for the SDF reflection leg (far cascade adds +2/5): -1=tier value SceneRenderer
r.GI.ScreenProbes.Budgetint8192Adaptive screen-probe budget on top of the per-16px-tile anchors (~8k anchors at 1080p): extra 8px probes allocated where a tile spans a depth/normal discontinuity; 0 disables adaptive subdivision SceneRenderer
r.GI.ScreenProbes.HalfRateConvergedint1Trace converged anchor probes on alternate frames in a tile checkerboard, carrying their history forward in between: 0 = every probe every frame SceneRenderer
r.GI.ScreenProbes.HalfRateMinFramesint8History length (frames) an anchor probe needs before the half-rate update may rest it SceneRenderer
r.GI.ScreenProbes.IndirectLaunchint1Launch the screen-probe trace/filter/guide/integrate passes from the live probe count (1) instead of the full probe capacity (0, the A/B reference) SceneRenderer
r.GI.ScreenProbes.Raysint-1Rays traced per screen probe per frame (upper hemisphere of the octahedral set): -1=tier value, else 16..256 (rounded to the octahedral resolution) SceneRenderer
r.GI.ScreenProbes.TemporalAccumint1Per-probe irradiance temporal accumulation: 1 = each anchor screen probe converges to a multi-frame average (kills the tile-coherent Monte-Carlo flicker the downstream full-res SVGF cannot remove — a static floor probe reaches a fixed value), 0 = fresh single-frame integrate (legacy A/B). Anchors only; adaptive probes always integrate fresh SceneRenderer
r.GI.ScreenProbes.TemporalAlphaMinfloat0.01fFloor on a screen probe's per-frame blend weight — the accumulated average never fully freezes, so a slow real change still creeps in even at the history cap SceneRenderer
r.GI.ScreenProbes.TemporalMaxFramesfloat32.0fCap on a screen probe's effective history length (frames). A converged static probe averages this many frames; a radiance-reactive rate shortens it where the traced radiance actually changed so movers do not ghost SceneRenderer
r.GI.ScreenProbes.TemporalReactfloat5.0fHow sharply a screen probe drops its history when the traced radiance changes (per unit relative luma delta above r.GI.ScreenProbes.TemporalReactFloor). Higher = snappier moving-bleed response, lower = smoother SceneRenderer
r.GI.ScreenProbes.TemporalReactFloorfloat0.08fRelative luma change |new - history| / (new + history) a screen probe must see before it shortens its history. Below it the change is treated as ray noise and averaged. At the old 0.2 a light had to change a probe by about 1.5x before the history reacted at all SceneRenderer
r.GI.ScreenProbes.TraceStepsint-1Sphere-march step cap for screen-probe rays (far cascade adds +1/2): -1=tier value SceneRenderer
r.GI.ScreenTracesint1Screen-space first trace leg of the screen-probe gather (the Lumen model): each probe ray FIRST marches the GBuffer depth buffer and shades a hit from the current frame's lit HDR scene color (pre-exposure divided out); only rays that miss, leave the screen or pass behind known geometry continue into the SDF cascade march / HWRT ray query from where the screen march ended. Gives real contact GI and makes dynamic/skinned geometry — present in the depth buffer, absent from the static SDF — occlude and bounce in the gather. 1=on (default at every tier the screen probes run); 0=world-only trace (A/B) SceneRenderer
r.GI.ScreenTraces.Stepsint16Linear depth-march step count of the screen-trace leg (plus a 5-iteration bisection refine on the first crossing). More steps catch thinner on-screen blockers at higher cost; clamped 4..64 SceneRenderer
r.GI.ScreenTraces.Thicknessfloat0.3fDepth-band thickness (world units) a screen-trace crossing must land inside to count as a hit; deeper crossings are treated as silhouette jumps and hand the ray to the world leg. Larger accepts more grazing hits (and more silhouette leaks) SceneRenderer
r.GI.SDFResolutionint-1World-SDF clipmap dimension (cubed): -1 = tier/Options value (Cinematic 128, else 64), else 32..256 (snapped even). Higher = a larger, higher-fidelity GI field at Cinematic cost. Applied live — the field, the radiance cache and the DDGI history rebuild over the following frames. SceneRenderer
r.GI.SkinnedSdfint1Skinned meshes in the GI distance field: 1 = a posed character occludes and bounces light — the runtime voxelizer re-voxelizes the cells around each moved pose, the baked composite places one rigid field per bone; 0 = skinned meshes are left out of the field (the old behaviour) SceneRenderer
r.GI.SkinnedSdfIntervalint2Frames between skinned-mesh updates of the GI distance field (1 = every frame). A pose change waits at most this long to reach the field SceneRenderer
r.GI.SkyScalefloat1.0fScale on probe-miss sky radiance in the DDGI trace — art-directable control over how much sky colour fills shadows outdoors SceneRenderer
r.GI.SurfaceCacheint1GI surface cache (the Lumen mesh-card analogue): 0=off — ray hits shade the flat per-draw voxel albedo; 1=on — static opaque mesh instances are captured into an albedo/normal/emissive/depth card atlas, relit on a budget, and sampled at ray hits with the voxel field as the fallback. The atlas is allocated on the first resident card, so a scene with nothing to card pays nothing; every consumer is bit-identical to the voxel path when it is off SceneRenderer
r.GI.SurfaceCache.AtlasSizeint-1Card-atlas edge in texels (256..4096, snapped down to a power of two); -1 = tier value (1024 up to High, 2048 at Epic+). Three RGBA16F capture targets, one RGBA16F lit target and a D32F depth target are allocated at this size — 1024 costs about 36 MB, 2048 about 144 MB SceneRenderer
r.GI.SurfaceCache.CaptureBudgetint8Card slots re-rasterized per capture event (0 = no limit). This is what bounds the raster spike: a scene that invalidates every slot at once refills over several capture events instead of one, and every slot not yet captured simply has no card, which every consumer already handles SceneRenderer
r.GI.SurfaceCache.CaptureIntervalint8Minimum frames between two card captures. A capture re-rasterizes only the card slots whose content hash moved (resident draw, its transform, its material texture version, the atlas tiles it holds), so a still scene captures once and never again and one moving object costs one instance, not the whole set SceneRenderer
r.GI.SurfaceCache.CardResolutionint-1MAXIMUM texels per card edge (8..256, snapped down to a power of two); -1 = tier value (64 Low/Medium, 128 High, 256 Epic+). A card is sized from its own screen coverage between MinCardResolution and this; the ceiling is what stops one wall the camera stands against from consuming the whole atlas SceneRenderer
r.GI.SurfaceCache.CardsPerInstanceint4Cards one instance may take from its mesh's offline set (1..32). A mesh cooked with a card set covers a concave shape with several oriented boxes instead of one; each card costs a record and up to six atlas tiles, so this is the ceiling that stops one L-shaped building consuming the budget. 1 = the single fitted box the cache used before card sets SceneRenderer
r.GI.SurfaceCache.CoverageStatsint0Card-coverage census: 0 = off, N = sample every Nth pixel of the GBuffer and run the consumers' own card lookup over it, reporting the covered fraction through GetGiCardCoverage(). Debug only — it costs a dispatch and a GPU->CPU readback, and the readback is a few frames latent SceneRenderer
r.GI.SurfaceCache.Instancesint64Maximum mesh instances resident in the card atlas, clamped by the atlas tile count and by the shader's GI_CARD_MAX_INSTANCES ceiling of 256. The resident set is the highest-scoring draws by apparent size, so the cards follow the camera SceneRenderer
r.GI.SurfaceCache.LightSlicesint4Interleaved phases the card relight is spread over (1..16). Each frame relights 1/N of the atlas texels, so a moving light reaches the cache continuously instead of landing as one full-atlas step every N frames. Freshly captured tiles ignore the phase and relight whole, because their texels still hold the previous occupant's radiance SceneRenderer
r.GI.SurfaceCache.MinCardResolutionint16MINIMUM texels per card edge (8..64, snapped down to a power of two, clamped below CardResolution). Also the block edge the relight work list is built in, so lowering it makes that list finer and larger SceneRenderer
r.GI.SurfaceCache.TexelDensityfloat0.0625fCard texels per screen pixel of the card's own world edge. A card is a GI bounce source, not a visible surface, so one texel per sixteen pixels is already finer than the probe grid that reads it — raise it only when card-lit detail is visibly blocky in a mirror SceneRenderer
r.GI.TemporalClampFloorfloat0.15fSVGF temporal variance-clip floor as a fraction of the local mean. The clip half-width never drops below floor*mean, so locally-flat GI/reflection regions keep integrating the designed per-frame jitter instead of the history being crushed to the current frame (visible as shaking). 0 = legacy tight clip SceneRenderer
r.GI.TemporalMaxFramesfloat20.0fSVGF temporal history cap for the GI chain (frames). It stacks on the screen-probe history (r.GI.ScreenProbes.TemporalMaxFrames), so a lighting change has to drain through both; the old fixed 32 on top of 64 there took over 160 frames to reach 90% of a lamp switch SceneRenderer
r.GI.TemporalMinHistoryfloat4.0fSVGF temporal floor on the effective history length for reprojected pixels — movers ease over at least this many frames instead of snapping to the current frame. Disocclusions still restart at 1 SceneRenderer
r.GI.TemporalVelocityScalefloat0.1fSVGF temporal history shortening per pixel of reprojection speed (Neff = N / (1 + scale*velPix)). Lower = smoother motion response, higher = more reactive/raw. Was hardcoded 0.25 SceneRenderer
r.GI.TerrainFoliageint1Terrain and foliage in the GI distance field: 1 = every field window takes the min with the CDLOD terrain's heightfield and with a capsule per tall foliage instance, so both occlude and bounce light; 0 = both are invisible to GI (the old behaviour) SceneRenderer
r.GI.TextureTintint1Multiply the SDF voxelizer's flat per-draw albedo by the material's average albedo-texture color (linear, baked at texture cook / computed at load) so GI bounce, the radiance cache, SDF/RT reflections and screen-probe hits carry the texture's actual tint. 1=on (default), 0=flat legacy base color (A/B). Flipping forces the next SDF rebuild SceneRenderer
r.GI.Translucencyint1Translucency GI: 1=forward transparents (glass/water) sample the DDGI probe field per pixel as their ambient term when DDGI is active (default), 0=flat ambient (A/B) SceneRenderer
r.GiCascadesint2GI clipmap cascades: 2=near window + far cascade, 3=+a third, wider cascade; the far ones are only active when the scene outgrows cascade 0's window. Applies to BOTH SDF builds — the runtime voxelize scroll chain and the baked composite (which fills the coarse window from the same resident baked fields) SceneRenderer
r.GlobalIllumination.EnableForProjectint0Project switch: 1 = this project uses dynamic global illumination (DDGI, screen probes, the GI scene SDF, SSGI, the neural cache). 0 = no scalability tier, device profile or r.* cvar turns it on, and its targets and pipelines are never built RHI
r.GpuCull.ClassicDirectint-1How the classic (non-meshlet) GBuffer path draws GPU-culled candidates: 0 = one indirect draw per candidate off the cull's argument buffer (GPU occlusion decides), 1 = directly from the CPU frustum test (the cull still runs for meshlets), -1 = the backend's RendererCapabilities::CheapPerDrawIndirect decides SceneRenderer
r.GpuDrivenCullint-1GPU compute frustum/Hi-Z cull + indirect draws: -1=code default, 0=off, 1=on SceneRenderer
r.GpuMarkersint1Name every GPU scope for capture tools (PIX / RenderDoc / Nsight / Xcode events): 0=off, 1=on. Independent of r.GpuTimings RHI
r.GpuScene.ClassicSlotsint1Give every non-instanced static draw a stable GPU-scene slot and have the classic G-Buffer, CSM and local-shadow vertex stages read its matrix from the GPU scene instead of the push block: 1 = on, 0 = push the model per draw (A/B) SceneRenderer
r.GpuScene.CompactRunsint11 = pack each live-MDI run's surviving instanced-group commands on the GPU and draw them with one DrawIndexedIndirectCount; 0 = the MultiDraw over every command of the run (A/B) SceneRenderer
r.GpuScene.DirtyUploadint1Write only the changed ranges of the per-frame instance-transform and previous-model pools (each frame-in-flight buffer keeps a CPU copy of what it holds): 1=on, 0=write every buffer whole (A/B) SceneRenderer
r.GpuScene.GeometryPoolBudgetMBint0VRAM the GPU scene's geometry pools may take in total, in MB; they hold a second copy of every bucketed mesh's vertices and indices. 0 = an eighth of the GPU's dedicated memory, clamped to 256..2048 MB SceneRenderer
r.GpuScene.GeometryPoolGrowthint1GPU-scene geometry pools: 1 = add a pool when no existing one fits a mesh, sized for what the current instancing plan still has to admit, within r.GpuScene.GeometryPoolBudgetMB; 0 = one fixed 512K-vertex pool per index width and every mesh past it on per-group draws (A/B) SceneRenderer
r.GpuScene.PlanCacheint1Keep the G-Buffer plan's material/mesh decisions (bindless residency of the material maps, resolved graph pipelines) across frames per primitive and rebuild them only when the material snapshot, the mesh's meshlet state, a plan-wide setting or the bindless table changes: 1 = on, 0 = resolve every draw every frame (A/B) SceneRenderer
r.GpuScene.PrevBySlotint1Keep a previous-frame matrix per GPU-scene slot and have the instanced velocity draw read it through each member's slot: 1 = on, 0 = repack the previous models in member order every frame (A/B) SceneRenderer
r.GpuScene.ShadowRunsint1CSM casters through the GPU scene's buckets: 1 = opaque pool-resident instanced groups (lone draws included under r.GpuScene.SingleDraws) are culled per cascade on the GPU and each run of them draws with one DrawIndexedIndirectCount per cascade; 0 = one instanced draw per group per cascade with every member in it (A/B) SceneRenderer
r.GpuScene.SingleDrawsint1With GPU-driven culling on: 1 = every eligible static draw joins the GPU scene's instanced buckets, a lone draw as a group of one, and the groups are ordered by material so a whole bucket is one count-compacted indirect draw; 0 = only meshes repeated AutoInstancingMinCount times are grouped and lone draws push their model (A/B) SceneRenderer
r.GpuTimingsintskGpuTimingsDefaultRecord per-pass GPU timestamps: 0=off (a scope costs nothing and the per-frame resolve, which blocks on Vulkan, never runs), 1=on. Default on in debug/dev/debuggame, off in profile/release RHI
r.Grid.Spacingfloat0.0fViewport grid minor cell size in world units, overriding Options::GridSpacing. 0 = use the scene/editor value SceneRenderer
r.GTAOint-1Ground-truth ambient occlusion slice: -1=tier value (Medium+ on, Low hard-off), 0=off, 1=on. Scene PostFX settings act within this. SceneRenderer
r.GTAO.Slicesint-1GTAO horizon slices per pixel: -1=tier value SceneRenderer
r.HairStrandsint1Draw hair strands (Hair Strands components) into the G-buffer: 0 = off, 1 = on SceneRenderer
r.HairStrands.Densityfloat1.0fFraction of each groom's render strands drawn (0.05..1): the guides always simulate, fewer children are interpolated and drawn SceneRenderer
r.HDRMaxNitsint1000HDR output: peak luminance in nits used for the highlight rolloff. RHI
r.HDROutputint0HDR display output: 0=SDR, 1=scRGB (RGBA16F linear), 2=HDR10 (RGB10A2 PQ), 3=auto (prefer scRGB). Falls back to SDR when the surface offers no HDR formats. RHI
r.HDRPaperWhiteNitsint200HDR output: luminance in nits that scene value 1.0 (SDR white) maps to. RHI
r.HeightFogint1Exponential height fog from an ExponentialHeightFog actor: 0=off, 1=on SceneRenderer
r.HiZ.LogOcclusionint0Read the GPU occlusion counters back and log, every 300 frames, how many classic draws and instances the Hi-Z pyramid rejected — the measure r.HiZ.Size is judged by. 0=off, 1=on SceneRenderer
r.HiZ.Sizeint256Side of the Hi-Z max-depth pyramid the occlusion culls test against, in texels (128..1024, rounded up to a power of two; read when a renderer initializes) SceneRenderer
r.InstancingPlan.Cacheint1Reuse last frame's instancing groups (which draw joined which group, bucket order) while every draw's key, the moving-body and meshlet flags, the plan switches and the geometry-pool residency are unchanged: 1=on, 0=rebuild every frame SceneRenderer
r.Lighting.Classifyint1Let the GPU pick the deferred-lighting variant per frame from the G-Buffer: 1 = the variant without the extended lobes (anisotropy, clear coat, Substrate, hair, subsurface, cloth, foliage, eye, iridescence) whenever no pixel takes one; 0 = always the full shader; 2 = always the simple one (diagnostic: extended surfaces lose their lobes) SceneRenderer
r.LocalExposureint-1Local exposure override: -1 = use the scene setting, 0 = off, 1 = on SceneRenderer
r.LOD.ErrorPixelsfloat1.0fScreen-space error budget, in pixels, a mesh's coarser LOD may show before the finer one takes over; a mesh whose simplifier recorded its error gets its own coverage boundaries from this, others keep r.LOD1/LOD2 coverage. 0 = always use the global boundaries SceneRenderer
r.LOD1Coveragefloat-1.0fScreen-coverage threshold below which a static mesh drops to LOD1: -1=tier value SceneRenderer
r.LOD1TriangleRatiofloat0.35fTarget triangle ratio for generated LOD1 (fraction of the source mesh, 0..1) AssetSystem
r.LOD2Coveragefloat-1.0fScreen-coverage threshold below which a static mesh drops to LOD2: -1=tier value SceneRenderer
r.LOD2TriangleRatiofloat0.12fTarget triangle ratio for generated LOD2 (fraction of the source mesh, 0..1) AssetSystem
r.LODCrossfadeTimefloat0.2fDithered LOD crossfade window in seconds: during a switch both levels draw with complementary screen-door masks; 0 = instant switch SceneRenderer
r.LogGpuScopesint0Log per-scope GPU averages (all nesting depths, amortized per frame) every N frames (0=off) — per-pass GPU budget evidence GameHost
r.LogGpuTimingsint0Log resolved GPU pass timings every N frames (0=off) — headless perf profiling until Snowcap lands GameHost
r.LowLatencyint0Low latency: 0=off, 1=on, 2=on+boost. Drives NVIDIA Reflex, AMD Anti-Lag 2 or Intel XeLL, whichever this GPU runs (see r.LowLatency.Backend); a live DLSS-G or XeSS-FG keeps it on RHI
r.LowLatency.Backendint0Low-latency runtime: 0=auto (whichever this GPU runs), 1=NVIDIA Reflex, 2=AMD Anti-Lag 2, 3=Intel XeLL; an unsupported pick falls back to auto RHI
r.Material.ClearCoatint1Clear-coat second specular lobe (opaque deferred + forward translucent). 0=off (bit-identical to a coatless material), 1=on SceneRenderer
r.Material.MaxStaticPermutationsint32Most shader permutations one material's static switches may produce (2^switches). A graph past it fails to compile with the switch named. AssetSystem
r.MaterialMipBias.Autoint1Bias every material texture sample by log2(render/output) while a temporal upscaler reconstructs the output grid (one level more for FSR/DLSS/XeSS, per their SDKs): 0=off, 1=on SceneRenderer
r.MaterialMipBias.Minfloat-2.0fFloor of the automatic material mip bias: past -2 the texture cache thrashes for detail the resolve cannot hold SceneRenderer
r.MaterialMipBias.Offsetfloat0.0fExtra material texture LOD bias in mip levels, added on top of the automatic one: negative = sharper SceneRenderer
r.MaterialProxyReuseint11 = reuse a material's render snapshot while its state version is unchanged; 0 = copy every material every frame (A/B) SceneRenderer
r.MaxAnisotropyfloat-1.0fSampler max anisotropy ceiling for newly created samplers: -1=tier value SceneRenderer
r.MaxImportTextureSizeint0Default cap for model-import textures larger than this (power-of-two box filter); 0 = unlimited. A texture's own Max Size in its .mdfmeta overrides it AssetSystem
r.MegaLightsint-1MegaLights-style stochastic many-shadowed-light sampling for the local shadow-casters past the atlas budget (needs clustered lighting): -1=tier value (Epic+), 0=off, 1=on SceneRenderer
r.MegaLights.CheapModeint-1Cheap screen-space fallback shadow for shadow-casting local lights denied an atlas tile while MegaLights is off (a short contact-style depth march toward the light): -1=tier value (High/Medium on), 0=off, 1=on SceneRenderer
r.MegaLights.Denoiseint1MegaLights spatiotemporal denoise: 0=raw stochastic result (A/B only), 1=temporal reproject + variance-guided spatial filter SceneRenderer
r.MegaLights.EnableForProjectint0Project switch: 1 = this project uses MegaLights stochastic many-light shadows. 0 = shadowed local lights past the atlas take the cheap screen-space march RHI
r.MegaLights.FireflyClampfloat8.0fMegaLights per-sample luminance clamp bounding one ray's contribution before the denoiser; higher admits brighter spikes SceneRenderer
r.MegaLights.Samplesint-1Local lights importance-sampled + shadow-traced per pixel per frame (1..4): -1=tier value SceneRenderer
r.Mesh.CompactIndicesint1Upload a mesh's indices at 16 bits when it addresses at most 65 536 vertices: 1 = on (half the index memory and bandwidth), 0 = always 32-bit Renderer
r.Mesh.DynamicPoolBudgetMBint0VRAM the dynamic mesh pool may take in total, in MB; a mesh past it is created with private buffers instead. 0 = a quarter of the GPU's dedicated memory, clamped to 256..3072 MB Renderer
r.Mesh.UploadBudgetKBint4096Bytes of dynamic-mesh geometry (GPUMesh::CreateLitPooled) the frame's single upload batch may carry, in KB; what does not fit stays queued and goes out first next frame. A 32-voxel chunk remesh is a few hundred KB, so the default carries well over a hundred a second at 60 fps. 0 = unlimited Renderer
r.Mesh.UploadMaxInFlightint3Upload batches the dynamic mesh pool keeps in flight before it holds the queue: the RHI's async-upload slots are shared with texture streaming, and a request past them would degrade to a blocking submit Renderer
r.MeshDrawCommands.Cacheint1Persistent static draw commands per primitive (entity, submesh): built once and reused while mesh, material, transform and flags are unchanged, with the material snapshot revalidated instead of looked up and the LOD state reached without a lookup; LOD and visibility stay per frame. 1 = on, 0 = rebuild every command every frame (A/B) SceneRenderer
r.MeshDrawCommands.Statsint0Log [MeshDrawCommands] built/reused/re-snapshotted static draw commands every N scenes: 0 = off SceneRenderer
r.Meshlet.AsyncLayoutsint1Build a mesh's meshlet page layout on a job worker the first time the pool is asked for it, drawing the mesh through the classic path until it is ready (1); 0 builds it inside the request on the render thread (A/B). SceneRenderer
r.Meshlet.ComputeFallbackint0Meshlet compute fallback for GPUs without mesh shaders: the batched material runs are culled per cluster by compute into one triangle list and drawn with one indexed-indirect draw each, the vertex stage pulling from the meshlet pool. 0 = off (no mesh shaders keeps the classic raster path), 1 = on where mesh shaders are missing, 2 = forced on every GPU (A/B against the mesh-shading path) SceneRenderer
r.Meshlet.Displacementint1Nanite-style displacement: a static uber material with a Height Map and Displacement > 0 moves its meshlet-path vertices along their normals in the mesh stage: 0 = off, 1 = on SceneRenderer
r.Meshlet.GBufferBatchint1Draw every static meshlet GBuffer draw that shares a material in ONE dispatch over a flattened task-group list (per-draw transforms, cluster ranges and visibility slots in a record buffer): 1 = on, 0 = one push + dispatch per draw SceneRenderer
r.Meshlet.PageKBint(int)(MeshletPool::kDefaultPageBudgetBytes / 1024)Target size in KB of one meshlet streaming page (its vertex slice + remap + packed triangles; cluster records stay reserved). SceneRenderer
r.Meshlet.PageOpsPerFrameint40Ceiling on meshlet page uploads/releases per frame. SceneRenderer
r.Meshlet.Pagingint1Cluster paging for the meshlet pool: keep only the pages the DAG cut can reach resident (1) or hold every mesh whole (0). SceneRenderer
r.Meshlet.PoolBudgetMBint0VRAM the meshlet cluster pool may grow to, in MB: it starts at about 63 MB and doubles the arena a level ran short of whenever it is full of meshes still on screen, and never grows into the last tenth of the GPU's memory budget; 0 = a sixteenth of the GPU's dedicated memory, 64 to 1024 MB; 64 or less keeps the starting pool (A/B). SceneRenderer
r.Meshlet.ShadowBatchint1Draw every static meshlet CSM caster of a cascade in ONE mesh-shading dispatch over a flattened task-group list (1, default) instead of one dispatch per caster per cascade (0). Skinned casters keep their own dispatch either way SceneRenderer
r.Meshlet.ShadowLodErrorfloat-1.0fCluster-DAG cut budget for meshlet CSM casters, in SHADOW-MAP TEXELS of allowed projected error (a cascade's projection is orthographic, so this does not vary with distance). -1 = use r.MeshletLodError; larger = coarser casters SceneRenderer
r.Meshlet.Shadowsint-1Render meshlet-eligible CSM casters (static + skinned) through the depth-only mesh-shading path with a per-cascade cluster-DAG LOD cut + per-cluster light-frustum culling: 0=off, 1=on, -1 = follow r.MeshletGBuffer. Requires VK_EXT_mesh_shader; casters fall back to the raster shadow path otherwise SceneRenderer
r.Meshlet.Skinnedint-1Route skeletal meshes through the mesh-shading GBuffer path (compute pre-skin into a per-instance vertex buffer + per-cluster bounds refit each frame): 0=off, 1=on, -1 = follow r.MeshletGBuffer. Requires VK_EXT_mesh_shader; skinned draws stay on the GPU-skinned raster path otherwise SceneRenderer
r.Meshlet.SwRasterint0Software-rasterize sub-pixel meshlet clusters in compute into a visibility buffer, resolved back into the GBuffer by one screen pass for every table-resident material plus one per material that needs its own descriptor set, instead of emitting them as mesh workgroups: 0=off, 1=on. Needs the meshlet path (VK_EXT_mesh_shader / SM6.5) and both MeshletSwRaster + MeshletSwResolve shipped SceneRenderer
r.Meshlet.SwRaster.IndirectLaunchint1Size the software rasterizer's depth and payload launches to the clusters the task stages appended (an indirect dispatch the GPU fills) instead of to every cluster they tested: 1 = indirect, 0 = the tested-count upper bound SceneRenderer
r.Meshlet.SwRasterDrawPixelsint(int)FMeshletEligibility::kSwDefaultDrawCeilingPixelsPer-DRAW ceiling on the software path: a draw whose whole bounding sphere projects wider than this keeps every cluster on hardware. Clusters never project larger than the draw holding them, so a big draw would buy a resolve screen pass for a handful of software pixels. 0 = no ceiling SceneRenderer
r.Meshlet.SwRasterPixelsint(int)FMeshletEligibility::kSwDefaultThresholdPixelsThe hardware/software split: a surviving cluster whose projected screen diameter is at or under this many pixels goes to the compute rasterizer (its ~124 triangles are then at or under a pixel each). Clamped to 1..127 — the threshold rides 7 free bits of the meshlet push block's CullFlags SceneRenderer
r.MeshletGBufferint-1Mesh-shading GBuffer path for meshes with import-built cluster DAGs (screen-space-error LOD cut + per-meshlet frustum/cone/Hi-Z cull + residency streaming): 0=off, 1=on, -1 = scalability tier default (Epic+). Requires VK_EXT_mesh_shader; without it every draw keeps the raster path and the fallback reason is logged once SceneRenderer
r.MeshletIdleFramesint600Evict resident clusters whose mesh has not drawn for this many frames, so a scene change or a walked-away region releases pool space and its mesh. 0 = keep until the budget forces it out SceneRenderer
r.MeshletLodErrorfloat1.0fCluster-DAG LOD cut threshold in screen pixels: a meshlet renders when its projected simplification error is under this while its parent's is not; 0 = full detail (leaves only) SceneRenderer
r.MeshletOcclusionCullint1Per-meshlet Hi-Z occlusion in the task shader (two-phase, needs r.GpuDrivenCull occlusion feeding the pyramid): 0=off, 1=on SceneRenderer
r.MeshletPoolBudgetint0Resident cluster budget in meshlets; meshes past it evict the least-recently-drawn and stream back in on demand. 0 = the pool's full capacity SceneRenderer
r.MeshletResidencyStatsint0Log [MeshletResidency] admissions/evictions/rejections and resident bytes every N frames: 0=off SceneRenderer
r.Meshletsint-1Build meshlet clusters at import for the mesh-shading path: -1=code default (ON when the GPU has mesh shaders), 0=off, 1=on AssetSystem
r.MeshletStatsint0Log [Meshlet] task-cull telemetry (tested/drawn/killed per test) every N frames: 0=off SceneRenderer
r.MeshLODint-1Coverage-based discrete mesh LOD (terrain chunks carry LOD chains): -1=code default, 0=off, 1=on SceneRenderer
r.MeshLODBiasint-1LOD bias in levels: every LOD boundary moves this many levels closer to the camera (coverage is scaled by the LOD1->LOD2 ratio per level), so coarser LODs come sooner while a close object keeps LOD0: -1 = use the active scalability tier, >=0 = explicit bias SceneRenderer
r.MeshRenderProxiesint1Mesh gather walks the persistent render proxies, rebuilt only on a structural ECS change (1, default), or looks every entity's components up again each view (0, for A/B) SceneRenderer
r.MeshStreamingint1Stream static-mesh LOD residency: 1 = register LOD-carrying meshes with the streaming manager in a host that drives it (evict/restore per level, default), 0 = everything stays resident AssetSystem
r.MeshStreaming.PoolSizeMBint0Streaming mesh residency budget in MB (0 = unlimited). The least-recently-drawn meshes coarsen first when the resident pool exceeds it. GameHost
r.Metal.CaptureFrameint0Capture the next GPU frame to a .gputrace under <cwd>/Captures (open in Xcode). Needs MTL_CAPTURE_ENABLED=1. Resets to 0 after the capture MetalRHI
r.Metal.MeshShadersint0Metal mesh shaders from Metal Shader Converter metallib blobs: 1=report SupportsMeshShaders when the device has mesh support, 0=vertex fallback. Experimental — Mac-unverified MetalRHI
r.Metal.MTL4int0Metal 4 command model: 1=MTL4 command queue + per-slot command allocators + argument-table binding when the runtime supports it (macOS 26), 0=classic MTLCommandBuffer path. Mac-unverified dual path — see Documentation/ROADMAP.md §12.7 (was plan item 12) MetalRHI
r.MetalFX.Denoisedint1MetalFX resolve variant when the renderer supplies the GBuffer aux inputs (diffuse albedo / normals / roughness): 1=MTLFXTemporalDenoisedScaler when the device supports it (denoise + upscale in one pass — the RT-effects path), 0=always the plain MTLFXTemporalScaler MetalRHI
r.MetalFX.Subsumeint0When the MetalFX denoised resolve runs, let it own denoising: skip the per-effect stochastic temporal filters (RTAO/RT-shadow accumulation, MegaLights denoise, GI SVGF) and feed the raw signal. 0=keep the engine's filters (default), 1=hand denoising to MetalFX SceneRenderer
r.MinScreenCoveragefloat-1.0fSmall-object cull: a static mesh whose world sphere covers less than this fraction of the vertical FOV is dropped from every pass: -1=tier value, 0=off SceneRenderer
r.MotionBlurObjectint1Per-object motion blur: 1=sample the velocity prepass in the MB pass when available (default), 0=camera reprojection only SceneRenderer
r.OcclusionCullint-1Hi-Z occlusion cull of main-view static meshes against last frame's depth pyramid: -1=tier value, 0=off, 1=on SceneRenderer
r.OITint0Weighted-blended order-independent transparency for the standard translucent path (water keeps the sorted pass). 0=off (sorted alpha), 1=on. SceneRenderer
r.ParallelRecordint-1Parallel GBuffer/shadow/velocity command recording into secondary CBs: -1=code default, 0=off, 1=on SceneRenderer
r.ParallelRecordMinDrawsint-1Minimum draw count before parallel recording engages: -1=code default (64), N=override (0 forces it on tiny scenes — debug) SceneRenderer
r.ParallelSubmitint1Parallel static-mesh visibility/LOD resolve at EndScene (bounds + frustum + coverage fan out to workers, LOD hysteresis stays serial in submit order): 0=legacy per-submit path, 1=on SceneRenderer
r.PathTracer.Denoiseint1Edge-avoiding a-trous denoiser over the path-tracer accumulation: 1=on (default — a restarted accumulation is 1 spp and reads as noise without it), 0=off (raw reference, byte-identical, for comparisons). SceneRenderer
r.PathTracer.Enableint0Progressive path-traced reference render: 0=off, 1=on. Forces the tracer on regardless of the editor view mode (offline/screenshot capture); the 'Path Tracing' view mode enables it in the editor without this flag. Session only: no config file applies it. Transient. SceneRenderer
r.PathTracer.FireflyClampfloat256.0fPer-sample radiance clamp before accumulation, in exposed units (the clamp scales by 1/pre-exposure like every other radiance ceiling); 0 = unbounded SceneRenderer
r.PathTracer.FurnaceSkyfloat0.0fWhite-furnace check: > 0 replaces the scene's sky with a uniform one of this radiance and drops the sun and the local lights, so a convex object of albedo a must converge to a times it and never above it (energy conservation); 0 = the scene's own lighting SceneRenderer
r.PathTracer.MaxBouncesint8Maximum path bounces per camera ray (1..32). More bounces resolve deeper indirect light. SceneRenderer
r.PathTracer.MaxSamplesint4096Samples per pixel after which accumulation stops and the converged image is held (0 = never stop). Without a limit the tracer kept spending the GPU on an image that had stopped changing. SceneRenderer
r.PathTracer.SamplesPerFrameint1Camera path samples accumulated per pixel each frame (1..16). Higher converges faster but costs more per frame. SceneRenderer
r.PathTracer.Texturesint1Path tracer hits sample the material's albedo, normal and metallic-roughness maps at the hit UV (needs the bindless table and 64-bit shader integers): 1 = on, 0 = each instance's average colour, vertex normal and scalar roughness/metallic, the old flat shading (A/B) SceneRenderer
r.Physics.AutoColliderint1Give a freshly placed mesh the collider its mesh asks for — the authored .mmeshmeta setup, else a primitive fitted to the mesh bounds. 0 places meshes with no collider at all Game
r.PipelineCacheSaveIntervalint60Seconds of pipeline-creation quiet before the VkPipelineCache is flushed to disk mid-session (crash-safe persistence): 0 = only on clean shutdown VulkanRHI
r.PointCloud.ComputeRasterint1Rasterise the scan layer in compute (one thread a point, GPU LOD, a 64-bit atomic min per pixel) where the device has 64-bit buffer atomics: 0 = always the splat draw SceneRenderer
r.PointCloud.Densityfloat1.0fPlayer scan density, 0.5..1.5: below 1 the renderer draws a stable thinned subset, above 1 the scan loop fires more rays per shot SceneTypes
r.PointCloud.EDLint1Eye-dome lighting on the scan layer: darkens a splat by how far its neighbours sit in front of it, so edges and creases read without any light SceneRenderer
r.PointCloud.EDLRadiusfloat1.4fEye-dome lighting sample radius in layer pixels SceneRenderer
r.PointCloud.EDLStrengthfloat0.7fEye-dome lighting strength (Boucheny scale; 1 is a visible edge, 0 off) SceneRenderer
r.PointCloud.Ephemeral.Capacityint-1Points the decaying half of a scanned cloud may hold before the oldest is evicted; -1 = the cloud's own value, 0 = drop dynamic hits entirely Game
r.PointCloud.Ephemeral.Lifetimeint-1How long an ephemeral point lives, in ephemeral ticks (60/s); -1 = the cloud's own value Game
r.PointCloud.FlashLimitint1Limit how fast the scan layer's mean luminance may rise (photosensitivity); 0 composites every reveal at once SceneRenderer
r.PointCloud.FlashRiseSecondsfloat0.15fShortest time over which the scan layer may rise by r.PointCloud.FlashStep; never below 0.1 s, the minimum a reveal may take SceneRenderer
r.PointCloud.FlashStepfloat0.1fLargest rise of the scan layer's mean linear luminance (0..1 of the screen at full white) allowed per r.PointCloud.FlashRiseSeconds SceneRenderer
r.PointCloud.GpuStoreint0Keep the persistent scan cloud in a GPU hash table (insert, dedup and scan-memory fade on the GPU, drawn by the compute rasteriser) instead of the CPU accumulator chunks; needs 64-bit buffer atomics. A save reads the store back and writes it with the CPU chunks. Off by default SceneRenderer
r.PointCloud.GpuStoreCullint1GPU point store: compact the live, in-view slots and rasterise only those through an indirect launch, instead of walking every slot of the table. 0 = walk the whole table. SceneRenderer
r.PointCloud.GrowSplatsint0Grow Gaussian splats from the accumulated scan on every point cloud (project option, off by default); a cloud's own Grow Splats turns them on for that cloud alone SceneRenderer
r.PointCloud.HoleFillint1Fill a scan-layer pixel no splat covered when its neighbours on opposite sides were covered on two axes (a gap inside a surface, never its outline) SceneRenderer
r.PointCloud.LodDistancefloat24.0fCompute rasteriser LOD: past this view distance (m) a page keeps only the (distance ratio)^2 prefix of its rank-ordered points; 0 keeps every point SceneRenderer
r.PointCloud.LodMinFractionfloat0.15fCompute rasteriser LOD: the smallest share of a page's points kept at any distance (0.01..1) SceneRenderer
r.PointCloud.MaxPointSizefloat12.0fLargest splat diameter in output pixels whatever the component asks for; the scan's photosensitivity ceiling SceneRenderer
r.PointCloud.Paletteint0Scan palette: 0 authored, 1 red-green safe, 2 blue-yellow safe, 3 monochrome with a splat shape per material family SceneRenderer
r.PointCloud.SizeScalefloat1.0fPlayer scale on every splat's size, 0.75..2; still capped by r.PointCloud.MaxPointSize SceneRenderer
r.PointCloud.Splatsint1Draw the Gaussian splats grown from scans on clouds with Grow Splats on: 0 = points only SceneRenderer
r.PointCloud.Splats.Maxint65536Most splats one cloud draws a frame (the nearest are kept); the back-to-front sort runs on the CPU each frame SceneRenderer
r.PointCloud.StreamModeint0Streamer mode: splats x1.75, density x0.75, no shrink-on-fade, and half the flash limiter's rise step, so a compressed video stream keeps the scan readable SceneTypes
r.PostProcessMaterialstring""Path of a PostProcess-domain .mat material evaluated as a fullscreen pass after tonemapping (empty = the scene/volume setting). SceneRenderer
r.PreExposureint1Pre-expose scene color: HDR targets store radiance scaled by the previous frame's exposure (clamped), tonemap divides it back out — keeps RGBA16F in range when physical light intensities (a 100k-lux sun) exist: 0=off, 1=on SceneRenderer
r.PSOCache.Prewarmint1Prewarm pipelines from the bundled PSO cache at game startup (populates the driver and backend pipeline caches before the first frame) RHI
r.PSOCache.Recordint-1Record created pipelines into <project>/Saved/PsoCache/PsoCache.mdfb: -1=auto (project open, non-shipping), 0=off, 1=on RHI
r.PSOPrecache.AsyncGraphint1Compile material-graph pipelines on job workers: 1 = the draw keeps the material's uber (fallback) pipeline until its own PSO is built, 0 = compile synchronously on first use (the old first-sight hitch) SceneRenderer
r.Qualityint-1Scalability preset: -1=code default, 0=Low, 1=Medium, 2=High, 3=Epic, 4=Cinematic (flips the render-feature Options bundle + the FScalabilityTiers numeric row) SceneRenderer
r.RayTracing.EnableForProjectint0Project switch: 1 = this project uses hardware ray tracing (RT reflections, RT shadows, RTAO, the HWRT GI gather, the path tracer, DLSS Ray Reconstruction). 0 = no TLAS is built and no RT pipeline compiles RHI
r.RDG.AsyncComputeint1Global async-compute switch: 0 = everything inline; 1 = passes and features that opt in (r.GI.AsyncCompute, ...) run on the async-compute lane where the backend has a real second queue (D3D12, Vulkan), forked as early and joined as late as their dependencies allow, and never beside an ALU-heavy pass; 2 = additionally force every compute-shaped graph pass onto the lane (testing; read when a graph compiles). D3D11 and Metal-without-lane record inline whatever this says RHI
r.RDG.BatchBarriersint1Issue each render-graph pass's image transitions as one barrier call (D3D12 one ResourceBarrier, Vulkan one vkCmdPipelineBarrier2, split where an image repeats) instead of one call per resource: 0=off, 1=on RHI
r.RDG.PlacedAliasingint0Back render-graph transients with placed images packed into shared heaps, so resources of different formats and sizes with disjoint lifetimes share memory (D3D12 and Vulkan; other backends keep the exact-match alias groups): 0=off, 1=on RHI
r.RDG.PostChainint1Record the head and tail of the post chain on the frame graph: the reactive masks, the temporal upscaler hand-off, the post-process material and the Final blit, with their barriers derived from declared reads and writes. 0 = the old path, each pass outside the graph with hand-placed transitions. Takes effect at the next graph rebuild SceneRenderer
r.RDG.SplitBarriersint0Split render-graph transitions of transients: begin right after the last pass that used the resource, end right before the next, so the GPU retires the transition behind the passes in between (D3D12 BEGIN_ONLY/END_ONLY, Vulkan events; other backends issue the whole transition at the end): 0=off, 1=on RHI
r.RDG.TransientViewTargetsint1Allocate the frame-local post targets (depth-of-field CoC, motion-blur velocity and tile maps, the bloom chain and, with r.RDG.PostChain, the reactive-mask pair) as frame-graph transients that alias with other scratch of the same shape, instead of persistent per-view images. 0 = persistent images imported into the graph. Takes effect at the next graph rebuild SceneRenderer
r.ReflectionProbes.Bakeint1Bake captured reflection probes to the DerivedDataCache and reload them on scene open instead of re-capturing (mbt cook packages them so shipped games skip runtime capture). 1=on (default), 0=always capture at runtime SceneRenderer
r.Reflections.Continuationint1Screen-trace-first reflections: 1=one ray per pixel — screen march, then the SAME ray continues into the SDF/RT world trace where the screen leg is inconclusive (default), 0=legacy independent traces blended by confidence (A/B) SceneRenderer
r.Reflections.MirrorReprojectfloat0.0fRoughness ceiling for mirrored-point temporal reprojection: at or below it a screen-leg hit fetches its reflection history from where the REFLECTED point was last frame instead of where the surface was, which is what the reflected image actually tracks. OFF by default: the history's depth/normal validity is keyed to the SURFACE, so a mirrored colour fetch is validated against the wrong pixel, accumulation never converges and the per-frame trace noise shows through as speckle — worse than the lag it removes. Keyed validity needs a reflection hit-distance channel in the moments history. 0 = surface reprojection only SceneRenderer
r.Reflections.Translucentint1One-ray reflections on forward translucent surfaces (High/Epic, SDF radiance cache + sky miss; reflective materials only): 0=off (env/none), 1=on SceneRenderer
r.Reflections.WorldLegConfidencefloat0.5fConfidence the SDF world leg reports at mirror roughness, relative to the screen leg (ramps to 1 at the roughness cutoff). The world leg returns cell-quantised cache radiance where the screen leg returns real scene colour; below 1 the resolve leans back on env specular across the handover instead of cutting to a blurrier source at full strength. 1 = legacy equal confidence SceneRenderer
r.Renderer.DeferredReleaseint1Create, destroy and resize scene views, resize the primary view's output and reallocate the volumetric fog grid and cloud targets without draining the GPU: what they drop goes through the backends' deferred-delete queues (or SubmitDeferredRelease) once the frames that read it have retired. 1=on, 0=WaitIdle first (A/B) SceneRenderer
r.RenderScalefloat-1.0fInternal render resolution scale (0.25..1.0): -1=tier value (upscaler policy may also drive it) SceneRenderer
r.RT.BLASCompactionint1Copy each freshly built BLAS into a right-sized allocation using the driver's post-build compacted size: 0=off 1=on RHI
r.RT.BLASCompaction.Budgetint8Maximum BLAS compaction copies per frame — each is a separate GPU submit, so this is what keeps a build burst from hitching RHI
r.RT.BLASCompaction.MinSavingint5Skip the copy when the compacted structure would reclaim less than this percentage of the built size RHI
r.RT.Foliageint1Put GPU-instanced foliage clumps near the camera in the scene TLAS (one instance per clump, sharing the clump mesh's BLAS), so RT shadows, reflections, AO and the hardware GI gather see grass: 0 = leave it out, 1 = include SceneRenderer
r.RT.Foliage.Distancefloat40.0fWorld radius around the camera inside which foliage clumps join the TLAS SceneRenderer
r.RT.Foliage.MaxInstancesint8192Most foliage clumps placed in the TLAS per frame SceneRenderer
r.RT.InFrameBuildsint1Record BLAS/TLAS builds made while a frame records into that frame's command list instead of a single-time submit and fence wait: 1=on (those builds are not compacted), 0=synchronous builds with compaction RHI
r.RT.Terrainint1Put CDLOD terrain in the scene TLAS as tiles of real triangles generated from the height texture (up to 256 quads a side, one updatable BLAS per 64x64 tile, refit where a sculpt touched): 0 = leave it out, so RT shadows, reflections, AO and the hardware GI gather see no ground, 1 = include SceneRenderer
r.RT.Translucentint1Put alpha-blended geometry in the scene TLAS, masked so only reflection rays (and shadow rays under r.RT.TranslucentShadows) see it, accepted stochastically by its opacity: 0 = leave it out (the old behaviour), 1 = include SceneRenderer
r.RT.TranslucentShadowsint1Alpha-blended shadow casters occlude ray-traced shadow rays by their opacity (needs r.RT.Translucent): 0 = off, 1 = on SceneRenderer
r.RTAOint-1Hardware ray-traced ambient occlusion instead of GTAO (needs ray query; implies the ray scene): -1=tier value, 0=off, 1=on SceneRenderer
r.RTAO.Calibrationfloat1.32fGain applied to ray-traced occlusion so its mean matches the screen-space integrator this pass replaces behind the AO slot. GTAO's raised horizon blocks the whole arc beneath it where a ray counts only geometry it meets, so a true trace reports less; the art is tuned on GTAO, and a gain moves the mean at constant signal-to-noise where a longer ray would not. Fitted on the gi-spatial-noise scene; 1 = raw traced occlusion SceneRenderer
r.RTAO.Radiusfloat-1.0fWorld-space occlusion ray length for RTAO, overriding the shared ssaoRadius setting (-1 = that setting times r.RTAO.RadiusScale). The two implementations behind the AO slot read that scalar differently — GTAO as a screen march it clamps to a 3-pixel floor, RTAO as a hard world TMax — so the shared 0.5 default is a real half-metre ray here and occludes a twentieth of what GTAO does; the fitted scale puts the two within a twentieth of each other and this knob overrides the product outright SceneRenderer
r.RTAO.RadiusScalefloat4.2fWhat the shared ssaoRadius setting is multiplied by before RTAO uses it as a world-space ray length. It exists because the two integrators behind the AO slot read that scalar differently, so the tier boundary that swaps them would otherwise change scene brightness. Reach buys mean occlusion at a steep price in variance — two stochastic rays a pixel cannot support a long one — so this stays short enough for gi-static-flicker and r.RTAO.Calibration closes the rest. r.RTAO.Radius overrides the product outright SceneRenderer
r.RTAO.Raysint-1RT AO occlusion rays per pixel: -1=tier value SceneRenderer
r.RTAO.TemporalAlphafloat0.96fHistory weight of the RTAO temporal accumulation on a still pixel (0.96 = ~25 frames). Two rays a frame need far more than the ten frames 0.9 gave them, and the short window was what left blurred noise crawling on a still camera: widening it took the crawling-pixel count at Epic from 4.89% to 3.09% and at Cinematic from 5.95% to 2.11%, which is the headroom the AO calibration gain spends. Safe by construction because motion still opens the weight toward 0.5 and depth rejection still drops a disoccluded history, so only a STILL pixel integrates this long SceneRenderer
r.RTAO.TemporalClampfloat4.0fWidth of the RTAO history clamp box as a multiple of the shared default. The box is centred on THIS frame's two-ray AO, whose centre jumps about as far as the box is wide, so the default clamp drags the history to a new edge every frame and the average never forms SceneRenderer
r.RTReflectionsint-1Hardware ray-traced reflections through the scene TLAS instead of the SSR ray march (needs ray query; implies the ray scene): -1=tier value, 0=off, 1=on SceneRenderer
r.RTReflections.HitLightingint1RT reflection hit shading: 0=flat per-instance records (legacy), 1=GI radiance cache with near-hit blend toward the records (default; falls back to the records where the cache is absent/unbaked), 2=pure cache (A/B, no near blend) SceneRenderer
r.RTReflections.Pipelineint0Trace the RT reflection world leg through a real ray-tracing pipeline (raygen + miss + a per-material closest-hit table) instead of the inline ray query: 1=on where the backend and device allow it, 0=inline pass (default). Read once when the post graph is built, because the pass it adds changes the trace target's usage flags. Off by default while the legacy-blend interaction below is open — see mowoengine.com/docs/rendering/ray-tracing/ SceneRenderer
r.RTReflections.RoughnessCutofffloat-1.0fRT reflections roughness cutoff — rougher surfaces fall back to SDF/env: -1=tier value SceneRenderer
r.RTReflections.SecondBounceint1Let a smooth metallic reflection HIT trace one more reflection ray, shaded by whatever material that ray lands on (pipeline path only — an inline query cannot recurse). 1=on (default), 0=one bounce SceneRenderer
r.RTSceneint0Maintain BLAS/TLAS over static scene geometry for ray-traced passes: 0=off, 1=on SceneRenderer
r.RTScene.BlasBudgetint8New BLAS builds per frame (each is a synchronous single-time submit) — residency amortizes across frames, the resident set itself is unbounded SceneRenderer
r.RTShadowsint-1Ray-traced sun shadows through the scene TLAS on top of CSM/VSM (implies r.RTScene): -1=scalability tier (Cinematic), 0=off, 1=on SceneRenderer
r.RTShadows.Samplesint-1RT sun shadow cone samples per pixel (jittered in the sun disc, temporally accumulated): -1=tier value, else 1..8 SceneRenderer
r.RTShadows.Spatialint1Depth-aware separable blur over the temporally accumulated RT sun shadow before the lighting reads it: 1 = on, 0 = the accumulation alone SceneRenderer
r.Shadow.BlockerSamplesint-1PCSS blocker-search taps per pixel: -1=tier value SceneRenderer
r.Shadow.Cascadesint-1Directional shadow cascades rendered (1..4): -1=tier value SceneRenderer
r.Shadow.CsmStaticCacheint1Static CSM cache: 1 = each cascade keeps its static casters in a second atlas and re-renders them only when the cascade's matrix or a static caster it reaches changes; a frame restores the cascade from it and draws only skinned, moving and WPO casters, terrain and foliage. 0 = every caster every frame SceneRenderer
r.Shadow.CsmStaticCache.MaxRestoreFractionfloat0.5fA cached cascade whose restore and dynamic layer both cover more than this fraction of its tile (terrain, foliage, a skinned crowd) draws every caster into its own cleared tile instead and keeps the cache for later: a full-tile depth copy from the pixel shader costs more GPU time than the static casters it saves, which is why UE caches only cascades movables do not cover SceneRenderer
r.Shadow.CsmStaticCache.Scrollint1Static CSM cache while the camera moves: 1 = a cascade the camera slid by whole texels restores its cached static layer at that offset and draws only the static casters of the uncovered strips (re-anchoring past an eighth of the tile); 0 = a moving cascade redraws every caster SceneRenderer
r.Shadow.CsmStaticCache.Scroll.MinCascadeint2First cascade a sliding camera scrolls instead of redrawing. A scroll is a full-tile shifted depth copy from the pixel shader; on the near cascades, which slide almost every frame of a moving camera, it cost more GPU time than the static casters it saved (csm-static-cache: 1.74 against 0.40 ms of Shadow scope), so they redraw and only the far cascades scroll SceneRenderer
r.Shadow.FilterSamplesint-1PCSS penumbra filter taps per pixel: -1=tier value SceneRenderer
r.Shadow.Local.Virtualint-1Local-light shadows as paged virtual shadow maps: 1 = every shadow view a sparse map of up to r.Shadow.Local.VirtualMaxPages^2 pages of 128 texels, only the pages the camera can reach resident in the atlas and kept across frames until their light or casters change; 0 = one packed atlas tile per view; -1 = the scalability tier (High and up page, Medium and below use the atlas) SceneRenderer
r.Shadow.Local.Virtual.DepthMarksint1Local virtual shadow pages are mapped only where a visible receiver in the scene depth projects into them (read back a few frames late; while the camera or a light moves the camera-frustum reach decides): 1 = on, 0 = every page the camera frustum can reach SceneRenderer
r.Shadow.Local.Virtual.MarkStrideint4Screen-pixel stride of the local virtual shadow depth-marking pass (1-16); a page is 128 shadow texels, so a coarse stride still finds every receiver of any size that matters SceneRenderer
r.Shadow.Local.Virtual.TwoLayerint1Two-layer local virtual shadow pages: 1 = a second atlas keeps each resident page's static depth, so a page under a moving dynamic caster (skinned mesh, moving body, animated foliage) copies its static depth back and redraws only the dynamic casters; 0 = such a page redraws every caster under it SceneRenderer
r.Shadow.Local.VirtualMaxPagesint16Pages per side of the largest local virtual shadow map (16 = 2048 texels); when the visible pages outgrow the atlas the largest maps give up a level first SceneRenderer
r.Shadow.LocalCacheint1Cached local shadow-atlas tiles: 1=re-render only tiles whose light or intersecting caster set changed (static tiles cost zero draws), 0=legacy full atlas clear + re-render every frame SceneRenderer
r.Shadow.LocalMinTileint-1Smallest local shadow atlas tile in px (a light that cannot get one goes unshadowed): -1=tier value SceneRenderer
r.Shadow.LocalTileSizeint-1Largest local shadow atlas tile in px (the most important light gets one): -1=tier value SceneRenderer
r.Shadow.MaxDistancefloat150.0fDirectional (CSM) shadow range in world units; the sun shadow fades to unshadowed over the last 15% of it. A scene's World Settings shadow max distance (> 0) overrides this SceneRenderer
r.Shadow.MaxLocalViewsint-1Local shadow atlas view budget (1 view per shadowed spot/rect, 6 per point): -1=tier value SceneRenderer
r.Shadow.MaxPenumbraTexelsfloat-1.0fPCSS penumbra ceiling in shadow-map texels: -1=tier value SceneRenderer
r.Shadow.Resolutionint-1CSM per-cascade shadow tile resolution (atlas = 2x2 of this): -1=tier value, else 256..8192 (live atlas recreate) SceneRenderer
r.Shadow.SdfFarint-1SDF far sun shadows: past r.Shadow.MaxDistance the sun cone-traces the GI global SDF for soft distant occlusion instead of going unshadowed (needs the SDF, Medium+): -1=tier value, 0=off, 1=on SceneRenderer
r.Shadow.SdfFarStepsint-1SDF far sun shadow trace step cap: -1=tier value, else 8..128 SceneRenderer
r.Shadow.Softint-1Soft shadows: 0=fixed PCF kernel, 1=PCSS (blocker search + variable-radius filter, penumbra from the light's source size): -1=tier value (High+) SceneRenderer
r.Shadow.StableFitint1CSM cascade fit: 1=constant-radius world-sphere extent + texel-snapped ortho origin (world-locked, no edge crawl under camera motion), 0=legacy tight per-frame light-space AABB with no snap (extent pumps + grid crawls = shadow-edge swim) SceneRenderer
r.Shadow.Translucentint1Alpha-blended meshes with Cast Shadows cast a partial shadow into the cascades and the local atlas: each texel is kept with the material's opacity as its probability (dithered, then softened by the shadow filter), so a 30%-opaque pane casts a 30% shadow instead of none or a black one. 0 = translucent meshes cast no raster shadow SceneRenderer
r.Sharpnessint-1Post-AA CAS sharpening override in percent: -1=scene setting, 0=off, 1-100=strength SceneRenderer
r.Sky.CoupleAmbientint1L3 sky<->ambient coupling: 1=the GI probe-miss sky is derived from the sky actually on screen, 0=legacy flat ambientColor*ambientIntensity (the pre-fix 4-17x mismatch — A/B only) SceneRenderer
r.Sky.MoonIntensityfloat1.0fMoon disc intensity at night (0 = off); rides anti-sun with a crescent phase from the sun/moon geometry SceneRenderer
r.Sky.Rotationfloat0.0fDegrees of extra sky yaw about world up, ADDED to the sky light's authored Sky Rotation. Turns the cubemap sky and every lobe derived from it (irradiance, prefilter, forward sky miss, reflection captures) together; a procedural atmosphere ignores it SceneRenderer
r.Sky.Starsfloat1.0fProcedural star field intensity at night (0 = off); fades in below the horizon, fully visible once the sun is 12 degrees under SceneRenderer
r.SkyAtmosphere.AerialPerspectiveint1Tint distant geometry with the atmosphere's in-scattering and transmittance (the froxel volume the sky LUTs feed): 0=off, 1=on SceneRenderer
r.SkyAtmosphere.Translucencyint1Sky atmosphere on translucents and particles: 1=they take the aerial perspective and height fog the atmosphere composite gives the opaque pixel behind them (default), 0=none (A/B) SceneRenderer
r.SkyIBL.CrossfadeSecondsfloat1.0fCrossfade between sky-IBL generations when the time-of-day rebake fires: seconds to blend the previous irradiance/prefilter into the new one, 0 = discrete swap (old behavior) SceneRenderer
r.SkyLight.CaptureCloudsint1Include the cloud layer in the sky light capture, so clouds shade the ambient and appear in reflections: 0=off, 1=on SceneRenderer
r.SkyLight.CaptureSizeint128Face size of the sky light capture cubemap the irradiance and reflection maps are convolved from (32..512) SceneRenderer
r.SkyLight.CloudRecaptureSecondsfloat0.5fShortest time between real-time sky light captures that only drifting clouds asked for (the sun, intensity or atmosphere changing still re-captures on the sky light's interval); the IBL crossfades between captures SceneRenderer
r.SSGIint-1Screen-space one-bounce indirect diffuse: -1=tier value, 0=off, 1=on SceneRenderer
r.SSGI.Raysint-1SSGI hemisphere rays per pixel: -1=tier value SceneRenderer
r.SSGI.Stepsint-1SSGI depth-march steps per ray: -1=tier value SceneRenderer
r.SSRint-1Screen-space reflections (the whole trace/temporal/resolve slice): -1=tier value (Medium+ on, Low hard-off), 0=off, 1=on. Scene PostFX settings act within this. SceneRenderer
r.SSR.FilterTapsint3Reflection spatial filter kernel: 5 = 5x5 taps, 3 = 3x3 a-trous over the same footprint (a third of the cost) SceneRenderer
r.SSR.MaxStepsint-1Cap on the scene's SSR raymarch step count: -1=tier value, 0=uncapped SceneRenderer
r.SSR.TraceDivisorint-1Resolution divisor of the screen-leg reflection trace: -1=tier value, 1=full res, 2=half (a quarter of the pixels traced per frame, rotating over a 2x2 block; SSRUpsample rebuilds the rest and the temporal pass integrates them) SceneRenderer
r.SSS.Widthfloat24.0fSubsurface blur radius in pixels at full strength (the profile shapes the falloff inside it) SceneRenderer
r.Substrateint0Substrate layered-BSDF slabs on compiled material graphs: 0=off (the Output node's Substrate slot is ignored and every graph emits byte-identical source), 1=on (a slab compiles into the two-slab G-Buffer encode). Materials must be recompiled after changing this. AssetSystem
r.Terrain.CDLODint1Terrain render path: 1=CDLOD (quadtree-selected instanced patches displaced by a height texture, continuous morph LOD), 0=legacy per-chunk meshes with discrete LOD chains Game
r.Terrain.ErrorPixelsfloat3.0fCDLOD terrain screen-space error tolerance in pixels — lower = denser node selection (more draws, finer far detail) SceneRenderer
r.Terrain.MorphZonefloat0.30fFraction of each CDLOD node's range spent morphing to the coarser grid (0.05-0.95) SceneRenderer
r.Terrain.RVTint-1Terrain runtime virtual texture — bake the splat blend into feedback-streamed VT pages and sample the composite per pixel: -1=tier value (High+ on), 0=off, 1=on SceneRenderer
r.Terrain.RVTVirtualPagesint64Terrain RVT virtual size in 128-texel pages per axis (64 = 8192 virtual texels across the terrain); applies to caches created after the change SceneRenderer
r.Terrain.Wireframeint0Draw CDLOD terrain with a wireframe fill pipeline (shows the live LOD density): 0=off, 1=on Cheat. SceneRenderer
r.Texture.KeepCpuCopyint0Keep every texture's decoded / cooked CPU pixels after the GPU upload: 0 = free them (a texture that needs them opts in with TextureAsset::SetKeepCpuCopy), 1 = keep all (A/B) AssetSystem
r.Texture.PackageNativeBcint1Upload a Texture package as its block-compressed chain (the package's cooked render data, else its source cooked through the DDC with its import settings): 1 = on, 0 = decode it to RGBA8 and build the mips on the GPU, as before (A/B). Read when a texture loads AssetSystem
r.TextureStreamingint1Camera-driven texture mip streaming (1 = on). Off keeps every scene texture fully resident. GameHost
r.TextureStreaming.ForceBudgetMBint0Treat the OS's VRAM budget as this many MB (0 = the driver's real budget), so the VRAM-pressure path drops mips on a card that has room: the small-card test on any machine. GameHost
r.TextureStreaming.MaxUploadBytesPerFrameint16 * 1024 * 1024Byte budget for texture mip uploads SUBMITTED per frame (the disk portion; GPU-copied resident tails are free). Uploads are asynchronous — the visible swap lands when the GPU finishes — so this bounds per-frame transfer bandwidth, not a stall. <= 0 = unbounded. Game
r.TextureStreaming.PoolSizeMBint0Streaming texture residency budget in MB (0 = unlimited). The farthest textures coarsen first when the desired set exceeds it. GameHost
r.TextureStreaming.VramPressureint1Shrink the texture and mesh LOD streaming pools (splitting the overshoot by what each holds) while the driver reports device-local usage over 95% of the VRAM budget the OS grants (relaxes under 85%): 1 = on, 0 = the configured pool only. GameHost
r.Tonemapint-1Tonemap operator override: -1=scene setting, 0=ACES (fit), 1=AgX, 2=Reinhard, 3=clamp, 4=ACES RRT+ODT (sRGB 100-nit ODT, 1000-nit under HDR output), 5=display LUT (r.DisplayLUT / the scene's; ACES RRT+ODT while none) SceneRenderer
r.TSR.AntiFlickerfloat2.0fTSR anti-flicker: damping applied to the current frame where its raw luma oscillates beyond the variance box between frames (0 = off) RHI
r.TSR.ClampGammafloat1.0fTSR history rectification: width of the YCoCg variance box in standard deviations (lower = less ghosting, more flicker; < 0 disables clipping) RHI
r.TSR.Debugint0TSR debug view written in place of the resolved image: 0 = off, 1 = history weight (sample count / MaxSamples), 2 = rejection (R = depth/off-screen reject, G = clip amount, B = reactive mask), 3 = velocity (RG = signed output pixels/frame, B = velocity clamp ramp) RHI
r.TSR.MaxSamplesfloat32.0fTSR temporal accumulation cap — the per-pixel sample count saturates here (alpha floor = 1/N) RHI
r.TSR.Sharpnessfloat0.4fTSR output sharpening (RCAS lobe): 0 = off, 1 = full RHI
r.TSR.Velocity.WeightClampingPixelSpeedfloat1.0fTSR: output-pixel speed per frame at which the history clamp reaches WeightClampingSampleCount RHI
r.TSR.Velocity.WeightClampingSampleCountfloat4.0fTSR: sample count the history is clamped to at r.TSR.Velocity.WeightClampingPixelSpeed (lower = crisper motion, more flicker; >= MaxSamples disables) RHI
r.Upscale.ReactiveMaskint1Derive a reactive mask from the pre/post-translucency scene diff and feed it to the temporal upscaler (0 = off) SceneRenderer
r.Upscalerint-1Active upscaler: -1=auto (picked from the device at startup), 0=None 1=TAA 2=Spatial 3=FSR 4=DLSS 5=TSR 6=XeSS 7=MetalFX (runtime-toggleable). ApplyUpscalerCVars ignores -1, so the auto slot never overrides the renderer before FQualityAutoTier fills it. SceneRenderer
r.Upscaler.AutoQualityint-1Auto upscaling: pick the upscaler quality mode from the output resolution (<=900p Native, 1080p Quality, 1440p Balanced, 4K Performance, above Ultra Performance; lower tiers shift toward Performance). -1 = follow the tier (on at High and below), 0 = off (r.UpscalerQuality decides), 1 = on. SceneRenderer
r.Upscaler.DeferredReleaseint1Reallocate upscaler history and intermediates (TSR, FSR 1, the FSR 3 context) on a resize without draining the GPU: the old images and contexts are released once the frames that read them have retired. 1=on, 0=WaitIdle first (A/B) RHI
r.UpscalerQualityint0Upscaler quality: 0=Native(DLAA) 1=Quality 2=Balanced 3=Performance 4=Ultra SceneRenderer
r.VdbVolumesint1Ray-march VDB volumes (VdbVolume components): 0 = off, 1 = on SceneRenderer
r.VdbVolumes.ShadowStepsint6Samples of the self-shadow march toward the sun at each view sample; 0 = unshadowed SceneRenderer
r.VdbVolumes.Stepsint64View-ray samples through each VDB volume's box SceneRenderer
r.Velocity.MoversOnlyint1Velocity pass: 1 = a fullscreen compose writes every pixel's camera-motion velocity from the GBuffer depth and only movers (skinned, WPO, transform changed since last frame) are rasterised on top; 0 = redraw the whole opaque list (the pre-2026-09-28 pass, A/B) SceneRenderer
r.ViewDistanceScalefloat-1.0fGlobal multiplier on every object's authored maxDrawDistance at cull time: -1=tier value SceneRenderer
r.ViewModeint-1Debug buffer view: -1=host decides (editor View menu), 0=Shaded, 1=Wireframe, 2=Unlit, 3=Normals, 4=Depth, 5=Roughness, 6=Metallic, 7=BaseColor, 8=Emissive, 9=AmbientOcclusion, 10=ShadowCascades, 11=DetailLighting, 12=LightingOnly, 13=Velocity, 14=GlobalIllumination, 15=Reflections, 16=PathTracing Cheat. SceneRenderer
r.VirtualTextureint-1Virtual texturing — feedback-driven page streaming over a GPU page table + physical atlas, driving a virtual-textured ground surface: -1=off (default), 0=off, 1=on SceneRenderer
r.VirtualTexture.Sourcestring""VFS path of a cooked virtual-texture tile file (<texture>.mvtiles, the Virtual Texture Tiles import setting) the ground surface streams BCn pages from; empty = the procedural source SceneRenderer
r.VolumetricCloudsint-1Cloud rendering master switch: -1=code default, 0=off, 1=on. r.VolumetricClouds.Mode picks the implementation SceneRenderer
r.VolumetricClouds.BaseAltitudefloat400.0fBottom of the raymarched cloud layer, in absolute world units SceneRenderer
r.VolumetricClouds.Coveragefloat0.45fCloud coverage fraction (0 = clear sky, 1 = overcast) SceneRenderer
r.VolumetricClouds.Densityfloat0.05fRaymarched cloud extinction per world unit at full coverage SceneRenderer
r.VolumetricClouds.Detailfloat0.4fSilhouette erosion strength from the detail noise volume (0 = smooth blobs) SceneRenderer
r.VolumetricClouds.EnableForProjectint0Project switch: 1 = this project may raymarch the volumetric cloud volume. 0 = a cloud actor draws the flat cloud layer and the cloud noise volumes are never built RHI
r.VolumetricClouds.Heightfloat400.0fCloud plane height in world units above the camera SceneRenderer
r.VolumetricClouds.Intensityfloat1.0fMultiplier on the composited cloud radiance SceneRenderer
r.VolumetricClouds.LightStepsint-1Sun light-march taps per lit sample: -1 = scalability tier default SceneRenderer
r.VolumetricClouds.MaxDistancefloat60000.0fLongest raymarch segment through the cloud layer, in world units SceneRenderer
r.VolumetricClouds.Modeint-1Cloud implementation: -1=scalability tier default, 1=2.5D fbm sky plane (cheap), 2=raymarched volume (Epic+, flyable) SceneRenderer
r.VolumetricClouds.Powderfloat0.6fPowder-term strength on the sun transmittance (dark edges on lit cloud tops) SceneRenderer
r.VolumetricClouds.Resolutionint2Raymarch target resolution divisor (1 = full res, 2 = half, 4 = quarter) SceneRenderer
r.VolumetricClouds.Scalefloat0.00035fRaymarched cloud noise frequency (1 / world units per shape-volume tile) SceneRenderer
r.VolumetricClouds.Stepsint-1Raymarch step budget (upper bound of the adaptive count): -1 = scalability tier default SceneRenderer
r.VolumetricClouds.Temporalfloat0.9fTemporal reprojection blend for the raymarch (0 = no history, 0.95 = heavy) SceneRenderer
r.VolumetricClouds.TopAltitudefloat1400.0fTop of the raymarched cloud layer, in absolute world units SceneRenderer
r.VolumetricClouds.Typefloat0.75fCloud type: 0 = flat stratus sheet, 1 = tall cumulus towers SceneRenderer
r.VolumetricClouds.WindSpeedfloat12.0fRaymarched cloud wind speed in world units per second SceneRenderer
r.VolumetricFogint-1Froxel volumetric fog (3D light grid: height fog + fog volumes, sun-scattered with per-froxel CSM shadow, temporally reprojected, composited before transparency): -1=code default, 0=off, 1=on SceneRenderer
r.VolumetricFog.Anisotropyfloat0.6fHenyey-Greenstein phase g for the sun in-scatter (>0 = forward, sharper god rays) SceneRenderer
r.VolumetricFog.EnableForProjectint0Project switch: 1 = this project uses froxel volumetric fog. 0 = height fog stays analytic and the froxel volumes are never built RHI
r.VolumetricFog.GiAmbientint1Froxel fog ambient: 1 = each froxel takes the mean radiance the DDGI probe field gives its position (sealed rooms stay dark, fog by a lit wall picks up its bounce) whenever the field is live, 0 = one constant ambient from the scene's ambient colour everywhere (A/B) SceneRenderer
r.VolumetricFog.HeightFallofffloat0.02fExponential height-fog falloff per world unit above the base plane SceneRenderer
r.VolumetricFog.MaxLocalLightsint32Point/spot lights injected into the froxel fog, nearest-first (0 = sun/ambient only). Per light, LightComponent volumetricScattering scales or disables its contribution SceneRenderer
r.VolumetricFog.Temporalfloat0.9fTemporal reprojection blend for the froxel injection (0 = no history, 0.9 = heavy) SceneRenderer
r.VolumetricFog.Translucencyint1Froxel fog on translucents: 1=forward transparents (glass, water, the OIT path) take the integrated froxel volume at their own depth, the haze the opaque composite gives the pixel behind them (default), 0=analytic fog only (A/B) SceneRenderer
r.Voxel.BlockLightEmissionfloat1.5fVoxel chunk block light as emission: albedo times the squared block light times this SceneRenderer
r.Voxel.PoolBudgetMBint1024VRAM the voxel vertex pool may grow to, in MB (32 MB blocks); a chunk mesh that does not fit is refused Renderer
r.Voxel.UploadBudgetKBint4096Voxel chunk mesh bytes sent to the GPU per frame in one batch; the rest of the queue waits for the next frame. 0 = no limit Renderer
r.Voxel.UploadMaxInFlightint2Voxel upload batches kept in flight before the queue is held; the RHI async upload slots are shared with texture streaming and the dynamic mesh pool Renderer
r.VRSint0Variable-rate shading of the G-buffer from a per-tile rate image (D3D12 VRS Tier 2 / Vulkan fragment shading rate): 0 = off, 1 = on. No effect where the device has no image-based VRS SceneRenderer
r.VRS.ContrastThresholdfloat0.03fMean perceptual luminance step between neighbouring samples of a tile below which it shades coarser along that axis SceneRenderer
r.VRS.MotionThresholdfloat6.0fScreen motion in pixels per frame above which a tile shades at 2x2 whatever its contrast SceneRenderer
r.VSMint-1Virtual shadow maps: 0=off, 1=on (-1 = scalability tier default, Epic+) SceneRenderer
r.VSM.CasterRunsint1VSM caster runs: 1=consecutive static casters on one mesh and LOD draw their dirty pages with one indirect call per run (page lists packed on the GPU), 0=one indirect call per caster SceneRenderer
r.VSM.Clipmap.FirstExtentfloat2.0fHalf-extent in world units of the finest VSM clipmap level; each further level doubles it. 96x96 pages of 64 texels over this extent sets the finest texel a receiver can ask for (2 = 0.65 mm); receivers take the coarsest level their pixel footprint still resolves, so a small first level costs pages only where the camera is close enough to use it SceneRenderer
r.VSM.Clipmap.Levelsint-1VSM clipmap level count (1..16); -1 = the fewest levels whose coarsest extent still covers r.Shadow.MaxDistance. Receivers past the coarsest level fall back to the CSM SceneRenderer
r.VSM.Clipmap.LodBiasfloat0.0fVSM clipmap level bias against the receiver's pixel footprint: 0 = one shadow texel per screen pixel, -1 = two per pixel (4x the page demand; UE's default sits near -1.5 on a pool four times this one), +1 = half SceneRenderer
r.VSM.CsmCastersint-1Mesh casters in the CSM cascades while the virtual shadow map is on: -1 = only until the VSM resolved with a steady page cache (no flood, no deferred pages), then the cascades carry terrain and GPU foliage alone and every sun-shadow reader samples the VSM pages; 1 = always draw them (the pre-2026-09-28 double raster, A/B); 0 = never draw them under VSM SceneRenderer
r.VSM.PageBudgetint256Max VSM pages re-rasterized per frame; stale pages past the budget keep waiting and the CSM serves their pixels, so a sun move or mass invalidation never hitches. Capped at 1024 (the per-frame page list); 0 = that cap SceneRenderer
r.VSM.SmrtRayLengthfloat0.0fSMRT occluder search distance toward the sun in world units; 0 = 16 SceneRenderer
r.VSM.SmrtRaysint6Shadow-map ray-tracing rays per pixel in the VSM resolve (jittered across the sun's angular extent) SceneRenderer
r.VSM.SmrtSamplesint4Depth samples marched along each SMRT ray SceneRenderer
r.VSM.StableFitint1VSM camera-decoupled light space: 1=toroidal clipmap scroll (a camera step invalidates the row/column that wrapped in, the rest of the page cache survives), 0=legacy behaviour where any window scroll floods the whole clipmap stale SceneRenderer
r.VSyncint-1Vertical sync. 1 = on, 0 = off, -1 = follow the window config (default). EngineLoop
r.Vulkan.AsyncCompute.SyncSubmitint01 = submit the async-compute fork, hand-off and join through FRHIThread::ExecuteSync (the render thread waits for the whole RHI queue each time), 0 = enqueue the submit and keep recording VulkanRHI
r.Vulkan.AsyncUploadsint1Create-with-data uploads on Vulkan (static buffers, texture data, IBL bakes, upload batches) submit their single-time command buffer and return without waiting for the GPU; the staging is released once the submit's fence signals. 0 = wait for every upload (the old blocking path) VulkanRHI
r.Vulkan.PipelineReuseint1Share one VkPipeline between pipelines created from an identical spec (shader content + full state hash): 0=every creation compiles its own, 1=dedupe VulkanRHI
r.Vulkan.ValidationRepeatint0Log every occurrence of a validation message instead of only the first: 0=dedupe, 1=repeat VulkanRHI
r.WarmPipelinesOnStartupint1Pre-compile the lazy feature pipeline groups (MegaLights/fog/clouds/screen probes/path trace/VT/...) at startup so first feature use never hitches on a PSO compile: 0=off, 1=on SceneRenderer
r.Water.Causticsint1Underwater caustics: an animated cellular light pattern projected onto submerged geometry, faded by the water column above it. Needs the water info texture for the surface height. SceneRenderer
r.Water.CausticStrengthfloat0.35fBrightness of the underwater caustic pattern. SceneRenderer
r.Water.Foamint1Water foam: shore band where water meets geometry + Gerstner crest foam. SceneTypes
r.Water.InfoResolutionint256Water info texture resolution per side (clamped 32-1024). Higher resolves a narrower river channel; the raster is CPU-side and only re-runs when a body changes. SceneTypes
r.Water.InfoTextureint1Water info texture: a top-down raster of depth-to-bottom, flow and surface height over every water body, read by the water shader for bathymetric colour, shoreline foam and flow-advected foam UVs. 0 = the pre-texture look, pixel for pixel. SceneTypes
r.Water.Reflectionsint1Fresnel-weighted environment reflection on water surfaces: a screen-space march over the opaque scene first (with r.Water.Refraction), then the translucent reflection ray through the SDF radiance cache where r.Reflections.Translucent and a built cache allow it, then the sky. SceneTypes
r.Water.Refractionint1Water refraction: sample the opaque scene color behind the surface with a normal-perturbed, depth-scaled offset. Latched at renderer init (selects the WATER+REFRACTION shader variant). SceneTypes
r.Water.Underwaterint1Fullscreen tint + distance fog when the camera is below a water surface. SceneTypes
r.Water.Wetnessint1Shoreline wetness: geometry in a band just above the waterline is darkened and smoothed in the deferred lighting pass, so its specular sharpens as well. Needs the water info texture for the per-pixel waterline. SceneTypes
r.Water.WetnessBandfloat0.6fMetres above the waterline the shoreline wetness band reaches. SceneTypes
r.Water.WetnessStrengthfloat0.45fHow wet the shoreline band gets at the waterline: 0 disables the lane, 1 is a fully soaked surface. SceneTypes
r.Wind.Flutterfloat0.15fHigh-frequency tip/edge flutter amount, weighted by the vertex-color bend mask SceneRenderer
r.Wind.Gustfloat0.35fGust amount — 2-octave time noise modulating the sway amplitude (0 = steady wind) SceneRenderer
r.Wind.Speedfloat1.0fGlobal wind speed multiplier on top of per-foliage windSpeed SceneRenderer
r.Wind.Strengthfloat1.0fGlobal wind strength multiplier on top of per-foliage windStrength SceneRenderer
r.WorldGridint1Procedural world grid on grid materials and on every mesh with no material. 0=flat base colour (a material-less mesh then reads as the old flat grey), 1=grid SceneRenderer

save

NameTypeDefaultDescription
save.AutosaveIntervalfloat300.0fSeconds between runtime autosaves into the dedicated autosave slot (0 = off) Game
save.AutosaveOnTravelint1Flush the outgoing scene's world state into the autosave slot before a map travel, so returning later via load restores it (0 = off) Game

sg

NameTypeDefaultDescription
sg.AntiAliasingQualityint-1Scalability group override: -1 = follow r.Quality, 0=Low 1=Medium 2=High 3=Epic 4=Cinematic SceneRenderer
sg.EffectsQualityint-1Scalability group override: -1 = follow r.Quality, 0=Low 1=Medium 2=High 3=Epic 4=Cinematic SceneRenderer
sg.FoliageQualityint-1Scalability group override: -1 = follow r.Quality, 0=Low 1=Medium 2=High 3=Epic 4=Cinematic SceneRenderer
sg.GlobalIlluminationQualityint-1Scalability group override: -1 = follow r.Quality, 0=Low 1=Medium 2=High 3=Epic 4=Cinematic SceneRenderer
sg.PostProcessQualityint-1Scalability group override: -1 = follow r.Quality, 0=Low 1=Medium 2=High 3=Epic 4=Cinematic SceneRenderer
sg.ReflectionQualityint-1Scalability group override: -1 = follow r.Quality, 0=Low 1=Medium 2=High 3=Epic 4=Cinematic SceneRenderer
sg.ShadowQualityint-1Scalability group override: -1 = follow r.Quality, 0=Low 1=Medium 2=High 3=Epic 4=Cinematic SceneRenderer
sg.TextureQualityint-1Scalability group override: -1 = follow r.Quality, 0=Low 1=Medium 2=High 3=Epic 4=Cinematic SceneRenderer
sg.ViewDistanceQualityint-1Scalability group override: -1 = follow r.Quality, 0=Low 1=Medium 2=High 3=Epic 4=Cinematic SceneRenderer

stat

NameTypeDefaultDescription
stat.fpsboolfalseToggle the FPS overlay in the editor / game view. EngineLoop
stat.FrameStatsint0Headless frame-stage profiler dump. 0 = off (default); N > 0 enables the in-process profiler and logs averaged CPU stage times plus the resolved GPU frame total to the log every N frames. EngineLoop
stat.FrameStatsCountint30How many scopes stat.FrameStats lists, ranked by total time. The default of 10 hid the whole gameplay breakdown behind the render stages. EngineLoop
stat.FrameStatsFilterstring""Case-insensitive substring; when set, stat.FrameStats lists only scopes whose name contains it (e.g. System for the ECS breakdown). EngineLoop

t

NameTypeDefaultDescription
t.BatterySaverFPSint0Frame rate cap while running on battery power. 0 = off (default). M2.5: on phones a card game at 30/60 stretches battery dramatically; high-refresh panels (ProMotion / 120 Hz Android) fall back to this only while unplugged and return to full rate on charger. EngineLoop
t.HitchLogMsintkDefaultHitchLogMsLog [Hitch] with the frame's phases for any frame longer than this many milliseconds but under t.StallLogMs, at most once a second. 0 = off. EngineLoop
t.MaxFPSint0Frame rate cap. 0 = uncapped (default). EngineLoop
t.StallLogMsint1000Log [Stall] with the phases of any frame whose own work (pacing excluded) runs longer than this many milliseconds; with the profiler on, its slowest scopes too. 0 = off. EngineLoop

telemetry

NameTypeDefaultDescription
telemetry.Alert.CpuTempCfloat95.0fCPU package temperature that raises the CPU-hot alert, in °C. Telemetry
telemetry.Alert.CpuTempClearCfloat88.0fCPU package temperature the CPU-hot alert clears under, in °C. Telemetry
telemetry.Alert.Enableint1Watch for a hot or thermally throttling GPU/CPU and VRAM near its budget, and raise telemetry alerts (1). Telemetry
telemetry.Alert.GpuHotspotCfloat105.0fGPU hotspot (junction) temperature that raises the GPU-hot alert where the GPU reports one, in °C. Telemetry
telemetry.Alert.GpuTempCfloat87.0fGPU temperature (edge/core sensor) that raises the GPU-hot alert, in °C. Telemetry
telemetry.Alert.GpuTempClearCfloat80.0fGPU temperature the GPU-hot alert clears under, in °C. Telemetry
telemetry.Alert.HoldSecondsfloat3.0fHow long a reading must stay past an alert threshold (or back under its clear threshold) before the alert raises (or clears). Telemetry
telemetry.Alert.SampleHzfloat1.0fTelemetry sample rate while nothing reads it but alerts are on, 0.2-4 Hz. Telemetry
telemetry.Alert.Throttlingint1Raise the GPU and CPU throttling alerts (1). A GPU held at its power limit under load is normal and never alerts; only thermal throttling does. Telemetry
telemetry.Alert.VramClearFractionfloat0.88fVRAM used over budget the VRAM alert clears under. Telemetry
telemetry.Alert.VramFractionfloat0.95fVRAM used over the budget the OS grants that raises the VRAM alert (0.95 = 95 %). Telemetry
telemetry.Enableint1Run the hardware and performance telemetry service (1). 0 = no sampling thread, every metric reads as unavailable. Telemetry
telemetry.SampleHzfloat4.0fTelemetry sample rate while something reads it (a script getter, the netgraph, an ArcUI binding, stat hardware/net), 1-10 Hz. Telemetry
telemetry.ShowPlayerWarningsint0Show players a one-line warning while a telemetry alert is raised (the GPU or CPU is hot or throttling, VRAM is near its budget). Off by default: the project decides (Project Settings > Performance). ArcUI

ui

NameTypeDefaultDescription
ui.HighContrastint0Accessibility: draw Arc menus and HUD in the high-contrast theme ArcUI
ui.ReducedMotionint0Accessibility: skip Arc's decorative transitions and motion ArcUI

vfs

NameTypeDefaultDescription
vfs.LogMissesboolfalseLog every failed VFS Open with the path and the mounts that were tried Filesystem
vfs.PackagedLooseFilesintkPackagedLooseFilesDefaultA packaged run with content paks: 1 keeps the working directory mounted as the lowest-priority VFS fallback, 0 reads relative keys only from the paks (release and profile default) so a loose file beside the package can never stand in for content the cook missed. Absolute paths always pass through. GameHost

voice

NameTypeDefaultDescription
voice.AutoGainbooltrueLevel a quiet or a loud microphone toward one speaking level VoiceChat
voice.AutoGainMaxDbint30The most automatic gain will add, in dB VoiceChat
voice.AutoGainTargetfloat0.25fSpeaking level automatic gain aims for, as a fraction of full scale VoiceChat
voice.BytesPerSecondint12000Hard per-client outgoing voice bandwidth cap in bytes/second; frames over budget are dropped VoiceChat
voice.Codecstring"auto"Voice codec: auto (Opus where its binaries are vendored, otherwise ADPCM), opus, or adpcm VoiceChat
voice.DistanceLowPassFarfloat3500.0fLow-pass cutoff (Hz) a proximity voice plays through at the edge of voice.HearingRange; 20000 switches the distance low-pass off VoiceChat
voice.DistanceLowPassNearfloat20000.0fLow-pass cutoff (Hz) a proximity voice plays through at voice.NearRange; 20000 = full band VoiceChat
voice.EchoCancellationbooltrueCancel other players' voices coming back in through the microphone from open speakers (SpeexDSP echo canceller) VoiceChat
voice.EchoTailMsint200Longest echo the canceller models, in milliseconds: speaker-to-microphone path plus device buffers VoiceChat
voice.EnabledbooltrueMaster switch for proximity voice chat capture and playback VoiceChat
voice.FollowPlatformMutebooltrueMute the microphone while the player is muted or deafened in their platform voice client (Discord), and silence incoming voice while deafened VoiceChat
voice.GateCloseRmsfloat0.02fCapture RMS below which the noise gate closes again after its hold expires VoiceChat
voice.GateHoldSecondsfloat0.35fSeconds the noise gate stays open after the signal drops, so a pause mid-sentence does not clip the tail VoiceChat
voice.GateOpenRmsfloat0.035fCapture RMS a frame must reach to open the noise gate and start transmitting VoiceChat
voice.GrainMaxfloat0.6fHow broken up a proximity voice is at the edge of hearing range, 0..1; 0 switches the grain layer off VoiceChat
voice.GrainStartfloat0.5fFraction of voice.HearingRange past which a proximity voice starts to break up VoiceChat
voice.HearingRangefloat22.0fDistance (m) past which a proximity voice speaker is inaudible and no longer relayed VoiceChat
voice.InputDevicestring""Capture device id; empty means the system default VoiceChat
voice.InputDeviceListstring""Capture devices the plugin found, one id|name row per line - published by the voice plugin, read by the settings screen VoiceChat
voice.InputGainfloat1.0fLinear gain applied to captured samples before the noise gate reads their energy VoiceChat
voice.MimicryCaptureboolfalseKeep short in-memory fragments of consenting, unmuted players' voices for a mimic (host side; never written to disk) VoiceChat
voice.MimicryConsentbooltrueAllow the host to keep short fragments of your voice in memory for creatures that mimic players; off = nothing of your voice is kept VoiceChat
voice.Modeint0Transmit mode: 0 = push-to-talk, 1 = open mic (the activation threshold is voice.GateOpenRms) VoiceChat
voice.MuteDuringPlatformCallbooltrueKeep the in-game microphone off while the player is in a platform voice call (a Discord lobby call), so one voice is not sent twice VoiceChat
voice.NearRangefloat3.0fDistance (m) within which a proximity speaker plays at full volume before rolloff begins VoiceChat
voice.NoiseSuppressDbint-25How far noise suppression pushes noise down, in dB (negative) VoiceChat
voice.NoiseSuppressionbooltrueLearn and subtract stationary microphone noise (fans, hum, hiss) before the gate and the encoder VoiceChat
voice.OcclusionbooltrueMuffle a speaker the local player has no line of sight to VoiceChat
voice.OpusBitrateint32000Target bitrate in bits/second for the Opus VBR encoder VoiceChat
voice.OpusDtxbooltrueLet Opus emit nothing at all through silence instead of a packet per 20 ms VoiceChat
voice.OpusFecbooltrueCarry a coarse copy of the previous frame in each Opus packet so one lost frame is rebuilt rather than concealed. Only while voice.OpusRedundancyMs is 0: deep redundancy replaces it VoiceChat
voice.OpusRedundancyMsint500Milliseconds of past speech carried as deep redundancy (Opus DRED) in every packet, so a burst of loss is rebuilt instead of concealed. 0 turns it off and inband FEC back on VoiceChat
voice.OutputVolumefloat1.0fMaster playback volume for every incoming voice, on top of the Voice bus VoiceChat
voice.RadioAINoisefloat0.6fLoudness of the noise AI hears from a radio playing a transmission (host only); 0 = radios are silent to AI VoiceChat
voice.RadioBandPassbooltruePlay radio transmissions through the 300-3400 Hz telephone band instead of full range VoiceChat
voice.RadioHeightfloat1.2fHeight (m) above a pawn's origin its radio hangs at, where incoming transmissions play from VoiceChat
voice.RadioSpeakerRangefloat12.0fDistance (m) out to which another player's radio is heard playing a transmission; your own radio is always heard VoiceChat
voice.RadioVolumefloat1.0fPlayback volume of radio transmissions, on top of the voice volume VoiceChat
voice.Rollofffloat1.0fProximity attenuation curve exponent: 1 = linear, higher falls off faster near the edge of hearing range VoiceChat

weapon

NameTypeDefaultDescription
weapon.DecalPoolCapacityint64Maximum live runtime-spawned impact decals; the oldest is recycled past this Game
weapon.ServerRateSlackfloat0.85fFraction of the fire interval the server tolerates between client fire requests before rejecting Plugins.Combat

wolang

NameTypeDefaultDescription
wolang.CallBudgetint20000000Ticks one call into a script may spend (one per script function entry or backward jump, in the interpreter and the compiled tier alike) before it stops with an error in the Message Log and the frame goes on. 0 = no limit. Read when a world's script machine is created. Scripting
wolang.DebugPortint4711TCP port on 127.0.0.1 a Wolang vm opens for the debugger (VS Code's Wolang extension, attach) in builds with the editor. 0 = any free port, -1 = no debugger. A second vm in the same process takes a free port; each logs its own. Scripting
wolang.HotReloadint1In builds with the editor: 1 = a saved script reloads in the playing world the next frame, keeping its state; 0 = scripts change only when play starts again. Scripting
wolang.RpcMaxBytesint1024Largest script RPC or replicated field batch in bytes, in either direction. A larger inbound one is dropped and counted; a script cannot send one. Scripting
wolang.RpcRateint30Calls per second one script actor accepts of each @Server method from its owning client (a burst of this many, then the rate). Beyond it the call is dropped and counted. 0 = no limit. Scripting

world

NameTypeDefaultDescription
world.Persistenceint1World-state journal: capture destroyed/modified/runtime-spawned persistent entities across sector streaming and saves (0 = off) Game

wp

NameTypeDefaultDescription
wp.CollisionProxyint1World-partition collision proxies: keep a coarse static collider for every streamed-out sector so long traces still hit (1 = on, 0 = off). Game
wp.CollisionProxy.MaxResidentint64How many streamed-out sectors keep a collision proxy at once; the oldest is dropped past this. Game
wp.CollisionProxy.MaxTrianglesint2000Triangle budget of one sector's collision proxy; geometry over it is simplified, then boxed. Game
wp.HLODint1World-partition HLOD: draw a low-poly proxy mesh for streamed-out sectors (1 = on, 0 = off). SceneRenderer
wp.HLOD.Atlasint1Draw an HLOD proxy with its baked albedo/normal atlas when the cook gave it one (1 = on, 0 = per-object vertex colours only). Read when a sector's proxy is first drawn. SceneRenderer
wp.HLOD.AtlasSizeint256Texel edge of the albedo/normal atlas baked into every HLOD proxy at cook (rounded up to a power of two, 16-2048; 0 = no atlas, the proxy keeps per-object vertex colours only). Game
wp.HLOD.FarRadiusfloat6000.0fMaximum distance in metres at which a streamed-out sector still draws its HLOD proxy; beyond this nothing is drawn. SceneRenderer
wp.HLOD.ResidentDistancefloat1000.0fDistance in metres past which a RESIDENT sector draws its HLOD proxy in place of its live entities (their meshes stop submitting; gameplay, physics and streaming are untouched). 0 = resident sectors always draw their entities. SceneRenderer
wp.RebaseDistancefloat8192.0fRebase the world origin when the main camera drifts this far from it (0 = off) Game
wp.RebaseGridfloat1024.0fOrigin shifts snap to this grid so rebased coordinates stay round Game

Page feedback

Was this page helpful?