Version 0.95
Engine 4.23
| Name | Help |
|---|---|
| r.AllowCachedUniformExpressions | Allow uniform expressions to be cached. |
| r.AllowDepthBoundsTest | If true, use enable depth bounds test when rendering defered lights. |
| r.AllowDownsampledStandardTranslucency | Allow standard translucency to be rendered in smaller resolution as an optimization This is incompatible with materials using blend modulate. Use 2 to ignore those. <0: off 0: on unless a material using blend modulate is used (default) >0: on and ignores any material using blend modulate |
| r.AllowGlobalClipPlane | Enables mesh shaders to support a global clip plane, needed for planar reflections, which adds about 15% BasePass GPU cost on PS4. |
| r.AllowHDR | Creates an HDR compatible swap-chain and enables HDR display output.0: Disabled (default) 1: Allow HDR, if supported by the platform and display |
| r.AllowLandscapeShadows | Allow Landscape Shadows |
| r.AllowOcclusionQueries | If zero, occlusion queries will not be used to cull primitives. |
| r.AllowPointLightCubemapShadows | When 0, will prevent point light cube map shadows from being used and the light will be unshadowed. |
| r.AllowPrecomputedVisibility | If zero, precomputed visibility will not be used to cull primitives. |
| r.AllowSimpleLights | If true, we allow simple (ie particle) lights |
| r.AllowStaticLighting | Whether to allow any static lighting to be generated and used, like lightmaps and shadowmaps. Games that only use dynamic lighting should set this to 0 to save some static lighting overhead. |
| r.AllowSubPrimitiveQueries | Enables sub primitive queries, currently only used by hierarchical instanced static meshes. 1: Enable, 0 Disabled. When disabled, one query is used for the entire proxy. |
| r.AllowVolumeTextureAssetCreation | Enable UVolumeTexture assets |
| r.AlsoUseSphereForFrustumCull | Performance tweak. If > 0, then use a sphere cull before and in addition to a box for frustum culling. |
| r.AmbientOcclusion.AsyncComputeBudget | Defines which level of EAsyncComputeBudget to use for balancing AsyncCompute work against Gfx work. Only matters if the compute version of SSAO is active (requires CS support, enabled by cvar, single pass, no normals) This is a low level developer tweak to get best performance on hardware that supports AsyncCompute. 0: least AsyncCompute 1: .. (default) 2: .. 3: .. 4: most AsyncCompute |
| r.AmbientOcclusion.Compute | If SSAO should use ComputeShader (not available on all platforms) or PixelShader. The [Async] Compute Shader version is WIP, not optimized, requires hardware support (not mobile/DX10/OpenGL3), does not use normals which allows it to run right after EarlyZPass (better performance when used with AyncCompute) AyncCompute is currently only functional on PS4. 0: PixelShader (default) 1: (WIP) Use ComputeShader if possible, otherwise fall back to ‘0’ 2: (WIP) Use AsyncCompute if efficient, otherwise fall back to ‘1’ 3: (WIP) Use AsyncCompute if possible, otherwise fall back to ‘1’ |
| r.AmbientOcclusion.Compute.Smooth | Whether to smooth SSAO output when TAA is disabled |
| r.AmbientOcclusion.Denoiser | Choose the denoising algorithm. 0: Disabled; 1: Forces the default denoiser of the renderer; 2: GScreenSpaceDenoiser witch may be overriden by a third party plugin (default). |
| r.AmbientOcclusion.Denoiser.HistoryConvolution.KernelSpreadFactor | Multiplication factor applied on the kernel sample offset (default=3). |
| r.AmbientOcclusion.Denoiser.HistoryConvolution.SampleCount | Number of samples to use for history post filter (default = 16). |
| r.AmbientOcclusion.Denoiser.ReconstructionSamples | Maximum number of samples for the reconstruction pass (default = 16). |
| r.AmbientOcclusion.Denoiser.TemporalAccumulation | Accumulates the samples over multiple frames. |
| r.AmbientOcclusion.DepthBoundsTest | Whether to use depth bounds test to cull distant pixels during AO pass. This option is only valid when pixel shader path is used (r.AmbientOcclusion.Compute=0), without upsampling. |
| r.AmbientOcclusion.FadeRadiusScale | Allows to scale the ambient occlusion fade radius (SSAO). 0.01:smallest .. 1.0:normal (default), <1:smaller, >1:larger |
| r.AmbientOcclusionLevels | Defines how many mip levels are using during the ambient occlusion calculation. This is useful when tweaking the algorithm. <0: decide based on the quality setting in the postprocess settings/volume and r.AmbientOcclusionMaxQuality (default) 0: none (disable AmbientOcclusion) 1: one 2: two (costs extra performance, soft addition) 3: three (larger radius cost less but can flicker) |
| r.AmbientOcclusionMaxQuality | Defines the max clamping value from the post process volume’s quality level for ScreenSpace Ambient Occlusion 100: don’t override quality level from the post process volume (default) 0..99: clamp down quality level from the post process volume to the maximum set by this cvar -100..0: Enforces a different quality (the absolute value) even if the postprocessvolume asks for a lower quality. |
| r.AmbientOcclusionMipLevelFactor | Controls mipmap level according to the SSAO step id 0: always look into the HZB mipmap level 0 (memory cache trashing) 0.5: sample count depends on post process settings (default) 1: Go into higher mipmap level (quality loss) |
| r.AmbientOcclusionRadiusScale | Allows to scale the ambient occlusion radius (SSAO). 0:off, 1.0:normal, <1:smaller, >1:larger |
| r.AmbientOcclusionStaticFraction | Allows to override the Ambient Occlusion Static Fraction (see post process volume). Fractions are between 0 and 1. <0: use default setting (default -1) 0: no effect on static lighting, 0 is free meaning no extra rendering pass 1: AO affects the stat lighting |
| r.AMDD3D11MultiThreadedDevice | If true, creates a multithreaded D3D11 device on AMD hardware (workaround for driver bug) Changes will only take effect in new game/editor instances – can’t be changed at runtime. |
| r.AMDDisableAsyncTextureCreation | If true, uses synchronous texture creation on AMD hardware (workaround for driver bug) Changes will only take effect in new game/editor instances – can’t be changed at runtime. |
| r.Android.DisableASTCSupport | Disable support for ASTC Texture compression if OpenGL driver supports it. (Android Only) 0 = ASTC texture compression will be used if driver supports it [default] 1 = ASTC texture compression will not be used. |
| r.Android.DisableOpenGLES31Support | Disable support for OpenGLES 3.1 API. (Android Only) 0 = OpenGLES 3.1 API will be used (providing device and project supports it) [default] 1 = OpenGLES 3.1 will be disabled, OpenGL ES2 fall back will be used. |
| r.Android.DisableVulkanSupport | Disable support for vulkan API. (Android Only) 0 = vulkan API will be used (providing device and project supports it) [default] 1 = vulkan will be disabled, opengl fall back will be used. |
| r.Android.OverrideExternalTextureSupport | Override external texture support for OpenGLES API. (Android Only) 0 = normal detection used [default] 1 = disable external texture support 2 = force ImageExternal100 (version #100 with GL_OES_EGL_image_external) 3 = force ImageExternal300 (version #300 with GL_OES_EGL_image_external) 4 = force ImageExternalESSL300 (version #300 with GL_OES_EGL_image_external_essl3) |
| r.AndroidDisableThreadedRendering | Sets whether or not to allow threaded rendering for a particular Android device profile. 0 = Allow threaded rendering [default] 1 = Disable creation of render thread on startup |
| r.AndroidDisableThreadedRenderingFirstLoad | Sets whether or not to allow threaded rendering for a particular Android device profile on the initial load. 0 = Allow threaded rendering on the initial load [default] 1 = Disable threaded rendering on the initial load |
| r.AOApplyToStaticIndirect | Whether to apply DFAO as indirect shadowing even to static indirect sources (lightmaps + stationary skylight + reflection captures) |
| r.AOAsyncBuildQueue | Whether to asynchronously build distance field volume data from meshes. |
| r.AOAverageObjectsPerCullTile | Determines how much memory should be allocated in distance field object culling data structures. Too much = memory waste, too little = flickering due to buffer overflow. |
| r.AOClearHistory | |
| r.AOComputeShaderNormalCalculation | Whether to use the compute shader version of the distance field normal computation. |
| r.AOGlobalDFClipmapDistanceExponent | Exponent used to derive each clipmap’s size, together with r.AOInnerGlobalDFClipmapDistance. |
| r.AOGlobalDFResolution | Resolution of the global distance field. Higher values increase fidelity but also increase memory and composition cost. |
| r.AOGlobalDFStartDistance | World space distance along a cone trace to switch to using the global distance field instead of the object distance fields. This has to be large enough to hide the low res nature of the global distance field, but smaller values result in faster cone tracing. |
| r.AOGlobalDistanceField | Whether to use a global distance field to optimize occlusion cone traces. The global distance field is created by compositing object distance fields into clipmaps as the viewer moves through the level. |
| r.AOGlobalDistanceFieldCacheMostlyStaticSeparately | Whether to cache mostly static primitives separately from movable primitives, which reduces global DF update cost when a movable primitive is modified. Adds another 12Mb of volume textures. |
| r.AOGlobalDistanceFieldForceFullUpdate | Whether to force full global distance field update every frame. |
| r.AOGlobalDistanceFieldLogModifiedPrimitives | Whether to log primitive modifications (add, remove, updatetransform) that caused an update of the global distance field. This can be useful for tracking down why updating the global distance field is always costing a lot, since it should be mostly cached. |
| r.AOGlobalDistanceFieldPartialUpdates | Whether to allow partial updates of the global distance field. When profiling it’s useful to disable this and get the worst case composition time that happens on camera cuts. |
| r.AOGlobalDistanceFieldRepresentHeightfields | Whether to put landscape in the global distance field. Changing this won’t propagate until the global distance field gets recached (fly away and back). |
| r.AOGlobalDistanceFieldStaggeredUpdates | Whether to allow the larger clipmaps to be updated less frequently. |
| r.AOHeightfieldOcclusion | Whether to compute AO from heightfields (landscape) |
| r.AOHistoryDistanceThreshold | World space distance threshold needed to discard last frame’s DFAO results. Lower values reduce ghosting from characters when near a wall but increase flickering artifacts. |
| r.AOHistoryStabilityPass | Whether to gather stable results to fill in holes in the temporal reprojection. Adds some GPU cost but improves temporal stability with foliage. |
| r.AOHistoryWeight | Amount of last frame’s AO to lerp into the final result. Higher values increase stability, lower values have less streaking under occluder movement. |
| r.AOJitterConeDirections | |
| r.AOListMemory | |
| r.AOListMeshDistanceFields | |
| r.AOLogObjectBufferReallocation | |
| r.AOMaxObjectBoundingRadius | Objects larger than this will not contribute to AO calculations, to improve performance. |
| r.AOMaxViewDistance | The maximum distance that AO will be computed at. |
| r.AOObjectDistanceField | Determines whether object distance fields are used to compute ambient occlusion. Only global distance field will be used when this option is disabled. |
| r.AOOverwriteSceneColor | |
| r.AOQuality | Defines the distance field AO method which allows to adjust for quality or performance. 0:off, 1:medium, 2:high (default) |
| r.AOSampleSet | 0 = Original set, 1 = Relaxed set |
| r.AOScatterTileCulling | Whether to use the rasterizer for binning occluder objects into screenspace tiles. |
| r.AOSpecularOcclusionMode | Determines how specular should be occluded by DFAO 0: Apply non-directional AO to specular. 1: (default) Intersect the reflection cone with the unoccluded cone produced by DFAO. This gives more accurate occlusion than 0, but can bring out DFAO sampling artifacts. |
| r.AOStepExponentScale | Exponent used to distribute AO samples along a cone direction. |
| r.AOUpdateGlobalDistanceField | Whether to update the global distance field, useful for debugging. |
| r.AOUseConesForGI | |
| r.AOUseHistory | Whether to apply a temporal filter to the distance field AO, which reduces flickering but also adds trails when occluders are moving. |
| r.AOUseJitter | Whether to use 4x temporal supersampling with Screen Grid DFAO. When jitter is disabled, a shorter history can be used but there will be more spatial aliasing. |
| r.AOViewFadeDistanceScale | Distance over which AO will fade out as it approaches r.AOMaxViewDistance, as a fraction of r.AOMaxViewDistance. |
| r.AsyncPipelineCompile | 0 to Create PSOs at the moment they are requested 1 to Create Pipeline State Objects asynchronously(default) |
| r.Atmosphere | Defines atmosphere will render or not. Only changed by r.Atmosphere console command. Enable/Disable Atmosphere, Load/Unload related data. 0: off (To save GPU memory) 1: on (default) |
| r.BasePassOutputsVelocity | Enables rendering WPO velocities on the base pass. 0: Renders in a separate pass/rendertarget, all movable static meshes + dynamic. 1: Renders during the regular base pass adding an extra GBuffer, but allowing motion blur on materials with Time-based WPO. |
| r.BasePassWriteDepthEvenWithFullPrepass | 0 to allow a readonly base pass, which skips an MSAA depth resolve, and allows masked materials to get EarlyZ (writing to depth while doing clip() disables EarlyZ) (default) 1 to force depth writes in the base pass. Useful for debugging when the prepass and base pass don’t match what they render. |
| r.BlackBorders | To draw black borders around the rendered image (prevents artifacts from post processing passes that read outside of the image e.g. PostProcessAA) in pixels, 0:off |
| r.Bloom.Cross | Experimental feature to give bloom kernel a more bright center sample (values between 1 and 3 work without causing aliasing) Existing bloom get lowered to match the same brightness <0 for a anisomorphic lens flare look (X only) 0 off (default) >0 for a cross look (X and Y) |
| r.Bloom.HalfResoluionFFT | Experimental half-resolution FFT Bloom convolution. 0: Standard full resolution convolution bloom. 1: Half-resolution convoltuion that excludes the center of the kernel. |
| r.BloomQuality | 0: off, no performance impact. 1: average quality, least performance impact. 2: average quality, least performance impact. 3: good quality. 4: good quality. 5: Best quality, most significant performance impact. (default) >5: force experimental higher quality on mobile (can be quite slow on some hardware) |
| r.BufferVisualizationDumpFrames | When screenshots or movies dumps are requested, also save out dumps of the current buffer visualization materials 0:off (default) 1:on |
| r.BufferVisualizationDumpFramesAsHDR | When saving out buffer visualization materials in a HDR capable format 0: Do not override default save format. 1: Force HDR format for buffer visualization materials. |
| r.BufferVisualizationOverviewTargets | Specify the list of post process materials that can be used in the buffer visualization overview. Put nothing between the commas to leave a gap. Choose from: BaseColor CustomDepth CustomStencil FinalImage ShadingModel MaterialAO Metallic Opacity Roughness SceneColor SceneDepth SeparateTranslucencyRGB SeparateTranslucencyA Specular SubsurfaceColor WorldNormal AmbientOcclusion CustomDepthWorldUnits SceneDepthWorldUnits Velocity PreTonemapHDRColor PostTonemapHDRColor |
| r.BufferVisualizationTarget | When the viewport view-mode is set to ‘Buffer Visualization’, this command specifies which of the various channels to display. Values entered other than the allowed values shown below will be ignored. BaseColor CustomDepth CustomStencil FinalImage ShadingModel MaterialAO Metallic Opacity Roughness SceneColor SceneDepth SeparateTranslucencyRGB SeparateTranslucencyA Specular SubsurfaceColor WorldNormal AmbientOcclusion CustomDepthWorldUnits SceneDepthWorldUnits Velocity PreTonemapHDRColor PostTonemapHDRColor |
| r.Cache.DrawDirectionalShadowing | Whether to draw direct shadowing sample points as generated by Lightmass. 0 is off (default), 1 is on |
| r.Cache.DrawInterpolationPoints | Whether to draw positions that indirect lighting is interpolated at when they are updated, which are stored in the cache. Probably need ‘r.CacheUpdateEveryFrame 1’ as well to be useful, otherwise points will flicker as they update. 0 is off (default), 1 is on |
| r.Cache.DrawLightingSamples | Whether to draw indirect lighting sample points as generated by Lightmass. 0 is off (default), 1 is on |
| r.Cache.LightingCacheDimension | Dimensions of the lighting cache. This should be a multiple of r.LightingCacheMovableObjectAllocationSize for least waste. |
| r.Cache.LightingCacheMovableObjectAllocationSize | Resolution of the interpolation sample volume used to light a dynamic object. Values of 1 or 2 will result in a single interpolation sample per object which does not provide continuous lighting under movement, so interpolation is done over time. Values of 3 or more support the necessary padding to provide continuous results under movement. |
| r.Cache.LimitQuerySize | 0 is off, 1 is on (default) |
| r.Cache.QueryNodeLevel | Level of the lighting sample octree whose node’s extents should be the target size for queries into the octree. Primitive blocks will be broken up into multiple octree queries if they are larger than this.0 is the root, 12 is the leaf level |
| r.Cache.ReduceSHRinging | Whether to modify indirect lighting cache SH samples to reduce ringing. 0 is off, 1 is on (default) |
| r.Cache.SampleTransitionSpeed | When using single sample lighting, controls the speed of the transition between two point samples (fade over time). |
| r.Cache.UpdateEveryFrame | Whether to update indirect lighting cache allocations every frame, even if they would have been cached. 0 is off (default), 1 is on |
| r.Cache.UpdatePrimsTaskEnabled | Enable threading for ILC primitive update. Will overlap with the rest the end of InitViews. |
| r.CapsuleDirectShadows | Whether to allow capsule direct shadowing on skinned components with bCastCapsuleDirectShadow enabled. |
| r.CapsuleIndirectConeAngle | Light source angle used when the indirect shadow direction is derived from precomputed indirect lighting (no stationary skylight present) |
| r.CapsuleIndirectShadows | Whether to allow capsule indirect shadowing on skinned components with bCastCapsuleIndirectShadow enabled. |
| r.CapsuleMaxDirectOcclusionDistance | Maximum cast distance for direct shadows from capsules. This has a big impact on performance. |
| r.CapsuleMaxIndirectOcclusionDistance | Maximum cast distance for indirect shadows from capsules. This has a big impact on performance. |
| r.CapsuleMinSkyAngle | Minimum light source angle derived from the precomputed unoccluded sky vector (stationary skylight present) |
| r.CapsuleShadowFadeAngleFromVertical | Angle from vertical up to start fading out the indirect shadow, to avoid self shadowing artifacts. |
| r.CapsuleShadows | Whether to allow capsule shadowing on skinned components with bCastCapsuleDirectShadow or bCastCapsuleIndirectShadow enabled. |
| r.CapsuleShadowsFullResolution | Whether to compute capsule shadows at full resolution. |
| r.CapsuleSkyAngleScale | Scales the light source angle derived from the precomputed unoccluded sky vector (stationary skylight present) |
| r.CatmullRomEndParamOffset | The parameter offset for catmul rom end points. |
| r.chaos.ReflectionCaptureStaticSceneOnly | 0 is off, 1 is on (default) |
| r.CheckSRVTransitions | Tests that render targets are properly transitioned to SRV when SRVs are set. |
| r.ClearCoatNormal | 0 to disable clear coat normal. 0: off 1: on |
| r.ClearSceneMethod | Select how the g-buffer is cleared in game mode (only affects deferred shading). 0: No clear 1: RHIClear (default) 2: Quad at max z |
| r.Color.Max | Allows to define where the value 1.0 in the color channels is mapped to after color grading. Value should be around 1, smaller values darken the highlights, larger values move more colors towards white, Default: 1 |
| r.Color.Mid | Allows to define where the value 0.5 in the color channels is mapped to after color grading (This is similar to a gamma correction). Value should be around 0.5, smaller values darken the mid tones, larger values brighten the mid tones, Default: 0.5 |
| r.Color.Min | Allows to define where the value 0 in the color channels is mapped to after color grading. The value should be around 0, positive: a gray scale is added to the darks, negative: more dark values become black, Default: 0 |
| r.CompileMaterialsForShaderFormat | When enabled, compile materials for this shader format in addition to those for the running platform. Note that these shaders are compiled and immediately tossed. This is only useful when directly inspecting output via r.DebugDumpShaderInfo. |
| r.CompileShadersForDevelopment | Setting this to 0 allows to ship a game with more optimized shaders as some editor and development features are not longer compiled into the shaders. Note: This should be done when shipping but it’s not done automatically yet (feature need to mature and shaders will compile slower as shader caching from development isn’t shared). Cannot be changed at runtime – can be put into BaseEngine.ini 0: off, shader can run a bit faster 1: on (Default) |
| r.CompositionForceRenderTargetLoad | 0: default engine behaviour 1: force ERenderTargetLoadAction::ELoad for all render targets |
| r.CompositionGraphDebug | Execute this command to get a single frame dump of the composition graph of one frame (post processing and lighting). |
| r.CompositionGraphOrder | Defines in which order the nodes in the CompositionGraph are executed (affects postprocess and some lighting). Option 1 provides more control, which can be useful for preserving ESRAM, avoid GPU sync, cluster up compute shaders for performance and control AsyncCompute. 0: tree order starting with the root, first all inputs then dependencies (classic UE4, unconnected nodes are not getting executed) 1: RegisterPass() call order, unless the dependencies (input and additional) require a different order (might become new default as it provides more control, executes all registered nodes) |
| r.ContactShadows | 0: disabled. 1: enabled. |
| r.CookOutUnusedDetailModeComponents | If set, components which are not relevant for the current detail mode will be cooked out. 0: keep components even if not relevant for the current detail mode. 1: cook out components not relevant for the current detail mode. |
| r.CopyLockedViews | Copies all locked views in to a string that r.LockView will accept to reload them. |
| r.CreateShadersOnLoad | Whether to create shaders on load, which can reduce hitching, but use more memory. Otherwise they will be created as needed. |
| r.CustomDepth | 0: feature is disabled 1: feature is enabled, texture is created on demand 2: feature is enabled, texture is not released until required (should be the project setting if the feature should not stall) 3: feature is enabled, stencil writes are enabled, texture is not released until required (should be the project setting if the feature should not stall) |
| r.CustomDepth.Order | When CustomDepth (and CustomStencil) is getting rendered 0: Before GBuffer (can be more efficient with AsyncCompute, allows using it in DBuffer pass, no GBuffer blending decals allow GBuffer compression) 1: After Base Pass (default) |
| r.CustomDepthTemporalAAJitter | If disabled the Engine will remove the TemporalAA Jitter from the Custom Depth Pass. Only has effect when TemporalAA is used. |
| r.CustomUnsafeZones | Allows you to set custom unsafe zones. Define them based on Portrait (P) or Landscape (L) for a device oriented ‘upright’.Unsafe zones may be either fixed or free, depending on if they move along with the rotation of the device.Format is (P:fixed[x1, y1][width, height]), semicolon-separated for each custom unsafe zone. +Values add from 0, -Values subtract from Height or Width |
| r.D3D.ForceDXC | Forces DirectX Shader Compiler (DXC) to be used for all D3D shaders. Shaders compiled with this option are only compatible with D3D12. 0: Disable (default) 1: Force new compiler for all shaders |
| r.D3D.RemoveUnusedInterpolators | Enables removing unused interpolators mode when compiling pipelines for D3D. -1: Do not actually remove, but make the app think it did (for debugging) 0: Disable (default) 1: Enable removing unused |
| r.d3d.uniformbufferrecycledepth | Number of frames before recycling freed uniform buffers . |
| r.D3D11.Depth24Bit | 0: Use 32-bit float depth buffer 1: Use 24-bit fixed point depth buffer(default) |
| r.d3d11.dumpliveobjects | When using -d3ddebug will dump a list of live d3d objects. Mostly for finding leaks. |
| r.D3D11.NVAutoFlushUAV | If enabled, use NVAPI (Nvidia) or AGS (AMD) to not flush between dispatches/draw calls 1: on (default) 0: off |
| r.D3D11.UseAllowTearing | Enable new dxgi flip mode with d3d11 |
| r.DBuffer | Enables DBuffer decal material blend modes. DBuffer decals are rendered before the base pass, allowing them to affect static lighting and skylighting correctly. When enabled, a full prepass will be forced which adds CPU / GPU cost. Several texture lookups will be done in the base pass to fetch the decal properties, which adds pixel work. 0: off 1: on (default) |
| r.DebugActionZone.ActionRatio | The action zone ratio that will be returned by FDisplayMetrics::GetDisplayMetrics on platforms that don’t have a defined safe zone (0..1) default: 1.0 |
| r.DebugLightDiscardProp | [0,1]: Proportion of lights to discard for debug/performance profiling purposes. |
| r.DebugSafeZone.Mode | The safe zone visualization mode (0..2) 0: Disabled (default) 1: Show Title Safe Zone 2: Show Action Safe Zone |
| r.DebugSafeZone.OverlayAlpha | The alpha value of the safe zone overlay (0..1) default: 0.2 |
| r.DebugSafeZone.TitleRatio | The safe zone ratio that will be returned by FDisplayMetrics::GetDisplayMetrics on platforms that don’t have a defined safe zone (0..1) default: 1.0 |
| r.Decal.FadeDurationScale | Scales the per decal fade durations. Lower values shortens lifetime and fade duration. Default is 1.0f. |
| r.Decal.FadeScreenSizeMult | Control the per decal fade screen size. Multiplies with the per-decal screen size fade threshold. Smaller means decals fade less aggressively. |
| r.Decal.StencilSizeThreshold | Control a per decal stencil pass that allows to large (screen space) decals faster. It adds more overhead per decals so this <0: optimization is disabled 0: optimization is enabled no matter how small (screen space) the decal is 0..1: optimization is enabled, value defines the minimum size (screen space) to trigger the optimization (default 0.1) |
| r.DefaultBackBufferPixelFormat | Defines the default back buffer pixel format. 0: 8bit RGBA 1: 16bit RGBA 2: Float RGB 3: Float RGBA 4: 10bit RGB, 2bit Alpha |
| r.DefaultFeature.AmbientOcclusion | Engine default (project setting) for AmbientOcclusion is (postprocess volume/camera/game setting still can override) 0: off, sets AmbientOcclusionIntensity to 0 1: on (default) |
| r.DefaultFeature.AmbientOcclusionStaticFraction | Engine default (project setting) for AmbientOcclusion is (postprocess volume/camera/game setting still can override) 0: off, sets AmbientOcclusionStaticFraction to 0 1: on (default, costs extra pass, only useful if there is some baked lighting) |
| r.DefaultFeature.AntiAliasing | Engine default (project setting) for AntiAliasingMethod is (postprocess volume/camera/game setting still can override) 0: off (no anti-aliasing) 1: FXAA (faster than TemporalAA but much more shimmering for non static cases) 2: TemporalAA (default) 3: MSAA (Forward shading only) |
| r.DefaultFeature.AutoExposure | Engine default (project setting) for AutoExposure is (postprocess volume/camera/game setting still can override) 0: off, sets AutoExposureMinBrightness and AutoExposureMaxBrightness to 1 1: on (default) |
| r.DefaultFeature.AutoExposure.ExtendDefaultLuminanceRange | Whether the default values for AutoExposure should support an extended range of scene luminance. This also change the PostProcessSettings.Exposure.MinBrightness, MaxBrightness, HistogramLogMin and HisogramLogMax to be expressed in EV100 values instead of in Luminance and Log2 Luminance. 0: Legacy range (default) 1: Extended range |
| r.DefaultFeature.AutoExposure.Method | Engine default (project setting) for AutoExposure Method (postprocess volume/camera/game setting still can override) 0: Histogram based (requires compute shader, default) 1: Basic AutoExposure |
| r.DefaultFeature.Bloom | Engine default (project setting) for Bloom is (postprocess volume/camera/game setting still can override) 0: off, set BloomIntensity to 0 1: on (default) |
| r.DefaultFeature.LensFlare | Engine default (project setting) for LensFlare is (postprocess volume/camera/game setting still can override) 0: off, sets LensFlareIntensity to 0 1: on (default) |
| r.DefaultFeature.LightUnits | Default units to use for point, spot and rect lights 0: unitless 1: candelas (default) 2: lumens |
| r.DefaultFeature.MotionBlur | Engine default (project setting) for MotionBlur is (postprocess volume/camera/game setting still can override) 0: off, sets MotionBlurAmount to 0 1: on (default) |
| r.DeferSkeletalDynamicDataUpdateUntilGDME | If > 0, then do skeletal mesh dynamic data updates will be deferred until GDME. Experimental option. |
| r.DeferUniformExpressionCaching | Whether to defer caching of uniform expressions until a rendering command needs them up to date. Deferring updates is more efficient because multiple SetVectorParameterValue calls in a frame will only result in one update. |
| r.DeferUpdateRenderStates | Whether to defer updating the render states of material parameter collections when a paramter is changed until a rendering command needs them up to date. Deferring updates is more efficient because multiple SetVectorParameterValue and SetScalarParameterValue calls in a frame will only result in one update. |
| r.DelaySceneRenderCompletion | Experimental option to postpone the cleanup of the scene renderer until later. This does NOT currently work because it is possible for the scene to be modified before ~FSceneRenderer, and that assumes the scene is unchanged. |
| r.DemosaicVposOffset | This offset is added to the rasterized position used for demosaic in the ES2 tonemapping shader. It exists to workaround driver bugs on some Android devices that have a half-pixel offset. |
| r.DepthOfField.DepthBlur.Amount | This scale multiplier only affects the CircleDOF DepthBlur feature (value defines in how many km the radius goes to 50%). x: Multiply the existing Depth Blur Amount with x -x: Override the existing Depth Blur Amount with x (in km) 1: No adjustments (default) |
| r.DepthOfField.DepthBlur.ResolutionScale | This scale multiplier only affects the CircleDOF DepthBlur feature. It’s a temporary hack. It lineary scale the DepthBlur by the resolution increase over 1920 (in width), does only affect resolution larger than that. Actual math: float Factor = max(ViewWidth / 1920 – 1, 0); DepthBlurRadius *= 1 + Factor * (CVar – 1) 1: No adjustments (default) x: if the resolution is 1920 there is no change, if 2x larger than 1920 it scale the radius by x |
| r.DepthOfField.DepthBlur.Scale | This scale multiplier only affects the CircleDOF DepthBlur feature. This is applied after r.DepthOfField.DepthBlur.ResolutionScale. 0: Disable Depth Blur x: Multiply the existing Depth Blur Radius with x -x: Override the existing Depth Blur Radius with x 1: No adjustments (default) |
| r.DepthOfField.MaxSize | Allows to clamp the gaussian depth of field radius (for better performance), default: 100 |
| r.DepthOfField.NearBlurSizeThreshold | Sets the minimum near blur size before the effect is forcably disabled. Currently only affects Gaussian DOF. (default: 0.01) |
| r.DepthOfFieldQuality | Allows to adjust the depth of field quality. Currently only fully affects BokehDOF. GaussianDOF is either 0 for off, otherwise on. 0: Off 1: Low 2: high quality (default, adaptive, can be 4x slower) 3: very high quality, intended for non realtime cutscenes, CircleDOF only (slow) 4: extremely high quality, intended for non realtime cutscenes, CircleDOF only (very slow) |
| r.DetailMode | Current detail mode; determines whether components of actors should be updated/ ticked. 0: low, show only object with DetailMode low or higher 1: medium, show all object with DetailMode medium or higher 2: high, show all objects (default) |
| r.DFFullResolution | 1 = full resolution distance field shadowing, 0 = half resolution with bilateral upsample. |
| r.DFShadowAverageObjectsPerCullTile | Determines how much memory should be allocated in distance field object culling data structures. Too much = memory waste, too little = flickering due to buffer overflow. |
| r.DFShadowCullTileWorldSize | World space size of a tile used for culling for directional lights. |
| r.DFShadowQuality | Defines the distance field shadow method which allows to adjust for quality or performance. 0:off, 1:medium (less samples, no SSS), 2:high (default) |
| r.DFShadowScatterTileCulling | Whether to use the rasterizer to scatter objects onto the tile grid for culling. |
| r.DFTwoSidedMeshDistanceBias | World space amount to expand distance field representations of two sided meshes. This is useful to get tree shadows to match up with standard shadow mapping. |
| r.DiffuseColor.Max | Allows quick material test by remapping the diffuse color at 1 to a new value (0..1), Only for non shipping built! 1: (default) |
| r.DiffuseColor.Min | Allows quick material test by remapping the diffuse color at 1 to a new value (0..1), Only for non shipping built! 1: (default) |
| r.DiffuseIndirect.Denoiser | Denoising options (default = 1) |
| r.DisableDistortion | Prevents distortion effects from rendering. Saves a full-screen framebuffer’s worth of memory. |
| r.DisableEngineAndAppRegistration | If true, disables engine and app registration, to disable GPU driver optimizations during debugging and development Changes will only take effect in new game/editor instances – can’t be changed at runtime. |
| r.DisableLODFade | Disable fading for distance culling |
| r.DiscardUnusedQuality | Whether to keep or discard unused quality level shadermaps in memory. 0: keep all quality levels in memory. (default) 1: Discard unused quality levels on load. |
| r.DisplayInternals | Allows to enable screen printouts that show the internals on the engine/renderer This is mostly useful to be able to reason why a screenshots looks different. 0: off (default) 1: enabled |
| r.DistanceFadeMaxTravel | Max distance that the player can travel during the fade time. |
| r.DistanceFieldAO | Whether the distance field AO feature is allowed, which is used to implement shadows of Movable sky lights from static meshes. |
| r.DistanceFieldBuild.Compress | Whether to store mesh distance fields compressed in memory, which reduces how much memory they take, but also causes serious hitches when making new levels visible. Only enable if your project does not stream levels in-game. Changing this regenerates all mesh distance fields. |
| r.DistanceFieldBuild.EightBit | Whether to store mesh distance fields in an 8 bit fixed point format instead of 16 bit floating point. 8 bit uses half the memory, but introduces artifacts for large meshes or thin meshes. |
| r.DistanceFieldBuild.UseEmbree | Whether to use embree ray tracer for mesh distance field generation. |
| r.DistanceFieldGI | |
| r.DistanceFields | Enables distance fields rendering. 0: Disabled. 1: Enabled. |
| r.DistanceFields.AtlasSizeXY | Max size of the global mesh distance field atlas volume texture in X and Y. |
| r.DistanceFields.AtlasSizeZ | Max size of the global mesh distance field atlas volume texture in Z. |
| r.DistanceFields.DefaultVoxelDensity | Determines how the default scale of a mesh converts into distance field voxel dimensions. Changing this will cause all distance fields to be rebuilt. Large values can consume memory very quickly! |
| r.DistanceFields.ForceAtlasRealloc | Force a full realloc. |
| r.DistanceFields.ForceMaxAtlasSize | When enabled, we’ll always allocate the largest possible volume texture for the distance field atlas regardless of how many blocks we need. This is an optimization to avoid re-packing the texture, for projects that are expected to always require the largest amount of space. |
| r.DistanceFields.MaxPerMeshResolution | Highest resolution (in one dimension) allowed for a single static mesh asset, used to cap the memory usage of meshes with a large scale. Changing this will cause all distance fields to be rebuilt. Large values such as 512 can consume memory very quickly! (128Mb for one asset at 512) |
| r.DistanceFields.ParallelAtlasUpdate | Whether to parallelize distance field data decompression and copying to upload buffer |
| r.DistanceFields.ThrottleCopyToAtlasInBytes | When enabled (higher than 0), throttle mesh distance field copy to global mesh distance field atlas volume (in bytes uncompressed). |
| r.DistanceFieldShadowing | Whether the distance field shadowing feature is allowed. |
| r.DOF.Gather.AccumulatorQuality | Controles the quality of the gathering accumulator. |
| r.DOF.Gather.EnableBokehSettings | Whether to applies bokeh settings on foreground and background gathering. 0: Disable; 1: Enable (default). |
| r.DOF.Gather.PostfilterMethod | Method to use to post filter a gather pass. 0: None; 1: Per RGB channel median 3×3 (default); 2: Per RGB channel max 3×3. |
| r.DOF.Gather.RingCount | Number of rings for gathering kernels [[3; 5]]. Default to 5. |
| r.DOF.Kernel.MaxBackgroundRadius | Maximum size of the background bluring radius in screen space (default=0.025). |
| r.DOF.Kernel.MaxForegroundRadius | Maximum size of the foreground bluring radius in screen space (default=0.025). |
| r.DOF.Recombine.EnableBokehSettings | Whether to applies bokeh settings on slight out of focus done in recombine pass. 0: Disable; 1: Enable (default). |
| r.DOF.Recombine.MinFullresBlurRadius | Minimal blurring radius used in full resolution pixel width to actually do DOF when slight out of focus is enabled (default = 0.1). |
| r.DOF.Recombine.Quality | Configures the quality of the recombine pass. 0: No slight out of focus; 1: Slight out of focus 24spp; 2: Slight out of focus 32spp (default). |
| r.DOF.Scatter.BackgroundCompositing | Compositing mode of the background hybrid scattering. 0: Disabled; 1: Additive; 2: Gather occlusion (default). |
| r.DOF.Scatter.EnableBokehSettings | Whether to enable bokeh settings on scattering. 0: Disable; 1: Enable (default). |
| r.DOF.Scatter.ForegroundCompositing | Compositing mode of the foreground hybrid scattering. 0: Disabled; 1: Additive (default). |
| r.DOF.Scatter.MaxSpriteRatio | Maximum ratio of scattered pixel quad as sprite, usefull to control DOF’s scattering upperbound. 1 will allow to scatter 100% pixel quads, whereas 0.2 will only allow 20% (default = 0.1). |
| r.DOF.Scatter.MinCocRadius | Minimal Coc radius required to be scattered (default = 3). |
| r.DOF.Scatter.NeighborCompareMaxColor | Controles the linear color clamping upperbound applied before color of pixel and neighbors are compared. To low, and you may not scatter enough; to high you may scatter unnecessarily too much in highlights (Default: 10). |
| r.DOF.TemporalAAQuality | Quality of temporal AA pass done in DOF. 0: Faster but lower quality; 1: Higher quality pass (default). |
| r.DoInitViewsLightingAfterPrepass | Delays the lighting part of InitViews until after the prepass. This improves the threading throughput and gets the prepass to the GPU ASAP. Experimental options; has an unknown race. |
| r.DoLazyStaticMeshUpdate | If true, then do not add meshes to the static mesh draw lists until they are visible. Experiemental option. |
| r.DontLimitOnBattery | 0: Limit performance on devices with a battery.(default) 1: Do not limit performance due to device having a battery. |
| r.DoPrepareDistanceFieldSceneAfterRHIFlush | If true, then do the distance field scene after the RHI sync and flush. Improves pipelining. |
| r.DoTiledReflections | Compute Reflection Environment with Tiled compute shader.. 0: off 1: on (default) |
| r.Downsample.Quality | Defines the quality in which the Downsample passes. we might add more quality levels later. 0: low quality >0: high quality (default: 3) |
| r.DownsampledOcclusionQueries | Whether to issue occlusion queries to a downsampled depth buffer |
| r.DrawRectangleOptimization | Controls an optimization for DrawRectangle(). When enabled a triangle can be used to draw a quad in certain situations (viewport sized quad). Using a triangle allows for slightly faster post processing in lower resolutions but can not always be used. 0: Optimization is disabled, DrawDenormalizedQuad always render with quad 1: Optimization is enabled, a triangle can be rendered where specified (default) |
| r.DriverDetectionMethod | Defines which implementation is used to detect the GPU driver (to check for old drivers, logs and statistics) 0: Iterate available drivers in registry and choose the one with the same name, if in question use next method (happens) 1: Get the driver of the primary adapter (might not be correct when dealing with multiple adapters) 2: Use DirectX LUID (would be the best, not yet implemented) 3: Use Windows functions, use the primary device (might be wrong when API is using another adapter) 4: Use Windows functions, use names such as DirectX Device (newest, most promising) |
| r.DumpingMovie | Allows to dump each rendered frame to disk (slow fps, names MovieFrame..). <=0:off (default), <0:remains on, >0:remains on for n frames (n is the number specified) |
| r.DumpPipelineCache | Dump current cache stats. |
| r.DumpRenderTargetPoolMemory | Dump allocation information for the render target pool. |
| r.DumpSCWQueuedJobs | When set to 1, it will dump a job list to help track down crashes that happened on ShaderCompileWorker. |
| r.DumpShaderDebugInfo | When set to 1, will cause any material shaders that are then compiled to dump debug info to GameName/Saved/ShaderDebugInfo The debug info is platform dependent, but usually includes a preprocessed version of the shader source. Global shaders automatically dump debug info if r.ShaderDevelopmentMode is enabled, this cvar is not necessary. On iOS, if the PowerVR graphics SDK is installed to the default path, the PowerVR shader compiler will be called and errors will be reported during the cook. |
| r.DumpShaderDebugShortNames | Only valid when r.DumpShaderDebugInfo=1. When set to 1, will shorten names factory and shader type folder names to avoid issues with long paths. |
| r.DumpShaderDebugWorkerCommandLine | Only valid when r.DumpShaderDebugInfo=1. When set to 1, it will generate a file that can be used with ShaderCompileWorker’s -directcompile. |
| r.DumpShadows | Dump shadow setup (for developer only, only for non shiping build) |
| r.DumpTransitionsForResource | Prints callstack when the given resource is transitioned. Only implemented for DX11 at the moment.Name of the resource to dump |
| r.DX11NumForcedGPUs | Num Forced GPUs. |
| r.DynamicRes.ChangePercentageThreshold | Minimal increase percentage threshold to alow when changing resolution. |
| r.DynamicRes.CPUBoundScreenPercentage | Screen percentage to converge to when CPU bound. This can be used when GPU and CPU share same memory. |
| r.DynamicRes.CPUTimeHeadRoom | Head room for the threads compared GPU time to avoid keep getting resolution fraction shrinking down when CPU bound (in milliseconds). |
| r.DynamicRes.FrameTimeBudget | Frame’s time budget in milliseconds. |
| r.DynamicRes.FrameWeightExponent | Recursive weight of frame N-1 against frame N. |
| r.DynamicRes.GPUTimingMeasureMethod | Selects the method to use to measure GPU timings. 0: Same as stat unit (default); 1: Timestamp queries. |
| r.DynamicRes.HistorySize | Number of frames keept in the history. |
| r.DynamicRes.IncreaseAmortizationBlendFactor | Amortization blend factor when scale resolution back up to reduce resolution fraction oscillations. |
| r.DynamicRes.MaxConsecutiveOverbudgetGPUFrameCount | Maximum number of consecutive frame tolerated over GPU budget. |
| r.DynamicRes.MaxScreenPercentage | Maximal screen percentage. |
| r.DynamicRes.MinResolutionChangePeriod | Minimal number of frames between resolution changes, important to avoid input sample position interferences in TAA upsample. |
| r.DynamicRes.MinScreenPercentage | Minimal screen percentage. |
| r.DynamicRes.OperationMode | Select the operation mode for dynamic resolution. 0: Disabled (default); 1: Enable according to the game user settings; 2: Enable regardless of the game user settings. |
| r.DynamicRes.OutlierThreshold | Ignore frame timing that have Game thread or render thread X time more than frame budget. |
| r.DynamicRes.TargetedGPUHeadRoomPercentage | Targeted GPU headroom (in percent from r.DynamicRes.FrameTimeBudget). |
| r.DynamicRes.TestScreenPercentage | Forces the screen percentage to a particular value with dynamic res. 0: Disabled (default); > 0: Screen percentage is enabled. |
| r.EarlyZPass | Whether to use a depth only pass to initialize Z culling for the base pass. Cannot be changed at runtime. Note: also look at r.EarlyZPassMovable 0: off 1: good occluders only: not masked, and large on screen 2: all opaque (including masked) x: use built in heuristic (default is 3) |
| r.EarlyZPassOnlyMaterialMasking | Whether to compute materials’ mask opacity only in early Z pass. Changing this setting requires restarting the editor. Note: Needs r.EarlyZPass == 2 && r.EarlyZPassMovable == 1 |
| r.Editor.2DGridFade | Tweak to define the grid rendering in 2D viewports. |
| r.Editor.2DSnapFade | Tweak to define the grid rendering in 2D viewports. |
| r.Editor.2DSnapMin | Tweak to define the grid rendering in 2D viewports. |
| r.Editor.2DSnapScale | Tweak to define the grid rendering in 2D viewports. |
| r.Editor.3DGridFade | Tweak to define the grid rendering in 3D viewports. |
| r.Editor.3DSnapFade | Tweak to define the grid rendering in 3D viewports. |
| r.Editor.AlignedOrthoZoom | Only affects the editor ortho viewports. 0: Each ortho viewport zoom in defined by the viewport width 1: All ortho viewport zoom are locked to each other to allow axis lines to be aligned with each other. |
| r.Editor.MovingPattern | 0:animation over time is off (default is 1) |
| r.Editor.NewLevelGrid | Wether to show the new editor level grid 0: off 1: Analytical Antialiasing 2: Texture based(default) |
| r.Editor.OpaqueGizmo | 0..1 0: occluded gizmo is partly transparent (default), 1:gizmo is never occluded |
| r.Editor.SkipSourceControlCheckForEditablePackages | Whether to skip the source control status check for editable packages, 0: Disable (Default), 1: Enable |
| r.EmitMeshDrawEvents | Emits a GPU event around each drawing policy draw call. /nUseful for seeing stats about each draw call, however it greatly distorts total time and time per draw call. |
| r.Emitter.FastPoolEnable | Should we use fast pools for emitters. 0: Don’t pool anything 1: Pool the emitters bro (default) |
| r.Emitter.FastPoolMaxFreeSize | Max free pool size to keep around without cleaning up. |
| r.EmitterSpawnRateScale | A global scale upon the spawn rate of emitters. Emitters can choose to apply or ignore it via their bApplyGlobalSpawnRateScale property. |
| r.EnableAsyncComputeTranslucencyLightingVolumeClear | Whether to clear the translucency lighting volume using async compute. |
| r.EnableDebugSpam_GetObjectPositionAndScale | Enables or disables debug log spam for a bug in FParticleSystemSceneProxy::GetObjectPositionAndScale() |
| r.EnableMorphTargets | Enable Morph Targets |
| r.EnableMultiGPUForkAndJoin | Whether to allow unused GPUs to speedup rendering by sharing work. |
| r.EnableStereoEmulation | Emulate stereo rendering |
| r.ExpandAllOcclusionTestedBBoxesAmount | Amount to expand all occlusion test bounds by. |
| r.ExpandNewlyOcclusionTestedBBoxesAmount | If we don’t occlusion test a primitive for r.GFramesNotOcclusionTestedToExpandBBoxes frames, then we expand the BBox when we do occlusion test it for a few frames by this amount. See also r.FramesToExpandNewlyOcclusionTestedBBoxes, r.GFramesNotOcclusionTestedToExpandBBoxes. |
| r.ExposureOffset | For adjusting the exposure on top of post process settings and eye adaptation. For developers only. 0:default |
| r.EyeAdaptation.Basic.Compute | Use Pixel or Compute Shader to compute the basic eye adaptation. = 0 : Pixel Shader > 0 : Compute Shader (default) |
| r.EyeAdaptation.EditorOnly | When pre-exposure is enabled, 0 to enable it everywhere, 1 to enable it only in the editor (default). This is to because it currently has an impact on the renderthread performance |
| r.EyeAdaptation.Focus | Applies to basic adapation mode only 0: Uniform weighting >0: Center focus, 1 is a good number (default) |
| r.EyeAdaptation.MethodOveride | Overide the camera metering method set in post processing volumes -2: override with custom settings (for testing Basic Mode) -1: no override 1: Auto Histogram-based 2: Auto Basic 3: Manual |
| r.EyeAdaptation.PreExposureOverride | Overide the scene pre-exposure by a custom value. = 0 : No override > 0 : Override PreExposure |
| r.EyeAdaptationQuality | Defines the eye adaptation quality which allows to adjust for quality or performance. <=0: off (fastest) 1: low quality (e.g. non histogram based, not yet implemented) 2: normal quality (default) 3: high quality (e.g. screen position localized, not yet implemented) |
| r.FastBlurThreshold | Defines at what radius the Gaussian blur optimization kicks in (estimated 25% – 40% faster). The optimization uses slightly less memory and has a quality loss on smallblur radius. 0: use the optimization always (fastest, lowest quality) 3: use the optimization starting at a 3 pixel radius (quite fast) 7: use the optimization starting at a 7 pixel radius (default) >15: barely ever use the optimization (high quality) |
| r.FastVRam.BokehDOF | |
| r.FastVRam.CircleDOF | |
| r.FastVRam.CombineLUTs | |
| r.FastVRam.CustomDepth | |
| r.FastVRam.DBufferA | |
| r.FastVRam.DBufferB | |
| r.FastVRam.DBufferC | |
| r.FastVRam.DBufferMask | |
| r.FastVRam.DistanceFieldAOBentNormal | |
| r.FastVRam.DistanceFieldAODownsampledBentNormal | |
| r.FastVRam.DistanceFieldAOHistory | |
| r.FastVRam.DistanceFieldAOScreenGridResources | |
| r.FastVRam.DistanceFieldCulledObjectBuffers | |
| r.FastVRam.DistanceFieldIrradiance | |
| r.FastVRam.DistanceFieldNormal | |
| r.FastVRam.DistanceFieldShadows | |
| r.FastVRam.DistanceFieldTileIntersectionResources | |
| r.FastVRam.Distortion | |
| r.FastVRam.DOFPostfilter | |
| r.FastVRam.DOFReduce | |
| r.FastVRam.DOFSetup | |
| r.FastVRam.Downsample | |
| r.FastVRam.EyeAdaptation | |
| r.FastVRam.ForwardLightingCullingResources | |
| r.FastVRam.GBufferA | |
| r.FastVRam.GBufferB | |
| r.FastVRam.GBufferC | |
| r.FastVRam.GBufferD | |
| r.FastVRam.GBufferE | |
| r.FastVRam.GBufferVelocity | |
| r.FastVRam.GlobalDistanceFieldCullGridBuffers | |
| r.FastVRam.Histogram | |
| r.FastVRam.HistogramReduce | |
| r.FastVRam.HZB | |
| r.FastVRam.LightAccumulation | |
| r.FastVRam.LightAttenuation | |
| r.FastVRam.LPV | |
| r.FastVRam.MotionBlur | |
| r.FastVRam.PostProcessMaterial | |
| r.FastVRam.SceneColor | |
| r.FastVRam.SceneDepth | |
| r.FastVRam.ScreenSpaceAO | |
| r.FastVRam.ScreenSpaceShadowMask | |
| r.FastVRam.SeparateTranslucency | |
| r.FastVRam.ShadowCSM | |
| r.FastVRam.ShadowPerObject | |
| r.FastVRam.ShadowPointLight | |
| r.FastVRam.SSR | |
| r.FastVRam.Tonemap | |
| r.FastVRam.Upscale | |
| r.FastVRam.VelocityFlat | |
| r.FastVRam.VelocityMax | |
| r.FastVRam.VolumetricFog | |
| r.FeatureLevelPreview | If 1 the quick settings menu will contain an option to enable feature level preview modes |
| r.Filter.LoopMode | Controls when to use either dynamic or unrolled loops to iterates over the Gaussian filtering. This passes is used for Gaussian Blur, Bloom and Depth of Field. The dynamic loop allows up to 128 samples versus the 32 samples of unrolled loops, but add an additional cost for the loop’s stop test at every iterations. 0: Unrolled loop only (default; limited to 32 samples). 1: Fall back to dynamic loop if needs more than 32 samples. 2: Dynamic loop only. |
| r.Filter.NewMethod | Affects bloom and Gaussian depth of field. 0: old method (doesn’t scale linearly with size) 1: new method, might need asset tweak (default) |
| r.Filter.SizeScale | Allows to scale down or up the sample count used for bloom and Gaussian depth of field (scale is clamped to give reasonable results). Values down to 0.6 are hard to notice 1 full quality (default) >1 more samples (slower) <1 less samples (faster, artifacts with HDR content or boxy results with GaussianDOF) |
| r.FinishCurrentFrame | If on, the current frame will be forced to finish and render to the screen instead of being buffered. This will improve latency, but slow down overall performance. |
| r.FlushMaterialUniforms | |
| r.FlushRHIThreadOnSTreamingTextureLocks | If set to 0, we won’t do any flushes for streaming textures. This is safe because the texture streamer deals with these hazards explicitly. |
| r.Fog | 0: disabled 1: enabled (default) |
| r.FogDensity | Allows to override the FogDensity setting (needs ExponentialFog in the level). Using a strong value allows to quickly see which pixel are affected by fog. Using a start distance allows to cull pixels are can speed up rendering. <0: use default settings (default: -1) >=0: override settings by the given value (0:off, 1=very dense fog) |
| r.FogStartDistance | Allows to override the FogStartDistance setting (needs ExponentialFog in the level). <0: use default settings (default: -1) >=0: override settings by the given value (in world units) |
| r.ForceAllCoresForShaderCompiling | When set to 1, it will ignore INI settings and launch as many ShaderCompileWorker instances as cores are available. Improves shader throughput but for big projects it can make the machine run OOM |
| r.ForceAMDToSM4 | Forces AMD devices to use SM4.0/D3D10.0 feature level. |
| r.ForceDebugViewModes | 0: Setting has no effect. 1: Forces debug view modes to be available, even on cooked builds.2: Forces debug view modes to be unavailable, even on editor builds. Removes many shader permutations for faster shader iteration. |
| r.ForceHighestMipOnUITextures | If set to 1, texutres in the UI Group will have their highest mip level forced. |
| r.ForceIntelToSM4 | Forces Intel devices to use SM4.0/D3D10.0 feature level. |
| r.ForceLOD | LOD level to force, -1 is off. |
| r.ForceLODShadow | LOD level to force for the shadow map generation only, -1 is off. |
| r.ForceNvidiaToSM4 | Forces Nvidia devices to use SM4.0/D3D10.0 feature level. |
| r.ForceSceneHasDecals | Whether to always assume that scene has decals, so we don’t switch depth state conditionally. This can significantly reduce total number of PSOs at a minor GPU cost. |
| r.ForceStripAdjacencyDataDuringCooking | If set, adjacency data will be stripped for all static and skeletal meshes during cooking (acting like the target platform did not support tessellation). |
| r.Forward.LightGridPixelSize | Size of a cell in the light grid, in pixels. |
| r.Forward.LightGridSizeZ | Number of Z slices in the light grid. |
| r.Forward.LightLinkedListCulling | Uses a reverse linked list to store culled lights, removing the fixed limit on how many lights can affect a cell – it becomes a global limit instead. |
| r.Forward.MaxCulledLightsPerCell | Controls how much memory is allocated for each cell for light culling. When r.Forward.LightLinkedListCulling is enabled, this is used to compute a global max instead of a per-cell limit on culled lights. |
| r.ForwardShading | Whether to use forward shading on desktop platforms – requires Shader Model 5 hardware. Forward shading has lower constant cost, but fewer features supported. 0:off, 1:on This rendering path is a work in progress with many unimplemented features, notably only a single reflection capture is applied per object and no translucency dynamic shadow receiving. |
| r.FramesToExpandNewlyOcclusionTestedBBoxes | If we don’t occlusion test a primitive for r.GFramesNotOcclusionTestedToExpandBBoxes frames, then we expand the BBox when we do occlusion test it for this number of frames. See also r.GFramesNotOcclusionTestedToExpandBBoxes, r.ExpandNewlyOcclusionTestedBBoxesAmount |
| r.FreeSkeletalMeshBuffers | Controls whether skeletal mesh buffers are kept in CPU memory to support merging of skeletal meshes. 0: Keep buffers(default) 1: Free buffers |
| r.FreezeMouseCursor | Free the mouse cursor position, for passes which use it to display debug information. 0: default 1: freeze mouse cursor position at current location |
| r.FrustumCullNumWordsPerTask | Performance tweak. Controls the granularity for the ParallelFor for frustum culling. |
| r.FullScreenMode | Defines how we do full screen when requested (e.g. command line option -fullscreen or in ini [SystemSettings] fullscreen=true) 0: normal full screen (renders faster, more control over vsync, less GPU memory, 10bit color if possible) 1: windowed full screen (quick switch between applications and window mode, slight performance loss) any other number behaves like 0 |
| r.Gamma | Gamma on output |
| r.GBufferFormat | Defines the memory layout used for the GBuffer. (affects performance, mostly through bandwidth, quality of normals and material attributes). 0: lower precision (8bit per component, for profiling) 1: low precision (default) 3: high precision normals encoding 5: high precision |
| r.GeneralPurposeTweak | Useful for low level shader development to get quick iteration time without having to change any c++ code. Value maps to Frame.GeneralPurposeTweak inside the shaders. Example usage: Multiplier on some value to tweak, toggle to switch between different algorithms (Default: 1.0) DON’T USE THIS FOR ANYTHING THAT IS CHECKED IN. Compiled out in SHIPPING to make cheating a bit harder. |
| r.GenerateLandscapeGIData | Whether to generate a low-resolution base color texture for landscapes for rendering real-time global illumination. This feature requires GenerateMeshDistanceFields is also enabled, and will increase mesh build times and memory usage. |
| r.GenerateMeshDistanceFields | Whether to build distance fields of static meshes, needed for distance field AO, which is used to implement Movable SkyLight shadows. Enabling will increase mesh build times and memory usage. Changing this value will cause a rebuild of all static meshes. |
| r.GeometryCollectionTripleBufferUploads | Whether to triple buffer geometry collection uploads, which allows Lock_NoOverwrite uploads which are much faster on the GPU with large amounts of data. |
| r.GFramesNotOcclusionTestedToExpandBBoxes | If we don’t occlusion test a primitive for this many frames, then we expand the BBox when we do occlusion test it for a few frames. See also r.ExpandNewlyOcclusionTestedBBoxesAmount, r.FramesToExpandNewlyOcclusionTestedBBoxes |
| r.GlobalIllumination.Denoiser.HistoryConvolution.KernelSpreadFactor | Multiplication factor applied on the kernel sample offset (default=3). |
| r.GlobalIllumination.Denoiser.HistoryConvolution.SampleCount | Number of samples to use for history post filter (default = 1). |
| r.GlobalIllumination.Denoiser.PreConvolution | Number of pre-convolution passes (default = 1). |
| r.GlobalIllumination.Denoiser.ReconstructionSamples | Maximum number of samples for the reconstruction pass (default = 16). |
| r.GlobalIllumination.Denoiser.TemporalAccumulation | Accumulates the samples over multiple frames. |
| r.GPUBusyWait | <=0:off, >0: keep the GPU busy with n units of some fixed amount of work, independent on the resolution This can be useful to make GPU timing experiments. The value should roughly represent milliseconds. Clamped at 500. |
| r.gpucrash.collectionenable | Stores GPU crash data from scoped events when a applicable crash debugging system is available. |
| r.gpucrash.datadepth | Limits the amount of marker scope depth we record for GPU crash debugging to the given scope depth. |
| r.GPUCrashDebugging | Enable vendor specific GPU crash analysis tools |
| r.GPUCsvStatsEnabled | Enables or disables GPU stat recording to CSVs |
| r.GPUDefrag.AllowOverlappedMoves | Allows defrag relocations that partially overlap themselves. |
| r.GPUDefrag.EnableTimeLimits | Limits CPU time spent doing GPU defragmentation. |
| r.GPUDefrag.MaxRelocations | Limits the number of total relocations in a frame regardless of number of bytes moved.. |
| r.GPUParticle.AFRReinject | Toggle optimization when running in AFR to re-inject particle injections on the next GPU rather than doing a slow GPU->GPU transfer of the texture data 0: Reinjection off 1: Reinjection on |
| r.GPUParticle.FixDeltaSeconds | GPU particle fix delta seconds. |
| r.GPUParticle.FixTolerance | Delta second tolerance before switching to a fix delta seconds. |
| r.GPUParticle.MaxNumIterations | Max number of iteration when using a fix delta seconds. |
| r.GPUParticle.Simulate | Enable or disable GPU particle simulation |
| r.GPUScene.MaxPooledUploadBufferSize | Maximum size of GPU Scene upload buffer size to pool. |
| r.GPUScene.UploadEveryFrame | Whether to upload the entire scene’s primitive data every frame. Useful for debugging. |
| r.GPUScene.ValidatePrimitiveBuffer | Whether to readback the GPU primitive data and assert if it doesn’t match the RT primitive data. Useful for debugging. |
| r.GPUSkin.Limit2BoneInfluences | Whether to use 2 bones influence instead of default 4 for GPU skinning. Cannot be changed at runtime. |
| r.GpuSkin.Pool | Should we pool gpu skins. 0: Don’t pool anything 1: Pool gpu skins bro (default) |
| r.GPUStatsChildTimesIncluded | If this is enabled, the child stat timings will be included in their parents’ times. This presents problems for non-hierarchical stats if we’re expecting them to add up to the total GPU time, so we probably want this disabled. |
| r.GPUStatsEnabled | Enables or disables GPU stat recording |
| r.GPUStatsMaxQueriesPerFrame | Limits the number of timestamps allocated per frame. -1 = no limit |
| r.GPUTracingStatsEnabled | Enables or disables GPU stat recording to tracing profiler |
| r.GraphicsAdapter | User request to pick a specific graphics adapter (e.g. when using a integrated graphics card with a discrete one) For Windows D3D, unless a specific adapter is chosen we reject Microsoft adapters because we don’t want the software emulation. This takes precedence over -prefer{AMD|NVidia|Intel} when the value is >= 0. -2: Take the first one that fulfills the criteria -1: Favour non integrated because there are usually faster (default) 0: Adapter #0 1: Adapter #1, … |
| r.GTSyncType | Determines how the game thread syncs with the render thread, RHI thread and GPU. Syncing to the GPU swap chain flip allows for lower frame latency. 0 – Sync the game thread with the render thread (default). 1 – Sync the game thread with the RHI thread. 2 – Sync the game thread with the GPU swap chain flip (only on supported platforms). |
| r.HDR.Display.ColorGamut | Color gamut of the output display: 0: Rec709 / sRGB, D65 (default) 1: DCI-P3, D65 2: Rec2020 / BT2020, D65 3: ACES, D60 4: ACEScg, D60 |
| r.HDR.Display.OutputDevice | Device format of the output display: 0: sRGB (LDR) 1: Rec709 (LDR) 2: Explicit gamma mapping (LDR) 3: ACES 1000 nit ST-2084 (Dolby PQ) (HDR) 4: ACES 2000 nit ST-2084 (Dolby PQ) (HDR) 5: ACES 1000 nit ScRGB (HDR) 6: ACES 2000 nit ScRGB (HDR) 7: Linear EXR (HDR) 8: Linear final color, no tone curve (HDR) |
| r.HDR.EnableHDROutput | Creates an HDR compatible swap-chain and enables HDR display output.0: Disabled (default) 1: Enable hardware-specific implementation |
| r.HDR.UI.CompositeMode | Mode used when compositing the UI layer: 0: Standard compositing 1: Shader pass to improve HDR blending |
| r.HDR.UI.Level | Luminance level for UI elements when compositing into HDR framebuffer (default: 1.0). |
| r.HeightfieldGlobalIllumination | |
| r.HeightfieldInnerBounceDistance | |
| r.HeightfieldOuterBounceDistanceScale | |
| r.HeightfieldTargetUnitsPerTexel | |
| r.HighQualityLightMaps | If set to 1, allow high quality lightmaps which don’t bake in direct lighting of stationary lights |
| r.HighResScreenshotDelay | When high-res screenshots are requested there is a small delay to allow temporal effects to converge. Default: 4. Using a value below the default will disable TemporalAA for improved image quality. |
| r.HLOD | Single argument: 0 or 1 to Disable/Enable HLOD System Multiple arguments: force X where X is the HLOD level that should be forced into view |
| r.HLOD.DistanceOverride | If non-zero, overrides the distance that HLOD transitions will take place for all objects at the HLOD level index, formatting is as follows: ‘r.HLOD.DistanceOverride 5000, 10000, 20000’ would result in HLOD levels 0, 1 and 2 transitioning at 5000, 1000 and 20000 respectively. |
| r.HLOD.DitherPauseTime | HLOD dither pause time in seconds |
| r.HLOD.ListUnbuilt | Lists all unbuilt HLOD actors in the world |
| r.HLOD.MaximumLevel | How far down the LOD hierarchy to allow showing (can be used to limit quality loss and streaming texture memory usage on high scalability settings) -1: No maximum level (default) 0: Prevent ever showing a HLOD cluster instead of individual meshes 1: Allow only the first level of HLOD clusters to be shown 2+: Allow up to the Nth level of HLOD clusters to be shown |
| r.HZBOcclusion | Defines which occlusion system is used. 0: Hardware occlusion queries 1: Use HZB occlusion system (default, less GPU and CPU cost, more conservative results) 2: Force HZB occlusion system (overrides rendering platform preferences) |
| r.IncludeNonVirtualTexturedLightmaps | If ‘r.VirtualTexturedLightmaps’ is enabled, controls whether non-VT lightmaps are generated/saved as well. Including non-VT lightmaps will constrain lightmap atlas size, which removes some of the benefit of VT lightmaps. 0: Not included. 1: Included. |
| r.IndirectLightingCache | Whether to use the indirect lighting cache on dynamic objects. 0 is off, 1 is on (default) |
| r.InvalidateCachedShaders | Invalidate shader cache by making a unique change to ShaderVersion.ush which is included in common.usf.To initiate actual the recompile of all shaders use « recompileshaders changed » or press « Ctrl Shift . ». The ShaderVersion.ush file should be automatically checked out but it needs to be checked in to have effect on other machines. |
| r.IrisNormal | 0 to disable iris normal. 0: off 1: on |
| r.KeepOverrideVertexColorsOnCPU | Keeps a CPU copy of override vertex colors. May be required for some blueprints / object spawning. |
| r.KeepPreCulledIndicesThreshold | |
| r.LandscapeLOD0DistributionScale | Multiplier for the landscape LOD0DistributionSetting property |
| r.LandscapeLODBias | LOD bias for landscape/terrain meshes. |
| r.LandscapeLODDistributionScale | Multiplier for the landscape LODDistributionSetting property |
| r.LensFlareQuality | 0: off but best for performance 1: low quality with good performance 2: good quality (default) 3: very good quality but bad performance |
| r.LightCulling.Quality | Whether to run compute light culling pass. 0: off 1: on (default) |
| r.LightFunctionQuality | Defines the light function quality which allows to adjust for quality or performance. <=0: off (fastest) 1: low quality (e.g. half res with blurring, not yet implemented) 2: normal quality (default) 3: high quality (e.g. super-sampled or colored, not yet implemented) |
| r.LightMaxDrawDistanceScale | Scale applied to the MaxDrawDistance of lights. Useful for fading out local lights more aggressively on some platforms. |
| r.LightPropagationVolume | Project setting of the work in progress feature LightPropgationVolume. Cannot be changed at runtime. 0: off (default) 1: on |
| r.LightShaftBlurPasses | Number of light shaft blur passes. |
| r.LightShaftDownSampleFactor | Downsample factor for light shafts. range: 1..8 |
| r.LightShaftFirstPassDistance | Fraction of the distance to the light to blur on the first radial blur pass. |
| r.LightShaftNumSamples | Number of samples per light shaft radial blur pass. Also affects how quickly the blur distance increases with each pass. |
| r.LightShaftQuality | Defines the light shaft quality (mobile and non mobile). 0: off 1: on (default) |
| r.LightShaftRenderToSeparateTranslucency | If enabled, light shafts will be rendered to the separate translucency buffer. This ensures postprocess materials with BL_BeforeTranslucnecy are applied before light shafts |
| r.LimitRenderingFeatures | Allows to quickly reduce render feature to increase render performance. This is just a quick way to alter multiple show flags and console variables in the game Disabled more feature the higher the number <=0:off, order is defined in code (can be documented here when we settled on an order) |
| r.ListSceneColorMaterials | Lists all materials that read from scene color. |
| r.LODFadeTime | How long LOD takes to fade (in seconds). |
| r.LPV.DiffuseIntensity | Multiplier for LPV Diffuse. |
| r.LPV.DirectionalOcclusionDefaultDiffuse | |
| r.LPV.DirectionalOcclusionDefaultSpecular | |
| r.LPV.EmissiveMultiplier | Emissive intensity multiplier |
| r.LPV.Intensity | Multiplier for LPV intensity. 1.0 is the default. |
| r.LPV.Mixing | Reflection environment mixes with indirect shading (Ambient + LPV). 0 is off, 1 is on (default) |
| r.LPV.NumAOPropagationSteps | Number of LPV AO propagation steps 0: noisy (good for debugging) 1: normal (default) 2: blurry |
| r.LPV.NumPropagationSteps | Number of LPV propagation steps |
| r.LPV.RSMResolution | Reflective Shadow Map resolution (used for LPV) – higher values result in less aliasing artifacts, at the cost of performance |
| r.LPV.SpecularIntensity | Multiplier for LPV Specular. |
| r.Lumin.OverrideExternalTextureSupport | Override external texture support for OpenGLES API. (Lumin Only) 0 = normal detection used [default] 1 = disable external texture support 2 = force ImageExternal100 (version #100 with GL_OES_EGL_image_external) 3 = force ImageExternal300 (version #300 with GL_OES_EGL_image_external) 4 = force ImageExternalESSL300 (version #300 with GL_OES_EGL_image_external_essl3) |
| r.LuminDebugCanvasHeight | Allows the override of the lumin debug canvas height. |
| r.LuminDebugCanvasWidth | Allows the override of the lumin debug canvas width. |
| r.LuminDebugCanvasX | Allows the override of the lumin debug canvas ‘x’ coordinate. |
| r.LuminDebugCanvasY | Allows the override of the lumin debug canvas ‘y’ coordinate. |
| r.LuminDebugCanvasZ | Allows the override of the lumin debug canvas ‘z’ coordinate. |
| r.LUT.Size | Size of film LUT |
| r.MaterialEditor.UseDevShaders | Toggles whether the material editor will use shaders that include extra overhead incurred by the editor. Material editor must be re-opened if changed at runtime. |
| r.MaterialQualityLevel | 0 corresponds to low quality materials, as defined by quality switches in materials, 1 corresponds to high and 2 for medium. |
| r.MaxAnisotropy | MaxAnisotropy should range from 1 to 16. Higher values mean better texure quality when using anisotropic filtering but at a cost to performance. Default is 4. |
| r.MaxCSMRadiusToAllowPerObjectShadows | Only stationary lights with a CSM radius smaller than this will create per object shadows for dynamic objects. |
| r.MaxQualityMode | If set to 1, override certain system settings to highest quality regardless of performance impact |
| r.MaxVertexBytesAllocatedPerFrame | The maximum number of transient vertex buffer bytes to allocate before we start panic logging who is doing the allocations |
| r.MeshDrawCommands.DynamicInstancing | Whether to dynamically combine multiple compatible visible Mesh Draw Commands into one instanced draw on vertex factories that support it. |
| r.MeshDrawCommands.LogDynamicInstancingStats | Whether to log dynamic instancing stats on the next frame |
| r.MeshDrawCommands.LogMeshDrawCommandMemoryStats | Whether to log mesh draw command memory stats on the next frame |
| r.MeshDrawCommands.ParallelPassSetup | Whether to setup mesh draw command pass in parallel. |
| r.MeshDrawCommands.UseCachedCommands | Whether to render from cached mesh draw commands (on vertex factories that support it), or to generate draw commands every frame. |
| r.MeshParticle.MinDetailModeForMotionBlur | Sets the minimum detail mode before mesh particles emit motion blur (Low = 0, Med = 1, High = 2, Max = 3). Set to -1 to disable mesh particles motion blur entirely. Defaults to -1. |
| r.MeshReductionModule | Name of what mesh reduction module to choose. If blank it chooses any that exist. |
| r.Metal.ForceDXC | Forces DirectX Shader Compiler (DXC) to be used for all Metal shaders instead of hlslcc. 0: Disable (default) 1: Force new compiler for all shaders |
| r.MinScreenRadiusForCSMDepth | Threshold below which meshes will be culled from CSM depth pass. |
| r.MinScreenRadiusForDepthPrepass | Threshold below which meshes will be culled from depth only pass. |
| r.MinScreenRadiusForLights | Threshold below which lights will be culled. |
| r.MinYResolutionFor3DView | Defines the smallest Y resolution we want to support in the 3D view |
| r.MinYResolutionForUI | Defines the smallest Y resolution we want to support in the UI (default is 720) |
| r.MipMapLODBias | Apply additional mip map bias for all 2D textures, range of -15.0 to 15.0 |
| r.Mobile.AdrenoOcclusionMode | 0: Render occlusion queries after the base pass (default). 1: Render occlusion queries after translucency and a flush, which can help Adreno devices in GL mode. |
| r.Mobile.AllowDistanceFieldShadows | 0: Do not generate shader permutations to render distance field shadows from stationary directional lights. 1: Generate shader permutations to render distance field shadows from stationary directional lights. (default) |
| r.Mobile.AllowDitheredLODTransition | Whether to support ‘Dithered LOD Transition’ material option on mobile platforms |
| r.Mobile.AllowMovableDirectionalLights | 0: Do not generate shader permutations to render movable directional lights. 1: Generate shader permutations to render movable directional lights. (default) |
| r.Mobile.AllowPixelDepthOffset | Whether to allow ‘Pixel Depth Offset’ in materials for ES3.1 feature level. Depth modification in pixel shaders may reduce GPU performance |
| r.Mobile.AllowSoftwareOcclusion | Whether to allow rasterizing scene on CPU for primitive occlusion. |
| r.Mobile.AlwaysResolveDepth | 0: Depth buffer is resolved after opaque pass only when decals or modulated shadows are in use. (Default) 1: Depth buffer is always resolved after opaque pass. |
| r.Mobile.CompressLandscapeWeightMaps | Whether to compress the terrain weight maps for mobile. |
| r.Mobile.DisableVertexFog | Set to 1 to disable vertex fogging in all mobile shaders. |
| r.Mobile.EnableMovableLightCSMShaderCulling | 0: All primitives lit by movable directional light render with CSM. 1: Primitives lit by movable directional light render with the CSM shader when determined to be within CSM range. (default) |
| r.Mobile.EnableMovableSpotlights | If 1 then enable movable spotlight support |
| r.Mobile.EnableStaticAndCSMShadowReceivers | 0: Primitives can receive only static shadowing from stationary lights. 1: Primitives can receive both CSM and static shadowing from stationary lights. (default) |
| r.Mobile.ForceDepthResolve | 0: Depth buffer is resolved by switching out render targets. (Default) 1: Depth buffer is resolved by switching out render targets and drawing with the depth texture. |
| r.Mobile.ForceFullPrecisionInPS | 0: Use precision specified in shader code (default) 1: Force use of high precision in pixel shaders. |
| r.Mobile.ForceRHISwitchVerticalAxis | Enable RHISwitchVerticalAxis when previewing mobile renderer. (Useful to test GLES y-axis flip codepaths) 0: RHISwitchVerticalAxis disabled (default). 1: RHISwitchVerticalAxis enabled. |
| r.Mobile.HighQualitySkyCaptureFiltering | 1: (default) use high quality filtering when generating mobile sky captures.0: use simple bilinear filtering when generating mobile sky captures. |
| r.Mobile.MeshSortingMethod | How to sort mesh commands on mobile: 0: Sort by state, roughly front to back (Default). 1: Strict front to back sorting. |
| r.Mobile.MoveSubmissionHintAfterTranslucency | 0: Submission hint occurs after occlusion query. 1: Submission hint occurs after translucency. (Default) |
| r.Mobile.SceneColorFormat | Overrides the memory layout (RGBA) used for the scene color of the mobile renderer. Unsupported overridden formats silently use default 0: (default) Automatically select the appropriate format depending on project settings and device support. 1: PF_FloatRGBA 64Bit 2: PF_FloatR11G11B10 32Bit 3: PF_B8G8R8A8 32Bit |
| r.Mobile.Shadow.CSMDebugHint | |
| r.Mobile.Shadow.CSMShaderCullingDebugGfx | |
| r.Mobile.Shadow.CSMShaderCullingMethod | Method to determine which primitives will receive CSM shaders: 0 – disabled (all primitives will receive CSM) 1 – Light frustum, all primitives whose bounding box is within CSM receiving distance. (default) 2 – Combined caster bounds, all primitives whose bounds are within CSM receiving distance and the capsule of the combined bounds of all casters. 3 – Light frustum + caster bounds, all primitives whose bounds are within CSM receiving distance and capsule of at least one caster. (slowest) Combine with 16 to change primitive bounding test to spheres instead of box. (i.e. 18 == combined casters + sphere test) |
| r.Mobile.SkyLightPermutation | 0: Generate both sky-light and non-skylight permutations. (default) 1: Generate only non-skylight permutations. 2: Generate only skylight permutations |
| r.Mobile.SupportGPUScene | Whether to support GPU scene, required for auto-instancing (only ES3.1 feature level) |
| r.Mobile.TonemapperFilm | Whether mobile platforms should use new film tone mapper |
| r.Mobile.UseHWsRGBEncoding | 0: Write sRGB encoding in the shader 1: Use GPU HW to convert linear to sRGB automatically (device must support sRGB write control) |
| r.Mobile.UseLegacyShadingModel | If 1 then use legacy (pre 4.20) shading model (such as spherical guassian specular calculation.) (will cause a shader rebuild) |
| r.MobileClearSceneColorWithMaxAlpha | Whether the scene color alpha channel on mobile should be cleared with MAX_FLT. 0: disabled (default) |
| r.MobileContentScaleFactor | Content scale multiplier (equates to iOS’s contentScaleFactor to support Retina displays |
| r.MobileDynamicPointLightsUseStaticBranch | 0: Generate unique forward rendering base pass shaders for 0, 1, … N mobile dynamic point lights. (faster but generates many more shaders) 1: Use a shared shader with static branching for rendering 1 or more dynamic point lights (slightly slower but reduces shaders generated, recommended for most games). |
| r.MobileHDR | 0: Mobile renders in LDR gamma space. (suggested for unlit games targeting low-end phones) 1: Mobile renders in HDR linear space. (default) |
| r.MobileHDR32bppMode | 0: If 32bpp is required mobile HDR will use best suited 32 bpp mode. (default) 1: Force Mobile 32bpp HDR with mosaic encoding. 2: Force Mobile 32bpp HDR with RGBE encoding mode. (device must support framebuffer fetch) 3: Force Mobile 32bpp HDR with direct RGBA8 rendering. |
| r.MobileMaxLoadedMips | Maximum number of loaded mips for nonstreaming mobile platforms. |
| r.MobileMSAA | Use MSAA instead of Temporal AA on mobile: 1: Use Temporal AA (MSAA disabled) 2: Use 2x MSAA (Temporal AA disabled) 4: Use 4x MSAA (Temporal AA disabled) 8: Use 8x MSAA (Temporal AA disabled) |
| r.MobileNumDynamicPointLights | The number of dynamic point lights to support on mobile devices. Setting this to 0 for games which do not require dynamic point lights will reduce the number of shaders generated. |
| r.MobileReduceLoadedMips | Reduce loaded texture mipmaps for nonstreaming mobile platforms. |
| r.MobileTonemapperUpscale | On mobile, whether to allow upscaling as part of the tonemapper or as a separate pass when possible0: separate pass (default) 1: as part of the tonemapper pass |
| r.MorphTarget.Mode | Use GPU for computing morph targets. 0: Use original CPU method (loop per morph then by vertex) 1: Enable GPU method (default) |
| r.MorphTarget.WeightThreshold | Set MorphTarget Weight Threshold (Default : 0.000000). |
| r.MotionBlur.Amount | Allows to override the postprocess setting (scale of motion blur) -1: override (default) |
| r.MotionBlur.Max | Allows to override the postprocess setting (max length of motion blur, in percent of the screen width) -1: override (default) |
| r.MotionBlur.PreferCompute | Will use compute shaders for motion blur pass. |
| r.MotionBlur.Scale | Allows to scale the postprocess intensity/amount setting in the postprocess. 1: don’t do any scaling (default) |
| r.MotionBlur.TargetFPS | Allows to override the postprocess setting (target FPS for motion blur velocity length scaling). -1: override (default) 0: target current frame rate with moving average [1,120]: target FPS for motion blur velocity scaling |
| r.MotionBlur2ndScale | |
| r.MotionBlurDebug | Defines if we log debugging output for motion blur rendering. 0: off (default) 1: on |
| r.MotionBlurFiltering | Useful developer variable 0: off (default, expected by the shader for better quality) 1: on |
| r.MotionBlurQuality | Defines the motion blur method which allows to adjust for quality or performance. 0:off, 1:low, 2:medium, 3:high (default), 4: very high |
| r.MotionBlurScatter | Forces scatter based max velocity method (slower). |
| r.MotionBlurSeparable | Adds a second motion blur pass that smooths noise for a higher quality blur. |
| r.MotionVectorSimulation | Controls whether to allow simulated motion vectors on scene components, geometry caches and skinned meshes on camera cut frames. |
| r.MrMesh.BrickCullingDebugState | MR Mesh brick culling debug state: 0=off, 1=on, 2=paused |
| r.MSAA.AllowCustomResolves | Whether to use builtin HW resolve or allow custom shader MSAA resolves |
| r.MSAA.CompositingSampleCount | Affects the render quality of the editor 3d objects. 1: no MSAA, lowest quality 2: 2x MSAA, medium quality (medium GPU memory consumption) 4: 4x MSAA, high quality (high GPU memory consumption) 8: 8x MSAA, very high quality (insane GPU memory consumption) |
| r.MSAACount | Number of MSAA samples to use with the forward renderer. Only used when MSAA is enabled in the rendering project settings. 0: MSAA disabled (Temporal AA enabled) 1: MSAA disabled 2: Use 2x MSAA 4: Use 4x MSAA8: Use 8x MSAA |
| r.MultithreadedLightmapEncode | Lightmap encoding after rebuild lightmaps is done multithreaded. |
| r.MultithreadedShadowmapEncode | Shadowmap encoding after rebuild lightmaps is done multithreaded. |
| r.NeverOcclusionTestDistance | When the distance between the viewpoint and the bounding sphere center is less than this, never occlusion cull. |
| r.NormalCurvatureToRoughnessBias | Biases the roughness resulting from screen space normal changes for materials with NormalCurvatureToRoughness enabled. Valid range [-1, 1] |
| r.NormalCurvatureToRoughnessExponent | Exponent on the roughness resulting from screen space normal changes for materials with NormalCurvatureToRoughness enabled. |
| r.NormalCurvatureToRoughnessScale | Scales the roughness resulting from screen space normal changes for materials with NormalCurvatureToRoughness enabled. Valid range [0, 2] |
| r.NormalMapsForStaticLighting | Whether to allow any static lighting to use normal maps for lighting computations. |
| r.NumBufferedOcclusionQueries | Number of frames to buffer occlusion queries (including the current renderthread frame). More frames reduces the chance of stalling the CPU waiting for results, but increases out of date query artifacts. |
| r.NVIDIATimestampWorkaround | If true we disable timestamps on pre-maxwell hardware (workaround for driver bug) |
| r.OcclusionCullParallelPrimFetch | Enables Parallel Occlusion Cull primitive fetch. |
| r.OneFrameThreadLag | Whether to allow the rendering thread to lag one frame behind the game thread (0: disabled, otherwise enabled) |
| r.OpenGL.AddExtensions | List of comma separated OpenGL extensions to add to a driver reported extensions string |
| r.OpenGL.AllowRHIThread | Toggle experimental OpenGL RHI thread support. 0: GL scene rendering operations are performed on the render thread. (default) 1: GL scene rendering operations are queued onto the RHI thread gaining some parallelism with the render thread. (mobile feature levels only) |
| r.OpenGL.DisableTextureStreamingSupport | Disable support for texture streaming on OpenGL. 0 = Texture streaming will be used if device supports it [default] 1 = Texture streaming will be disabled. |
| r.OpenGL.EnableProgramLRUCache | OpenGL program LRU cache. For use only when driver only supports a limited number of active GL programs. 0: disable LRU. (default) 1: When the LRU cache limits are reached, the least recently used GL program(s) will be deleted to make space for new/more recent programs. Expect hitching if requested shader is not in LRU cache. |
| r.OpenGL.EvictOnBSSDestruct | |
| r.OpenGL.EvictOnBSSDestruct.Latency | |
| r.OpenGL.IgnoreLinkFailure | Ignore OpenGL program link failures. 0: Program link failure generates a fatal error when encountered. (default) 1: Ignore link failures. this may allow a program to continue but could lead to undefined rendering behaviour. |
| r.OpenGL.PollRenderQueryResult | Whether to poll render query for result until it’s ready, otherwise do a blocking call to get result.0: Block, 1: Poll (default) |
| r.OpenGL.PrintProgramStats | Print to log current program binary stats |
| r.OpenGL.ProgramLRUBinarySize | OpenGL LRU maximum binary shader size. Limit the maximum number of active shader programs at any one time. 0: disable LRU. (default) Non-Zero: Maximum number of bytes active shader programs may use. If reached, least recently used shader programs will deleted. |
| r.OpenGL.ProgramLRUCount | OpenGL LRU maximum occupancy. Limit the maximum number of active shader programs at any one time. 0: disable LRU. (default) Non-Zero: Maximum number of active shader programs, if reached least, recently used shader programs will deleted. |
| r.OpenGL.ProgramLRUKeepBinaryResident | OpenGL LRU should keep program binary in memory. Do not discard the program binary after creation of the GL program. 0: Program binary is discarded after GL program creation and recreated on program eviction. (default) 1: Program binary is retained, this improves eviction and re-creation performance but uses more memory. |
| r.OpenGL.StoreCompressedProgramBinaries | |
| r.OpenGL.StripExtensions | List of comma separated OpenGL extensions to strip from a driver reported extensions string |
| r.OpenGL.UseExistingBinaryFileCache | When generating a new binary cache (such as when Shader Pipeline Cache Version Guid changes) use the existing binary file cache to speed up generation of the new cache. 0: Always rebuild binary file cache when Pipeline Cache Version Guid changes. 1: When Pipeline Cache Version Guid changes re-use programs from the existing binary cache where possible (default). |
| r.Paper2D.DrawTwoSided | Draw sprites as two sided. |
| r.ParallelBasePass | Toggles parallel base pass rendering. Parallel rendering must be enabled for this to have an effect. |
| r.ParallelGatherNumPrimitivesPerPacket | Number of primitives per packet. Only used when r.Shadow.UseOctreeForCulling is disabled. |
| r.ParallelGatherShadowPrimitives | Toggles parallel Gather shadow primitives. 0 = off; 1 = on |
| r.ParallelGeometryCollectionBatchSize | The number of vertices per thread dispatch in a single collection. |
| r.ParallelInitViews | Toggles parallel init views. 0 = off; 1 = on |
| r.ParallelPrePass | Toggles parallel zprepass rendering. Parallel rendering must be enabled for this to have an effect. |
| r.ParallelShadows | Toggles parallel shadow rendering. Parallel rendering must be enabled for this to have an effect. |
| r.ParallelShadowsNonWholeScene | Toggles parallel shadow rendering for non whole-scene shadows. r.ParallelShadows must be enabled for this to have an effect. |
| r.ParallelTranslucency | Toggles parallel translucency rendering. Parallel rendering must be enabled for this to have an effect. |
| r.ParallelVelocity | Toggles parallel velocity rendering. Parallel rendering must be enabled for this to have an effect. |
| r.ParticleLightQuality | 0: No lights. 1:Only simple lights. 2:Simple+HQ lights |
| r.ParticleLODBias | LOD bias for particle systems, default is 0 |
| r.PathTracing.AdaptiveSampling | Toggles the use of adaptive sampling 0: off 1: on (default) |
| r.PathTracing.AdaptiveSampling.MinimumSamplesPerPixel | Changes the minimum samples-per-pixel before applying adaptive sampling (default=16) |
| r.PathTracing.MaxBounces | Sets the maximum number of path tracing bounces (default = -1 (driven by postprocesing volume)) |
| r.PathTracing.RandomSequence | Changes the underlying random sequence 0: LCG (default 1: Halton 2: Scrambled Halton |
| r.PathTracing.RayCountFrequency | Sets the ray count computation frequency (default = every 128 iterations) |
| r.PathTracing.SamplesPerPixel | Defines the samples per pixel before resetting the simulation (default = -1 (driven by postprocesing volume)) |
| r.PathTracing.VarianceMapRebuildFrequency | Sets the variance map rebuild frequency (default = every 16 iterations) |
| r.Photography.Allow | If 1, allow the user to freeze the scene and potentially use a roaming camera to take screenshots. Set this dynamically to permit or forbid photography per-level, per-cutscene, etc. (Default: 1) |
| r.Photography.AutoPause | If 1, the photography system will attempt to ensure that the level is paused while in photography mode. Set to 0 to manage pausing and unpausing manually from the PlayerCameraManager Blueprint callbacks. Note: Blueprint callbacks will be called regardless of AutoPause value. (Default: auto-pause (1) |
| r.Photography.AutoPostprocess | If 1, the photography system will attempt to automatically disable HUD, subtitles, and some standard postprocessing effects during photography sessions/captures which are known to give poor photography results. Set to 0 to manage all postprocessing tweaks manually from the PlayerCameraManager Blueprint callbacks. Note: Blueprint callbacks will be called regardless of AutoPostprocess value. (Default: auto-disable (1) |
| r.Photography.Available | (Read-only) If 1, the photography system is potentially available to the user. Otherwise, a functioning back-end is not available. |
| r.Photography.Constrain.CameraSize | Radius (in Unreal Units) of sphere around the camera; used to prevent the camera clipping into nearby geometry when constraining camera with collision. Negative values disable default camera collisions. (Default: 14.0) |
| r.Photography.Constrain.MaxCameraDistance | Maximum distance (in Unreal Units) which camera is allowed to wander from its initial position when constraining camera by distance. Negative values disable default distance contraints. (Default: 2500.0) |
| r.Photography.EnableMultipart | If 1, allow the photography system to take high-resolution shots that need to be rendered in tiles which are later stitched together. (Default: 1) |
| r.Photography.SettleFrames | The number of frames to let the rendering ‘settle’ before taking a photo. Useful to allow temporal AA/smoothing to work well; if not using any temporal effects, can be lowered for faster capture. (Default: 10) |
| r.Photography.TranslationSpeed | Normal speed (in Unreal Units per second) at which to move the roaming photography camera. (Default: 100.0) |
| r.PostProcessAAQuality | Defines the postprocess anti aliasing method which allows to adjust for quality or performance. 0:off, 1:very low (faster FXAA), 2:low (FXAA), 3:medium (faster TemporalAA), 4:high (default TemporalAA), 5:very high, 6:max |
| r.PostProcessAllowBlendModes | Enables blend modes in post process materials. 0: disable blend modes. Uses replace 1: allow blend modes |
| r.PostProcessAllowStencilTest | Enables stencil testing in post process materials. 0: disable stencil testing 1: allow stencil testing 2: allow stencil testing and, if necessary, making a copy of custom depth/stencil buffer |
| r.PostProcessing.DisableMaterials | Allows to disable post process materials. |
| r.PostProcessing.ForceAsyncDispatch | Will force asynchronous dispatch for post processing compute shaders where implementations available. Only available for testing in non-shipping builds. |
| r.PostProcessing.PreferCompute | Will use compute shaders for post processing where implementations available. |
| r.PostProcessing.PropagateAlpha | 0 to disable scene alpha channel support in the post processing. 0: disabled (default); 1: enabled in linear color space; 2: same as 1, but also enable it through the tonemapper. Compositing after the tonemapper is incorrect, as their is no meaning to tonemap the alpha channel. This is only meant to be use exclusively for broadcasting hardware that does not support linear color space compositing and tonemapping. |
| r.PostProcessingColorFormat | Defines the memory layout (RGBA) used for most of the post processing chain buffers. 0: Default 1: Force PF_A32B32G32R32F 128Bit (unreasonable but good for testing) |
| r.PrecomputedVisibilityWarning | If set to 1, a warning will be displayed when rendering a scene from a view point without precomputed visibility. |
| r.PreTileTextures | If set to 1, textures will be tiled during cook and are expected to be cooked at runtime |
| r.PreventInvalidMaterialConnections | Controls whether users can make connections in the material editor if the system determines that they may cause compile errors 0: Allow all connections 1: Prevent invalid connections |
| r.PreViewTranslation | To limit issues with float world space positions we offset the world by the PreViewTranslation vector. This command allows to disable updating this vector. 0: disable update 1: update the offset is each frame (default) |
| r.ProfileGPU.AssetSummaryCallOuts | Comma separated list of substrings that deserve special mention in the final summary (e.g., « LOD,HeroName » r.ProfileGPU.PrintAssetSummary must be true to enable this feature |
| r.ProfileGPU.Pattern | Allows to filter the entries when using ProfileGPU, the pattern match is case sensitive. ‘*’ can be used in the end to get all entries starting with the string. ‘*’ without any leading characters disables the pattern matching and uses a time threshold instead (default). ‘?’ allows to ignore one character. e.g. AmbientOcclusionSetup, AmbientOcclusion*, Ambient???lusion*, * |
| r.ProfileGPU.PrintAssetSummary | Should we print a summary split by asset (r.ShowMaterialDrawEvents is strongly recommended as well). |
| r.ProfileGPU.Root | Allows to filter the tree when using ProfileGPU, the pattern match is case sensitive. |
| r.ProfileGPU.Screenshot | Whether a screenshot should be taken when profiling the GPU. 0:off, 1:on (default) |
| r.ProfileGPU.ShowEventHistogram | Whether the event histogram should be shown. |
| r.ProfileGPU.ShowLeafEvents | Allows profileGPU to display event-only leaf nodes with no draws associated. |
| r.ProfileGPU.ShowTransitions | Allows profileGPU to display resource transition events. |
| r.ProfileGPU.ShowUI | Whether the user interface profiler should be displayed after profiling the GPU. The results will always go to the log/console 0:off, 1:on (default) |
| r.ProfileGPU.Sort | Sorts the TTY Dump independently at each level of the tree in various modes. 0 : Chronological 1 : By time elapsed 2 : By number of prims 3 : By number of verts |
| r.ProgramBinaryCache.Enable | If true, enables binary program cache. Enabled by default only on Android |
| r.ProgramBinaryCache.RestartAndroidAfterPrecompile | If true, Android apps will restart after precompiling the binary program cache. Enabled by default only on Android |
| r.ProxyLODChartColorVerts | Color verts by uv chart. Default off. 0: Disabled 1: Enabled. |
| r.ProxyLODCorrectCollapsedWalls | Shall the ProxyLOD system attemp to correct walls with interpenetrating faces0: disabled (default) 1: endable, may cause cracks. |
| r.ProxyLODMaterialInParallel | 0: disable doing material work in parallel with mesh simplification 1: enable – default |
| r.ProxyLODMaxDilationSteps | Limit the numer of dilation steps used in gap filling for performance reasons This may affect gap filling quality as bigger dilations steps will be used with a smaller max 0: will disable gap filling 7: default |
| r.ProxyLODMeshReductionModule | Name of the Proxy LOD reduction module to choose. If blank it chooses any that exist. |
| r.ProxyLODRemeshOnly | Only remesh. No simplification or materials. Default off. 0: Disabled – will simplify and generate materials 1: Enabled – will not simplfy or generate materials. |
| r.ProxyLODSingleThreadSimplify | Use single threaded code path. Default off. 0: Multithreaded 1: Single threaded. |
| r.ProxyLODTransfer | 0: shoot both ways 1: preference for forward (default) |
| r.ProxyLODUseTangentSpace | Shall the ProxyLOD system generate a true tangent space at each vertex0: world space at each vertex 1: tangent space at each vertex (default) |
| r.PS4MixedModeShaderDebugInfo | Whether to compile shaders to allow mixed mode shader debugging. This will currently generate slower code. 0: Normal mode 1: Mixed mode) |
| r.pso.evictiontime | Time between checks to remove stale objects from the cache. 0 = no eviction (which may eventually OOM…) |
| r.RayTracing | 0 to disable ray tracing. 0: off 1: on |
| r.RayTracing.AmbientOcclusion | -1: Value driven by postprocess volume (default) 0: ray tracing ambient occlusion off 1: ray tracing ambient occlusion enabled |
| r.RayTracing.AmbientOcclusion.EnableMaterials | Enables |
| r.RayTracing.AmbientOcclusion.EnableTwoSidedGeometry | Enables two-sided geometry when tracing shadow rays (default = 0) |
| r.RayTracing.AmbientOcclusion.SamplesPerPixel | Sets the samples-per-pixel for ambient occlusion (default = -1 (driven by postprocesing volume)) |
| r.RayTracing.EnableMaterials | 0: bind default material shader that outputs placeholder data 1: bind real material shaders (default) |
| r.RayTracing.ExcludeDecals | A toggle that modifies the inclusion of decals in the ray tracing BVH. 0: Decals included in the ray tracing BVH (default) 1: Decals excluded from the ray tracing BVH |
| r.RayTracing.ForceAllRayTracingEffects | Force all ray tracing effects ON/OFF. -1: Do not force (default) 0: All ray tracing effects disabled 1: All ray tracing effects enabled |
| r.RayTracing.GlobalIllumination | -1: Value driven by postprocess volume (default) 0: ray tracing global illumination off 1: ray tracing global illumination enabled |
| r.RayTracing.GlobalIllumination.Denoiser | Denoising options (default = 1) |
| r.RayTracing.GlobalIllumination.DiffuseThreshold | Diffuse luminance threshold for evaluating global illuminationNOTE: This parameter is experimental |
| r.RayTracing.GlobalIllumination.EnableFinalGather | Enables final gather algorithm for 1-bounce global illumination (default = 0) |
| r.RayTracing.GlobalIllumination.EnableTwoSidedGeometry | Enables two-sided geometry when tracing GI rays (default = 1) |
| r.RayTracing.GlobalIllumination.EvalSkyLight | Evaluate SkyLight multi-bounce contributionNOTE: This parameter is experimental |
| r.RayTracing.GlobalIllumination.FinalGatherDistance | Maximum world-space distance for valid, reprojected final gather points (default = 10) |
| r.RayTracing.GlobalIllumination.MaxBounces | Max bounces (default = -1 (driven by postprocesing volume)) |
| r.RayTracing.GlobalIllumination.MaxRayDistance | Max ray distance (default = 1.0e27) |
| r.RayTracing.GlobalIllumination.NextEventEstimationSamples | Number of sample draws for next-event estimation (default = 2)NOTE: This parameter is experimental |
| r.RayTracing.GlobalIllumination.SamplesPerPixel | Samples per pixel (default = -1 (driven by postprocesing volume)) |
| r.RayTracing.GlobalIllumination.ScreenPercentage | Screen percentage for ray tracing global illumination (default = 50) |
| r.RayTracing.GlobalIllumination.TileSize | Render ray traced global illumination in NxN piel tiles, where each tile is submitted as separate GPU command buffer, allowing high quality rendering without triggering timeout detection. (default = 0, tiling disabled) |
| r.RayTracing.GlobalIllumination.UseRussianRoulette | Perform Russian Roulette to only cast diffuse rays on surfaces with brighter albedos (default = 0)NOTE: This parameter is experimental |
| r.RayTracing.InstancedStaticMeshes | Include static mesh instances in ray tracing effects (default = 1 (Instances enabled in ray tracing)) |
| r.RayTracing.InstancedStaticMeshes.CullClusterMaxRadiusMultiplier | Multiplier for the maximum instance size (default = 20cm) |
| r.RayTracing.InstancedStaticMeshes.CullClusterRadius | Ignore instances outside of this radius in ray tracing effects (default = 10000 (100m)) |
| r.RayTracing.InstancedStaticMeshes.Culling | Enable culling for instances in ray tracing (default = 0 (Culling disabled)) |
| r.RayTracing.InstancedStaticMeshes.LowScaleCullRadius | Cull radius for small instances (default = 1000 (10m)) |
| r.RayTracing.InstancedStaticMeshes.LowScaleRadiusThreshold | Threshold that classifies instances as small (default = 50cm)) |
| r.RayTracing.Landscape | Include landscapes in ray tracing effects (default = 1 (landscape enabled in ray tracing)) |
| r.RayTracing.Landscape.DetectTextureStreaming | If on, update ray tracing geometry when texture streaming state changes. Useful when WorldPositionOffset is used in the landscape material |
| r.RayTracing.Landscape.LODsUpdateEveryFrame | If on, LODs that are lower than the specified level will be updated every frame, which can be used to workaround some artifacts caused by texture streaming if you’re using WorldPositionOffset on the landscape |
| r.RayTracing.NormalBias | Sets the max. normal bias used for offseting the ray start position along the normal (default = 0.1, i.e., 1mm) |
| r.RayTracing.PSOCacheSize | Number of ray tracing pipelines to keep in the cache (default = 50). Set to 0 to disable eviction. |
| r.RayTracing.Reflections | -1: Value driven by postprocess volume (default) 0: use traditional rasterized SSR 1: use ray traced reflections |
| r.RayTracing.Reflections.DirectLighting | Enables ray tracing reflections direct lighting (default = 1) |
| r.RayTracing.Reflections.EmissiveAndIndirectLighting | Enables ray tracing reflections emissive and indirect lighting (default = 1) |
| r.RayTracing.Reflections.HeightFog | Enables height fog in ray traced reflections (default = 1) |
| r.RayTracing.Reflections.MaxBounces | Sets the maximum number of ray tracing reflection bounces (default = -1 (max bounces driven by postprocessing volume)) |
| r.RayTracing.Reflections.MaxRayDistance | Sets the maximum ray distance for ray traced reflection rays. When ray shortening is used, skybox will not be sampled in RT reflection pass and will be composited later, together with local reflection captures. Negative values turn off this optimization. (default = -1 (infinite rays)) |
| r.RayTracing.Reflections.MaxRoughness | Sets the maximum roughness until which ray tracing reflections will be visible (default = -1 (max roughness driven by postprocessing volume)) |
| r.RayTracing.Reflections.MaxUnderCoatBounces | How many bounces to apply ray traced reflections to the undercoat layer. Extra bounces will use reflection probes. (default 0, always use probes) |
| r.RayTracing.Reflections.MinClearCoatLevel | Minimum level at which to apply clear coat shading (default 0.01) Note: causes some variation in height fog due to using the bottom layer path |
| r.RayTracing.Reflections.MinRayDistance | Sets the minimum ray distance for ray traced reflection rays. Actual reflection ray length is computed as Lerp(MaxRayDistance, MinRayDistance, Roughness), i.e. reflection rays become shorter when traced from rougher surfaces. (default = -1 (infinite rays)) |
| r.RayTracing.Reflections.ReflectionCaptures | Enables ray tracing reflections to use reflection captures as the last bounce reflection. Particularly usefull for metals in reflection. (default = 0) |
| r.RayTracing.Reflections.SamplesPerPixel | Sets the samples-per-pixel for reflections (default = -1 (driven by postprocesing volume)) |
| r.RayTracing.Reflections.ScreenPercentage | Screen percentage the reflections should be ray traced at (default = 100). |
| r.RayTracing.Reflections.Shadows | Enables shadows in ray tracing reflections) -1: Shadows driven by postprocessing volume (default) 0: Shadows disabled 1: Hard shadows 2: Soft area shadows |
| r.RayTracing.Reflections.SortMaterials | Sets whether refected materials will be sorted before shading 0: Disabled (Default) 1: Enabled, using Trace->Sort->Trace |
| r.RayTracing.Reflections.SortSize | Size of horizon for material ID sort 0: Disabled 1: 256 Elements 2: 512 Elements 3: 1024 Elements 4: 2048 Elements 5: 4096 Elements (Default) |
| r.RayTracing.Reflections.SortTileSize | Size of pixel tiles for sorted reflections Default 64 |
| r.RayTracing.Reflections.TestPathRoughness | Accumulate roughness along path and test accumulated roughness against MaxRoughness before launching the next bounce (default 1) |
| r.RayTracing.Shadow.MaxBatchSize | Maximum number of shadows to trace at the same time. |
| r.RayTracing.Shadow.SamplesPerPixel | Sets the samples-per-pixel for directional light occlusion (default = 1) |
| r.RayTracing.Shadows | 0: use traditional rasterized shadow map 1: use ray tracing shadows (default) |
| r.RayTracing.Shadows.EnableMaterials | Enables material shader binding for shadow rays. If this is disabled, then a default trivial shader is used. (default = 1) |
| r.RayTracing.Shadows.EnableTwoSidedGeometry | Enables two-sided geometry when tracing shadow rays (default = 1) |
| r.RayTracing.SkyLight | Enables ray tracing SkyLight (default = 0) |
| r.RayTracing.SkyLight.DecoupleSampleGeneration | Decouples sample generation from ray traversal (default = 1) |
| r.RayTracing.SkyLight.Denoiser | Denoising options (default = 1) |
| r.RayTracing.SkyLight.EnableMaterials | Enables material shader binding for shadow rays. If this is disabled, then a default trivial shader is used. (default = 0) |
| r.RayTracing.SkyLight.EnableTwoSidedGeometry | Enables two-sided geometry when tracing shadow rays (default = 1) |
| r.RayTracing.SkyLight.MaxRayDistance | Sets the max ray distance for ray tracing SkyLight (default = 1.0e7) |
| r.RayTracing.SkyLight.MaxShadowThickness | Sets the max shadow thickness for translucent materials for ray tracing SkyLight (default = 1.0e3) |
| r.RayTracing.SkyLight.SamplesPerPixel | Sets the samples-per-pixel for ray tracing SkyLight (default = -1) |
| r.RayTracing.SkyLight.Sampling.StopLevel | Sets the stop level for MIP-sampling (default = 0) |
| r.RayTracing.StochasticRectLight | 0: use analytical evaluation (default) 1: use stochastic evaluation |
| r.RayTracing.StochasticRectLight.IsTextureImportanceSampling | Enable importance sampling for rect light evaluation (default = 1) |
| r.RayTracing.StochasticRectLight.SamplesPerPixel | Sets the samples-per-pixel for rect light evaluation (default = 1) |
| r.RayTracing.Translucency | -1: Value driven by postprocess volume (default) 0: ray tracing translucency off (use raster) 1: ray tracing translucency enabled |
| r.RayTracing.Translucency.DirectLighting | Enables ray tracing translucency direct lighting (default = 1) |
| r.RayTracing.Translucency.EmissiveAndIndirectLighting | Enables ray tracing translucency emissive and indirect lighting (default = 1) |
| r.RayTracing.Translucency.HeightFog | Enables height fog in ray traced Translucency (default = 1) |
| r.RayTracing.Translucency.MaxRayDistance | Sets the maximum ray distance for ray traced translucency rays. When ray shortening is used, skybox will not be sampled in RT translucency pass and will be composited later, together with local reflection captures. Negative values turn off this optimization. (default = -1 (infinite rays)) |
| r.RayTracing.Translucency.MaxRefractionRays | Sets the maximum number of refraction rays for ray traced translucency (default = -1 (max bounces driven by postprocessing volume) |
| r.RayTracing.Translucency.MaxRoughness | Sets the maximum roughness until which ray tracing reflections will be visible (default = -1 (max roughness driven by postprocessing volume)) |
| r.RayTracing.Translucency.MinRayDistance | Sets the minimum ray distance for ray traced translucency rays. Actual translucency ray length is computed as Lerp(MaxRayDistance, MinRayDistance, Roughness), i.e. translucency rays become shorter when traced from rougher surfaces. (default = -1 (infinite rays)) |
| r.RayTracing.Translucency.PrimaryRayBias | Sets the bias to be subtracted from the primary ray TMax in ray traced Translucency. Larger bias reduces the chance of opaque objects being intersected in ray traversal, saving performance, but at the risk of skipping some thin translucent objects in proximity of opaque objects. (recommended range: 0.00001 – 0.1) (default = 0.00001) |
| r.RayTracing.Translucency.Refraction | Enables refraction in ray traced Translucency (default = 1) |
| r.RayTracing.Translucency.SamplesPerPixel | Sets the samples-per-pixel for Translucency (default = 1) |
| r.RayTracing.Translucency.Shadows | Enables shadows in ray tracing translucency) -1: Shadows driven by postprocessing volume (default) 0: Shadows disabled 1: Hard shadows 2: Soft area shadows |
| r.RayTracing.UseTextureLod | 0 to disable texture LOD. 0: off 1: on |
| r.RDG.Debug | Allow to output warnings for inefficiencies found during wiring and execution of the passes. 0: disabled; 1: emit warning once (default); 2: emit warning everytime issue is detected. |
| r.RDG.ImmediateMode | Executes passes as they get created. Useful to have a callstack of the wiring code when crashing in the pass’ lambda. |
| r.ReadBuffer.AlignSize | The alignment size (in instances) to allocate in blocks for rendering read buffers. i.e. 64*1024 = 256k for a float buffer |
| r.ReadBuffer.MaxRenderingBytesAllocatedPerFrame | The maximum number of transient rendering read buffer bytes to allocate before we start panic logging who is doing the allocations |
| r.ReadBuffer.MinSize | The minimum size (in instances) to allocate in blocks for rendering read buffers. i.e. 256*1024 = 1mb for a float buffer |
| r.RecompileRenderer | Recompiles the renderer module on the fly. |
| r.ReflectionCaptureGPUArrayCopy | Do a fast copy of the reflection capture array when resizing if possible. This avoids hitches on the rendering thread when the cubemap array needs to grow. 0 is off, 1 is on (default) |
| r.ReflectionCaptureResolution | Set the resolution for all reflection capture cubemaps. Should be set via project’s Render Settings. Must be power of 2. Defaults to 128. |
| r.ReflectionCaptureSupersampleFactor | Super sample factor when rendering reflection captures. Default = 1, no super sampling Maximum clamped to 8. |
| r.ReflectionEnvironment | Whether to render the reflection environment feature, which implements local reflections through Reflection Capture actors. 0: off 1: on and blend with scene (default) 2: on and overwrite scene (only in non-shipping builds) |
| r.ReflectionEnvironmentBeginMixingRoughness | Min roughness value at which to begin mixing reflection captures with lightmap indirect diffuse. |
| r.ReflectionEnvironmentEndMixingRoughness | Min roughness value at which to end mixing reflection captures with lightmap indirect diffuse. |
| r.ReflectionEnvironmentLightmapMixBasedOnRoughness | Whether to reduce lightmap mixing with reflection captures for very smooth surfaces. This is useful to make sure reflection captures match SSR / planar reflections in brightness. |
| r.ReflectionEnvironmentLightmapMixing | Whether to mix indirect specular from reflection captures with indirect diffuse from lightmaps for rough surfaces. |
| r.ReflectionEnvironmentLightmapMixLargestWeight | When set to 1 can be used to clamp lightmap mixing such that only darkening from lightmaps are applied to reflection captures. |
| r.Reflections.Denoiser | Choose the denoising algorithm. 0: Disabled; 1: Forces the default denoiser of the renderer; 2: GScreenSpaceDenoiser which may be overriden by a third party plugin (default). |
| r.Reflections.Denoiser.HistoryConvolution.SampleCount | Number of samples to use for history post filter (default = 1). |
| r.Reflections.Denoiser.ReconstructionSamples | Maximum number of samples for the reconstruction pass (default = 16). |
| r.Reflections.Denoiser.TemporalAccumulation | Accumulates the samples over multiple frames. |
| r.RefractionQuality | Defines the distorion/refraction quality which allows to adjust for quality or performance. <=0: off (fastest) 1: low quality (not yet implemented) 2: normal quality (default) 3: high quality (e.g. color fringe, not yet implemented) |
| r.RenderLastFrameInStreamingPause | If 1 the previous frame is displayed during streaming pause. If zero the screen is left black. |
| r.RenderPass.Validation | |
| r.RenderTargetPool.AllowMultipleAliasingDiscardsPerFrame | If enabled, allows rendertargets to be discarded and reacquired in the same frame. This should give better aliasing efficiency, but carries some RHIthread/GPU performance overhead with some RHIs (due to additional commandlist flushes) 0:off (default), 1:on |
| r.RenderTargetPool.Events | Visualize the render target pool events over time in one frame. Optional parameter defines threshold in KB. To disable the view use the command without any parameter |
| r.RenderTargetPool.TransientAliasingMode | Enables transient resource aliasing for rendertargets. Used only if GSupportsTransientResourceAliasing is true. 0 : Disabled 1 : enable transient resource aliasing for fastVRam rendertargets 2 : enable transient resource aliasing for fastVRam rendertargets and those with a Transient hint. Best for memory usage – has some GPU cost (~0.2ms) 3 : enable transient resource aliasing for ALL rendertargets (not recommended) |
| r.RenderTargetPoolMin | If the render target pool size (in MB) is below this number there is no deallocation of rendertargetsDefault is 200 MB. |
| r.RenderTargetSwitchWorkaround | Workaround needed on some mobile platforms to avoid a performance drop related to switching render targets. Only enabled on some hardware. This affects the bloom quality a bit. It runs slower than the normal code path but still faster as it avoids the many render target switches. (Default: 0) We want this enabled (1) on all 32 bit iOS devices (implemented through DeviceProfiles). |
| r.RenderTimeFrozen | Allows to freeze time based effects in order to provide more deterministic render profiling. 0: off 1: on (Note: this also disables occlusion queries) |
| r.ResetViewState | Reset some state (e.g. TemporalAA index) to make rendering more deterministic (for automated screenshot verification) |
| r.RHI.FastClearUAVMaxSize | Max size in bytes to fast clear tiny UAV. 0 by default or when feature is not supported by the platform |
| r.RHICmdAsyncRHIThreadDispatch | Experiemental option to do RHI dispatches async. This keeps data flowing to the RHI thread faster and avoid a block at the end of the frame. |
| r.RHICmdBalanceParallelLists | Allows to enable a preprocess of the drawlists to try to balance the load equally among the command lists. 0: off 1: enabled 2: experiemental, uses previous frame results (does not do anything in split screen etc) |
| r.RHICmdBalanceTranslatesAfterTasks | Experimental option to balance the parallel translates after the render tasks are complete. This minimizes the number of deferred contexts, but adds latency to starting the translates. r.RHICmdBalanceParallelLists overrides and disables this option |
| r.RHICmdBasePassDeferredContexts | True to use deferred contexts to parallelize base pass command list execution. |
| r.RHICmdBufferWriteLocks | Only relevant with an RHI thread. Debugging option to diagnose problems with buffered locks. |
| r.RHICmdBypass | Whether to bypass the rhi command list and send the rhi commands immediately. 0: Disable (required for the multithreaded renderer) 1: Enable (convenient for debugging low level graphics API calls, can suppress artifacts from multithreaded renderer code) |
| r.RHICmdCollectRHIThreadStatsFromHighLevel | This pushes stats on the RHI thread executes so you can determine which high level pass they came from. This has an adverse effect on framerate. This is on by default. |
| r.RHICmdDeferSkeletalLockAndFillToRHIThread | If > 0, then do the bone and cloth copies on the RHI thread. Experimental option. |
| r.RHICmdFlushOnQueueParallelSubmit | Wait for completion of parallel commandlists immediately after submitting. For issue diagnosis. Only available on some RHIs. |
| r.RHICmdFlushRenderThreadTasks | If true, then we flush the render thread tasks every pass. For issue diagnosis. This is a master switch for more granular cvars. |
| r.RHICmdFlushRenderThreadTasksBasePass | Wait for completion of parallel render thread tasks at the end of the base pass. A more granular version of r.RHICmdFlushRenderThreadTasks. If either r.RHICmdFlushRenderThreadTasks or r.RHICmdFlushRenderThreadTasksBasePass is > 0 we will flush. |
| r.RHICmdFlushRenderThreadTasksPrePass | Wait for completion of parallel render thread tasks at the end of the pre pass. A more granular version of r.RHICmdFlushRenderThreadTasks. If either r.RHICmdFlushRenderThreadTasks or r.RHICmdFlushRenderThreadTasksPrePass is > 0 we will flush. |
| r.RHICmdFlushRenderThreadTasksShadowPass | Wait for completion of parallel render thread tasks at the end of each shadow pass. A more granular version of r.RHICmdFlushRenderThreadTasks. If either r.RHICmdFlushRenderThreadTasks or r.RHICmdFlushRenderThreadTasksShadowPass is > 0 we will flush. |
| r.RHICmdFlushRenderThreadTasksTranslucentPass | Wait for completion of parallel render thread tasks at the end of the translucent pass. A more granular version of r.RHICmdFlushRenderThreadTasks. If either r.RHICmdFlushRenderThreadTasks or r.RHICmdFlushRenderThreadTasksTranslucentPass is > 0 we will flush. |
| r.RHICmdFlushRenderThreadTasksVelocityPass | Wait for completion of parallel render thread tasks at the end of the velocity pass. A more granular version of r.RHICmdFlushRenderThreadTasks. If either r.RHICmdFlushRenderThreadTasks or r.RHICmdFlushRenderThreadTasksVelocityPass is > 0 we will flush. |
| r.RHICmdFlushUpdateTextureReference | If true, then we flush the rhi thread when we do RHIUpdateTextureReference, otherwise this is deferred. For issue diagnosis. |
| r.RHICmdForceRHIFlush | Force a flush for every task sent to the RHI thread. For issue diagnosis. |
| r.RHICmdMergeSmallDeferredContexts | When it can be determined, merge small parallel translate tasks based on r.RHICmdMinDrawsPerParallelCmdList. |
| r.RHICmdMinCmdlistForParallelSubmit | Minimum number of parallel translate command lists to submit. If there are fewer than this number, they just run on the RHI thread and immediate context. |
| r.RHICmdMinCmdlistForParallelTranslate | If there are fewer than this number of parallel translates, they just run on the RHI thread and immediate context. Only relevant if r.RHICmdBalanceTranslatesAfterTasks is on. |
| r.RHICmdMinCmdlistSizeForParallelTranslate | In kilobytes. Cmdlists are merged into one parallel translate until we have at least this much memory to process. For a given pass, we won’t do more translates than we have task threads. Only relevant if r.RHICmdBalanceTranslatesAfterTasks is on. |
| r.RHICmdMinDrawsPerParallelCmdList | The minimum number of draws per cmdlist. If the total number of draws is less than this, then no parallel work will be done at all. This can’t always be honored or done correctly. More effective with RHICmdBalanceParallelLists. |
| r.RHICmdPrePassDeferredContexts | True to use deferred contexts to parallelize prepass command list execution. |
| r.RHICmdShadowDeferredContexts | True to use deferred contexts to parallelize shadow command list execution. |
| r.RHICmdSpewParallelListBalance | For debugging, spews the size of the parallel command lists. This stalls and otherwise wrecks performance. 0: off (default) 1: enabled (default) |
| r.RHICmdTranslucencyPassDeferredContexts | True to use deferred contexts to parallelize base pass command list execution. |
| r.RHICmdUseDeferredContexts | True to use deferred contexts to parallelize command list execution. Only available on some RHIs. |
| r.RHICmdUseParallelAlgorithms | True to use parallel algorithms. Ignored if r.RHICmdBypass is 1. |
| r.RHICmdUseThread | Uses the RHI thread. For issue diagnosis. |
| r.RHICmdVelocityPassDeferredContexts | True to use deferred contexts to parallelize velocity pass command list execution. |
| r.RHICmdWidth | Controls the task granularity of a great number of things in the parallel renderer. |
| r.RHIRenderPasses | |
| r.RHISetGPUCaptureOptions | Utility function to change multiple CVARs useful when profiling or debugging GPU rendering. Setting to 1 or 0 will guarantee all options are in the appropriate state. r.rhithread.enable, r.rhicmdbypass, r.showmaterialdrawevents, toggledrawevents Platform RHI’s may implement more feature toggles. |
| r.RHIThread.Enable | Enables/disabled the RHI Thread and determine if the RHI work runs on a dedicated thread or not. |
| r.Roughness.Max | Allows quick material test by remapping the roughness at 1 to a new value (0..1), Only for non shipping built! 1: (default) |
| r.Roughness.Min | Allows quick material test by remapping the roughness at 0 to a new value (0..1), Only for non shipping built! 0: (default) |
| r.SafeStateLookup | Forces new-style safe state lookup for easy runtime perf comparison |
| r.SaveEXR.CompressionQuality | Defines how we save HDR screenshots in the EXR format. 0: no compression 1: default compression which can be slow (default) |
| r.SceneCapture.EnableViewExtensions | Whether to enable view extensions when doing scene capture. 0: Disable view extensions (default). 1: Enable view extensions. |
| r.SceneColorFormat | Defines the memory layout (RGBA) used for the scene color (affects performance, mostly through bandwidth, quality especially with translucency). 0: PF_B8G8R8A8 32Bit (mostly for testing, likely to unusable with HDR) 1: PF_A2B10G10R10 32Bit 2: PF_FloatR11G11B10 32Bit 3: PF_FloatRGB 32Bit 4: PF_FloatRGBA 64Bit (default, might be overkill, especially if translucency is mostly using SeparateTranslucency) 5: PF_A32B32G32R32F 128Bit (unreasonable but good for testing) |
| r.SceneColorFringe.Max | Allows to clamp the postprocess setting (in percent, Scene chromatic aberration / color fringe to simulate an artifact that happens in real-world lens, mostly visible in the image corners) -1: don’t clamp (default) -2: to test extreme fringe |
| r.SceneColorFringeQuality | 0: off but best for performance 1: 3 texture samples (default)n |
| r.SceneRenderTargetResizeMethod | Control the scene render target resize method: (This value is only used in game mode and on windowing platforms.) 0: Resize to match requested render size (Default) (Least memory use, can cause stalls when size changes e.g. ScreenPercentage) 1: Fixed to screen resolution. 2: Expands to encompass the largest requested render dimension. (Most memory use, least prone to allocation stalls.) |
| r.ScreenPercentage | To render in lower resolution and upscale for better performance (combined up with the blenable post process setting). 70 is a good value for low aliasing and performance, can be verified with ‘show TestImage’ in percent, >0 and <=100, larger numbers are possible (supersampling) but the downsampling quality is improvable.<0 is treated like 100. |
| r.ScreenshotDelegate | ScreenshotDelegates prevent processing of incoming screenshot request and break some features. This allows to disable them. Ideally we rework the delegate code to not make that needed. 0: off 1: delegates are on (default) |
| r.SecondaryScreenPercentage.GameViewport | Override secondary screen percentage for game viewport. 0: Compute secondary screen percentage = 100 / DPIScalefactor automaticaly (default); 1: override secondary screen percentage. |
| r.SelectiveBasePassOutputs | Enables shaders to only export to relevant rendertargets. 0: Export in all rendertargets. 1: Export only into relevant rendertarget. |
| r.SeparateTranslucency | Allows to disable the separate translucency feature (all translucency is rendered in separate RT and composited after DOF, if not specified otherwise in the material). 0: off (translucency is affected by depth of field) 1: on costs GPU performance and memory but keeps translucency unaffected by Depth of Field. (default) |
| r.SeparateTranslucencyAutoDownsample | Whether to automatically downsample separate translucency based on last frame’s GPU time. Automatic downsampling is only used when r.SeparateTranslucencyScreenPercentage is 100 |
| r.SeparateTranslucencyDurationDownsampleThreshold | When smoothed full-res translucency GPU duration is larger than this value (ms), the entire pass will be downsampled by a factor of 2 in each dimension. |
| r.SeparateTranslucencyDurationUpsampleThreshold | When smoothed half-res translucency GPU duration is smaller than this value (ms), the entire pass will be restored to full resolution. This should be around 1/4 of r.SeparateTranslucencyDurationDownsampleThreshold to avoid toggling downsampled state constantly. |
| r.SeparateTranslucencyMinDownsampleChangeTime | Minimum time in seconds between changes to automatic downsampling state, used to prevent rapid swapping between half and full res. |
| r.SeparateTranslucencyScreenPercentage | Render separate translucency at this percentage of the full resolution. in percent, >0 and <=100, larger numbers are possible (supersampling).<0 is treated like 100. |
| r.SeparateTranslucencyUpsampleMode | Upsample method to use on separate translucency. These are only used when r.SeparateTranslucencyScreenPercentage is less than 100. 0: bilinear 1: Nearest-Depth Neighbor (only when r.SeparateTranslucencyScreenPercentage is 50) |
| r.SetNearClipPlane | Set the near clipping plane (in cm) |
| r.SetRes | Set the display resolution for the current game view. Has no effect in the editor. e.g. 1280x720w for windowed 1920x1080f for fullscreen 1920x1080wf for windowed fullscreen |
| r.ShaderCodeLibrary.DefaultAsyncIOPriority | |
| r.ShaderComplexity.Baseline.Deferred.PS | Minimum number of instructions for pixel shaders in deferred shading (default=111) |
| r.ShaderComplexity.Baseline.Deferred.UnlitPS | Minimum number of instructions for unlit material pixel shaders in deferred shading (default=33) |
| r.ShaderComplexity.Baseline.Deferred.VS | Minimum number of instructions for vertex shaders in deferred shading (default=41) |
| r.ShaderComplexity.Baseline.Forward.PS | Minimum number of instructions for pixel shaders in forward shading (default=635) |
| r.ShaderComplexity.Baseline.Forward.UnlitPS | Minimum number of instructions for unlit material pixel shaders in forward shading (default=47) |
| r.ShaderComplexity.Baseline.Forward.VS | Minimum number of instructions for vertex shaders in forward shading (default=134) |
| r.ShaderDevelopmentMode | 0: Default, 1: Enable various shader development utilities, such as the ability to retry on failed shader compile, and extra logging as shaders are compiled. |
| r.ShaderPipelineCache.AutoSaveTime | Set the time where any logged PSO’s will be saved if the number is < r.ShaderPipelineCache.SaveAfterPSOsLogged. Disabled when r.ShaderPipelineCache.SaveAfterPSOsLogged is 0 |
| r.ShaderPipelineCache.AutoSaveTimeBoundPSO | Set the time where any logged PSO’s will be saved when -logpso is on th ecommand line. |
| r.ShaderPipelineCache.BackgroundBatchSize | Set the number of PipelineStateObjects to compile in a single batch operation when compiling in the background. Defaults to a maximum of 1 per frame, due to async. file IO it is less in practice. |
| r.ShaderPipelineCache.BackgroundBatchTime | The target time (in ms) to spend precompiling each frame when in the background or 0.0 to disable. When precompiling is faster the batch size will grow and when slower will shrink to attempt to occupy the full amount. Defaults to 0.0 (off). |
| r.ShaderPipelineCache.BatchSize | Set the number of PipelineStateObjects to compile in a single batch operation when compiling takes priority. Defaults to a maximum of 50 per frame, due to async. file IO it is less in practice. |
| r.ShaderPipelineCache.BatchTime | The target time (in ms) to spend precompiling each frame when compiling takes priority or 0.0 to disable. When precompiling is faster the batch size will grow and when slower will shrink to attempt to occupy the full amount. Defaults to 16.0 (max. ms per-frame of precompilation). |
| r.ShaderPipelineCache.ClearOSCache | 1 Enables the OS level clear after install, 0 disables it. |
| r.ShaderPipelineCache.Close | Close the current pipeline file cache. |
| r.ShaderPipelineCache.Enabled | 1 Enables the PipelineFileCache, 0 disables it. |
| r.ShaderPipelineCache.GameFileMaskEnabled | Set non zero to use GameFileMask during PSO precompile – recording should always save out the usage masks to make that data availble when needed. |
| r.ShaderPipelineCache.LazyLoadShadersWhenPSOCacheIsPresent | Non-Zero: If we load a PSO cache, then lazy load from the shader code library. This assumes the PSO cache is more or less complete. This will only work on RHIs that support the library+Hash CreateShader API (GRHISupportsLazyShaderCodeLoading == true). |
| r.ShaderPipelineCache.LogPSO | 1 Logs new PSO entries into the file cache and allow saving, 0 uses existing PSO file cache in readonly mode (if enabled). |
| r.ShaderPipelineCache.MinBindCount | The minimum bind count to allow a PSO to be precompiled. Changes to this value will not affect PSOs that have already been removed from consideration. |
| r.ShaderPipelineCache.Open | Takes the desired filename to open and then loads the pipeline file cache. |
| r.ShaderPipelineCache.PrintNewPSODescriptors | 1 prints descriptions for all new PSO entries to the log/console while 0 does not. Defaults to 0 in *Shipping* builds, otherwise 1. |
| r.ShaderPipelineCache.ReportPSO | 1 reports new PSO entries via a delegate, but does not record or modify any cache file. |
| r.ShaderPipelineCache.Save | Save the current pipeline file cache. |
| r.ShaderPipelineCache.SaveAfterPSOsLogged | Set the number of PipelineStateObjects to log before automatically saving. 0 will disable automatic saving. Shipping defaults to 0, otherwise default is 100. |
| r.ShaderPipelineCache.SaveBoundPSOLog | If > 0 then a log of all bound PSOs for this run of the program will be saved to a writable user cache file. Defaults to 0 but is forced on with -logpso. |
| r.ShaderPipelineCache.SaveUserCache | If > 0 then any missed PSOs will be saved to a writable user cache file for subsequent runs to load and avoid in-game hitches. Enabled by default on macOS only. |
| r.ShaderPipelineCache.SetBatchMode | Sets the compilation batch mode, which should be one of: Pause: Suspend precompilation. Background: Low priority precompilation. Fast: High priority precompilation. |
| r.ShaderPipelineCache.StartupMode | Sets the startup mode for the PSO cache, determining what the cache does after initialisation: 0: Precompilation is paused and nothing will compile until a call to ResumeBatching(). 1: Precompilation is enabled in the ‘Fast’ mode. 2: Precompilation is enabled in the ‘Background’ mode. Default is 1. |
| r.ShaderPipelines | Enable using Shader pipelines. |
| r.ShaderPrintEnable | ShaderPrint debugging toggle. |
| r.ShaderPrintFontSize | ShaderPrint font size. |
| r.ShaderPrintFontSpacingX | ShaderPrint horizontal spacing between symbols. |
| r.ShaderPrintFontSpacingY | ShaderPrint vertical spacing between symbols. |
| r.ShaderPrintMaxValueCount | ShaderPrint output buffer size. |
| r.Shaders.BoundsChecking | Whether to enforce bounds-checking & flush-to-zero/ignore for buffer reads & writes in shaders. Defaults to 1 (enabled). Not all shader languages can omit bounds checking. |
| r.Shaders.ExportDebugInfo | Whether to export the shader reflection and debug data from shader bytecode as separate files.r.Shaders.KeepDebugInfo must be enabled and r.DumpShaderDebugInfo will enable this cvar.For some platforms this cvar can be overriden in the Engine.ini, under the [ShaderCompiler] section. |
| r.Shaders.ExportDebugInfoMode | 0: Export as loose files. 1: Export as an uncompressed archive. |
| r.Shaders.FastMath | Whether to use fast-math optimisations in shaders. |
| r.Shaders.FlowControlMode | Specifies whether the shader compiler should preserve or unroll flow-control in shader code. This is primarily a debugging aid and will override any per-shader or per-material settings if not left at the default value (0). 0: Off (Default) – Entirely at the discretion of the platform compiler or the specific shader/material. 1: Prefer – Attempt to preserve flow-control. 2: Avoid – Attempt to unroll and flatten flow-control. |
| r.Shaders.KeepDebugInfo | Whether to keep shader reflection and debug data from shader bytecode, default is to strip. When using graphical debuggers like Nsight it can be useful to enable this on startup.For some platforms this cvar can be overriden in the Engine.ini, under the [ShaderCompiler] section. |
| r.Shaders.Optimize | Whether to optimize shaders. When using graphical debuggers like Nsight it can be useful to disable this on startup. |
| r.Shaders.ZeroInitialise | Whether to enforce zero initialise local variables of primitive type in shaders. Defaults to 1 (enabled). Not all shader languages can omit zero initialisation. |
| r.Shadow.CachedShadowsCastFromMovablePrimitives | Whether movable primitives should cast a shadow from cached whole scene shadows (movable point and spot lights). Disabling this can be used to remove the copy of the cached shadowmap. |
| r.Shadow.CachePreshadow | Whether preshadows can be cached as an optimization |
| r.Shadow.CacheWholeSceneShadows | When enabled, movable point and spot light whole scene shadow depths from static primitives will be cached as an optimization. |
| r.Shadow.CacheWPOPrimitives | Whether primitives whose materials use World Position Offset should be considered movable for cached shadowmaps. Enablings this gives more correct, but slower whole scene shadows from materials that use WPO. |
| r.Shadow.ConservativeBounds | Whether to use safe and conservative shadow frustum creation that wastes some shadowmap space |
| r.Shadow.CSM.MaxCascades | The maximum number of cascades with which to render dynamic directional light shadows. |
| r.Shadow.CSM.MaxMobileCascades | The maximum number of cascades with which to render dynamic directional light shadows when using the mobile renderer. |
| r.Shadow.CSM.TransitionScale | Allows to scale the cascaded shadow map transition region. Clamped within 0..2. 0: no transition (fastest) 1: as specific in the light settings (default) 2: 2x larger than what was specified in the light |
| r.Shadow.CSMDepthBias | Constant depth bias used by CSM |
| r.Shadow.CSMDepthBoundsTest | Whether to use depth bounds tests rather than stencil tests for the CSM bounds |
| r.Shadow.CSMReceiverBias | Receiver bias used by CSM. Value between 0 and 1. |
| r.Shadow.CSMShadowDistanceFadeoutMultiplier | Multiplier for the CSM distance fade |
| r.Shadow.CSMSlopeScaleDepthBias | Slope scale depth bias used by CSM |
| r.Shadow.CSMSplitPenumbraScale | Scale applied to the penumbra size of Cascaded Shadow Map splits, useful for minimizing the transition between splits |
| r.Shadow.Denoiser | Choose the denoising algorithm. 0: Disabled (default); 1: Forces the default denoiser of the renderer; 2: GScreenSpaceDenoiser witch may be overriden by a third party plugin. |
| r.Shadow.Denoiser.HistoryConvolutionSamples | Number of samples to use to convolve the history over time. |
| r.Shadow.Denoiser.MaxBatchSize | Maximum number of shadow to denoise at the same time. |
| r.Shadow.Denoiser.PreConvolution | Number of pre-convolution passes (default = 1). |
| r.Shadow.Denoiser.ReconstructionSamples | Maximum number of samples for the reconstruction pass (default = 16). |
| r.Shadow.Denoiser.TemporalAccumulation | |
| r.Shadow.Denoiser.Use1SPPCodePath | Whether to use the 1spp code path. |
| r.Shadow.DistanceScale | Scalability option to trade shadow distance versus performance for directional lights (clamped within a reasonable range). <1: shorter distance 1: normal (default) >1: larger distance |
| r.Shadow.DrawPreshadowFrustums | visualize preshadow frustums when the shadowfrustums show flag is enabled |
| r.Shadow.EnableModulatedSelfShadow | Allows modulated shadows to affect the shadow caster. (mobile only) |
| r.Shadow.FadeExponent | Controls the rate at which shadows are faded out |
| r.Shadow.FadeResolution | Resolution in texels below which shadows are faded out |
| r.Shadow.FilterMethod | Chooses the shadow filtering method. 0: Uniform PCF (default) 1: PCSS (experimental) |
| r.Shadow.ForceSingleSampleShadowingFromStationary | Whether to force all components to act as if they have bSingleSampleShadowFromStationaryLights enabled. Useful for scalability when dynamic shadows are disabled. |
| r.Shadow.FreezeCamera | Debug the shadow methods by allowing to observe the system from outside. 0: default 1: freeze camera at current location |
| r.Shadow.LightViewConvexHullCull | Enables culling of shadow casters that do not intersect the convex hull of the light origin and view frustum. |
| r.Shadow.MaxCSMResolution | Max square dimensions (in texels) allowed for rendering Cascaded Shadow depths. Range 4 to hardware limit. Higher = better quality shadows but at a performance cost. |
| r.Shadow.MaxNumPointShadowCacheUpdatesPerFrame | Maximum number of point light shadow cache updates allowed per frame.Only affect updates caused by resolution change. -1 means no limit. |
| r.Shadow.MaxNumSpotShadowCacheUpdatesPerFrame | Maximum number of spot light shadow cache updates allowed per frame.Only affect updates caused by resolution change. -1 means no limit. |
| r.Shadow.MaxResolution | Max square dimensions (in texels) allowed for rendering shadow depths. Range 4 to hardware limit. Higher = better quality shadows but at a performance cost. |
| r.Shadow.MaxSoftKernelSize | Mazimum size of the softening kernels in pixels. |
| r.Shadow.MinPreShadowResolution | Minimum dimensions (in texels) allowed for rendering preshadow depths |
| r.Shadow.MinResolution | Minimum dimensions (in texels) allowed for rendering shadow subject depths |
| r.Shadow.OcclusionCullCascadedShadowMaps | Whether to use occlusion culling on cascaded shadow maps. Disabled by default because rapid view changes reveal new regions too quickly for latent occlusion queries to work with. |
| r.Shadow.PerObject | Whether to render per object shadows (character casting on world) 0: off 1: on (default) |
| r.Shadow.PerObjectCastDistanceRadiusScale | PerObjectCastDistanceRadiusScale The scale factor multiplied with the radius of the object to calculate the maximum distance a per-object directional shadow can reach. This will only take effect after a certain (large) radius. Default is 8 times the object radius. |
| r.Shadow.PerObjectDirectionalDepthBias | Constant depth bias used by per-object shadows from directional lights Lower values give better shadow contact, but increase self-shadowing artifacts |
| r.Shadow.PerObjectDirectionalSlopeDepthBias | Slope scale depth bias used by per-object shadows from directional lights Lower values give better shadow contact, but increase self-shadowing artifacts |
| r.Shadow.PointLightDepthBias | Depth bias that is applied in the depth pass for shadows from point lights. (0.03 avoids peter paning but has some shadow acne) |
| r.Shadow.PointLightSlopeScaleDepthBias | Slope scale depth bias that is applied in the depth pass for shadows from point lights |
| r.Shadow.PreshadowExpand | How much bounds will be expanded when rendering a cached preshadow (0.15 = 15% larger) |
| r.Shadow.PreShadowFadeResolution | Resolution in texels below which preshadows are faded out |
| r.Shadow.PreShadowResolutionFactor | Mulitplier for preshadow resolution |
| r.Shadow.Preshadows | Whether to allow preshadows (static world casting on character) |
| r.Shadow.PreshadowsForceLowestDetailLevel | When enabled, static meshes render their lowest detail level into preshadow depth maps. Disabled by default as it causes artifacts with poor quality LODs (tree billboard). |
| r.Shadow.RadiusThreshold | Cull shadow casters if they are too small, value is the minimal screen space bounding sphere radius |
| r.Shadow.RadiusThresholdRSM | Cull shadow casters in the RSM if they are too small, values is the minimal screen space bounding sphere radius (default 0.06) |
| r.Shadow.RectLightDepthBias | Depth bias that is applied in the depth pass for shadows from rect lights. (0.03 avoids peter paning but has some shadow acne) |
| r.Shadow.RectLightReceiverBias | Receiver bias used by rect light. Value between 0 and 1. |
| r.Shadow.RectLightSlopeScaleDepthBias | Slope scale depth bias that is applied in the depth pass for shadows from rect lights |
| r.Shadow.ShadowMaxSlopeScaleDepthBias | Max Slope depth bias used for shadows for all lights Higher values give better self-shadowing, but increase self-shadowing artifacts |
| r.Shadow.SpotLightDepthBias | Depth bias that is applied in the depth pass for per object projected shadows from spot lights |
| r.Shadow.SpotLightReceiverBias | Receiver bias used by spotlights. Value between 0 and 1. |
| r.Shadow.SpotLightSlopeDepthBias | Slope scale depth bias that is applied in the depth pass for per object projected shadows from spot lights |
| r.Shadow.SpotLightTransitionScale | Transition scale for spotlights |
| r.Shadow.StencilOptimization | Removes stencil clears between shadow projections by zeroing the stencil during testing |
| r.Shadow.TexelsPerPixel | The ratio of subject pixels to shadow texels for per-object shadows |
| r.Shadow.TexelsPerPixelPointlight | The ratio of subject pixels to shadow texels for point lights |
| r.Shadow.TexelsPerPixelRectlight | The ratio of subject pixels to shadow texels for rect lights |
| r.Shadow.TexelsPerPixelSpotlight | The ratio of subject pixels to shadow texels for spotlights |
| r.Shadow.TransitionScale | This controls the ‘fade in’ region between a caster and where his shadow shows up. Larger values make a smaller region which will have more self shadowing artifacts |
| r.Shadow.UnbuiltNumWholeSceneDynamicShadowCascades | DynamicShadowCascades to use when using CSM to preview unbuilt lighting from a directional light |
| r.Shadow.UnbuiltPreviewInGame | Whether to render unbuilt preview shadows in game. When enabled and lighting is not built, expensive preview shadows will be rendered in game. When disabled, lighting in game and editor won’t match which can appear to be a bug. |
| r.Shadow.UnbuiltWholeSceneDynamicShadowRadius | WholeSceneDynamicShadowRadius to use when using CSM to preview unbuilt lighting from a directional light |
| r.Shadow.UseOctreeForCulling | Whether to use the primitive octree for shadow subject culling. The octree culls large groups of primitives at a time, but introduces cache misses walking the data structure. |
| r.Shadow.WholeSceneShadowCacheMb | Amount of memory that can be spent caching whole scene shadows. ShadowMap allocations in a single frame can cause this to be exceeded. |
| r.Shadow.WholeSceneShadowUnbuiltInteractionThreshold | How many unbuilt light-primitive interactions there can be for a light before the light switches to whole scene shadows |
| r.ShadowQuality | Defines the shadow method which allows to adjust for quality or performance. 0:off, 1:low(unfiltered), 2:low .. 5:max (default) |
| r.ShowMaterialDrawEvents | Whether to emit a draw event around every mesh draw call with information about the assets used. Introduces severe CPU and GPU overhead when enabled, but useful for debugging. |
| r.ShowPrecomputedVisibilityCells | If not zero, draw all precomputed visibility cells. |
| r.ShowRelevantPrecomputedVisibilityCells | If not zero, draw relevant precomputed visibility cells only. |
| r.ShowShaderCompilerWarnings | When set to 1, will display all warnings. |
| r.SimpleForwardShading | Whether to use the simple forward shading base pass shaders which only support lightmaps + stationary directional light + stationary skylight All other lighting features are disabled when true. This is useful for supporting very low end hardware, and is only supported on PC platforms. 0:off, 1:on |
| r.SkeletalMesh.StripMinLodDataDuringCooking | If set will strip skeletal mesh LODs under the minimum renderable LOD for the target platform during cooking. |
| r.SkeletalMeshLODBias | LOD bias for skeletal meshes (does not affect animation editor viewports). |
| r.SkeletalMeshLODRadiusScale | Scale factor for the screen radius used in computing discrete LOD for skeletal meshes. (0.25-1) |
| r.SkeletalMeshReductionModule | Name of what skeletal mesh reduction module to choose. If blank it chooses any that exist. |
| r.SkinCache.AllowDupedVertsForRecomputeTangents | 0: off (default) 1: Forces that vertices at the same position will be treated differently and has the potential to cause seams when verts are split. |
| r.SkinCache.CompileShaders | Whether or not to compile the GPU compute skinning cache shaders. This will compile the shaders for skinning on a compute job and not skin on the vertex shader. GPUSkinVertexFactory.usf needs to be touched to cause a recompile if this changes. 0 is off(default), 1 is on |
| r.SkinCache.Debug | A scaling constant passed to the SkinCache shader, useful for debugging |
| r.SkinCache.ForceRecomputeTangents | 0: off (default) 1: Forces enabling and using the skincache and forces all skinned object to Recompute Tangents |
| r.SkinCache.Mode | Whether or not to use the GPU compute skinning cache. This will perform skinning on a compute job and not skin on the vertex shader. Requires r.SkinCache.CompileShaders=1 0: off 1: on(default) 2: only use skin cache for skinned meshes that ticked the Recompute Tangents checkbox (unavailable in shipping builds) |
| r.SkinCache.NumTangentIntermediateBuffers | How many intermediate buffers to use for intermediate results while doing Recompute Tangents; more may allow the GPU to overlap compute jobs. |
| r.SkinCache.RecomputeTangents | This option enables recomputing the vertex tangents on the GPU. Can be changed at runtime, requires both r.SkinCache.CompileShaders=1 and r.SkinCache.Mode=1 0: off 1: on, forces all skinned object to Recompute Tangents 2: on, only recompute tangents on skinned objects who ticked the Recompute Tangents checkbox(default) |
| r.SkinCache.SceneMemoryLimitInMB | Maximum memory allowed to be allocated per World/Scene in Megs |
| r.SkyLightingQuality | Defines the sky lighting quality which allows to adjust for performance. <=0: off (fastest) 1: on |
| r.SkylightIntensityMultiplier | Intensity scale on Stationary and Movable skylights. This is useful to control overall lighting contrast in dynamically lit games with scalability levels which disable Ambient Occlusion. For example, if medium quality disables SSAO and DFAO, reduce skylight intensity. |
| r.SkylightRecapture | Updates all stationary and movable skylights, useful for debugging the capture pipeline |
| r.SkylightUpdateEveryFrame | Whether to update all skylights every frame. Useful for debugging. |
| r.SkySpecularOcclusionStrength | Strength of skylight specular occlusion from DFAO (default is 1.0) |
| r.so.MaxDistanceForOccluder | Max radius where to look for occluders. |
| r.so.MaxOccluderNum | Maximum number of primitives that can be rendered as occluders |
| r.so.MinScreenRadiusForOccluder | Threshold below which meshes will be culled from beeing an occluder. |
| r.so.SIMD | Use SIMD routines in software occlusion |
| r.so.ThreadName | 0 = AnyHiPriThreadNormalTask1 = AnyHiPriThreadHiPriTask2 = AnyNormalThreadNormalTask (Default)3 = AnyNormalThreadHiPriTask4 = AnyBackgroundThreadNormalTask5 = AnyBackgroundHiPriTask |
| r.so.VisualizeBuffer | Visualize rasterized occlusion buffer |
| r.SplineMesh.NoRecreateProxy | Optimization. If true, spline mesh proxies will not be recreated every time they are changed. They are simply updated. |
| r.SSGI.Quality | Whether to use screen space diffuse indirect and at what quality setting. |
| r.SSR.ExperimentalDenoiser | Replace SSR’s TAA pass with denoiser. |
| r.SSR.MaxRoughness | Allows to override the post process setting ScreenSpaceReflectionMaxRoughness. It defines until what roughness we fade the screen space reflections, 0.8 works well, smaller can run faster. (Useful for testing, no scalability or project setting) 0..1: use specified max roughness (overrride PostprocessVolume setting) -1: no override (default) |
| r.SSR.Quality | Whether to use screen space reflections and at what quality setting. (limits the setting in the post process settings which has a different scale) (costs performance, adds more visual realism but the technique has limits) 0: off (default) 1: low (no glossy) 2: medium (no glossy) 3: high (glossy/using roughness, few samples) 4: very high (likely too slow for real-time) |
| r.SSR.Stencil | Defines if we use the stencil prepass for the screen space reflection 0 is off (default), 1 is on |
| r.SSR.Temporal | Defines if we use the temporal smoothing for the screen space reflection 0 is off (for debugging), 1 is on (default) |
| r.SSS.Checkerboard | Enables or disables checkerboard rendering for subsurface profile rendering. This is necessary if SceneColor does not include a floating point alpha channel (e.g 32-bit formats) 0: Disabled (high quality) 1: Enabled (low quality). Surface lighting will be at reduced resolution. 2: Automatic. Non-checkerboard lighting will be applied if we have a suitable rendertarget format |
| r.SSS.Filter | Defines the filter method for Screenspace Subsurface Scattering feature. 0: point filter (useful for testing, could be cleaner) 1: bilinear filter |
| r.SSS.HalfRes | 0: full quality (not optimized, as reference) 1: parts of the algorithm runs in half resolution which is lower quality but faster (default) |
| r.SSS.Quality | Defines the quality of the recombine pass when using the SubsurfaceScatteringProfile shading model 0: low (faster, default) 1: high (sharper details but slower) -1: auto, 1 if TemporalAA is disabled (without TemporalAA the quality is more noticable) |
| r.SSS.SampleSet | Defines how many samples we use for Screenspace Subsurface Scattering feature. 0: lowest quality (6*2+1) 1: medium quality (9*2+1) 2: high quality (13*2+1) (default) |
| r.SSS.Scale | Affects the Screen space subsurface scattering pass(use shadingmodel SubsurfaceProfile, get near to the object as the default) is human skin which only scatters about 1.2cm) 0: off (if there is no object on the screen using this pass it should automatically disable the post process pass) <1: scale scatter radius down (for testing) 1: use given radius form the Subsurface scattering asset (default) >1: scale scatter radius up (for testing) |
| r.StaticMesh.EnableSaveGeneratedLODsInPackage | Enables saving generated LODs in the Package. 0 – Do not save (and hide this menu option) [default]. 1 – Enable this option and save the LODs in the Package. |
| r.StaticMesh.StripDistanceFieldDataDuringLoad | If non-zero, data for distance fields will be discarded on load. TODO: change to discard during cook!. |
| r.StaticMesh.StripMinLodDataDuringCooking | If non-zero, data for Static Mesh LOD levels below MinLOD will be discarded at cook time |
| r.StaticMesh.UpdateMeshLODGroupSettingsAtLoad | If set, LODGroup settings for static meshes will be applied at load time. |
| r.StaticMeshLODDistanceScale | Scale factor for the distance used in computing discrete LOD for static meshes. (defaults to 1) (higher values make LODs transition earlier, e.g., 2 is twice as fast / half the distance) |
| r.StencilForLODDither | Whether to use stencil tests in the prepass, and depth-equal tests in the base pass to implement LOD dithering. If disabled, LOD dithering will be done through clip() instructions in the prepass and base pass, which disables EarlyZ. Forces a full prepass when enabled. |
| r.Streaming.AmortizeCPUToGPUCopy | If set and r.Streaming.MaxNumTexturesToStreamPerFrame > 0, limit the number of 2D textures streamed from CPU memory to GPU memory each frame |
| r.Streaming.Boost | =1.0: normal <1.0: decrease wanted mip levels >1.0: increase wanted mip levels |
| r.Streaming.CheckBuildStatus | If non-zero, the engine will check whether texture streaming needs rebuild. |
| r.Streaming.DefragDynamicBounds | If non-zero, unused dynamic bounds will be removed from the update loop |
| r.Streaming.DropMips | 0: Drop No Mips 1: Drop Cached Mips 2: Drop Cached and Hidden Mips |
| r.Streaming.FlushTimeOut | Time before we timeout when flushing streaming (default=3) |
| r.Streaming.FramesForFullUpdate | Texture streaming is time sliced per frame. This values gives the number of frames to visit all textures. |
| r.Streaming.FullyLoadUsedTextures | If non-zero, all used texture will be fully streamed in as fast as possible |
| r.Streaming.HiddenPrimitiveScale | Define the resolution scale to apply when not in range. .5: drop one mip 1: ignore visiblity |
| r.Streaming.HLODStrategy | Define the HLOD streaming strategy. 0: stream 1: stream only mip 0 2: disable streaming |
| r.Streaming.LimitPoolSizeToVRAM | If non-zero, texture pool size with be limited to how much GPU mem is available. |
| r.Streaming.MaxEffectiveScreenSize | 0: Use current actual vertical screen size > 0: Clamp wanted mip size calculation to this value for the vertical screen size component. |
| r.Streaming.MaxHiddenPrimitiveViewBoost | Maximum view boost that can affect hidden primitive. This prevents temporary small FOV from streaming all textures to their highest mips. |
| r.Streaming.MaxNumTexturesToStreamPerFrame | Maximum number of 2D textures allowed to stream from CPU memory to GPU memory each frame. <= 0 means no limit. This has no effect if r.Streaming.AmortizeCPUToGPUCopy is not set |
| r.Streaming.MaxTempMemoryAllowed | Maximum temporary memory used when streaming in or out texture mips. This memory contains mips used for the new updated texture. The value must be high enough to not be a limiting streaming speed factor. |
| r.Streaming.MaxTextureUVDensity | If non-zero, the max UV density a static entry can have. Used to improve level culling from MinLevelTextureScreenSize. Component with bigger entries become handled as dynamic component. |
| r.Streaming.MinBoost | Minimum clamp for r.Streaming.Boost |
| r.Streaming.MinLevelRenderAssetScreenSize | If non-zero, levels only get handled if any of their referenced texture could be required of this size. Using conservative metrics on the level data. |
| r.Streaming.MinMipForSplitRequest | If non-zero, the minimum hidden mip for which load requests will first load the visible mip |
| r.Streaming.MipBias | 0..x reduce texture quality for streaming by a floating point number. 0: use full resolution (default) 1: drop one mip 2: drop two mips |
| r.Streaming.MipCalculationEnablePerLevelList | If non-zero, Mip size computation for streamed texture will use levels referenced with it (instead of iterating thorugh every levels). |
| r.Streaming.NumStaticComponentsProcessedPerFrame | If non-zero, the engine will incrementaly inserting levels by processing this amount of components per frame before they become visible |
| r.Streaming.OverlapAssetAndLevelTicks | Ticks render asset streaming info on a high priority task thread while ticking levels on GT |
| r.Streaming.PerTextureBiasViewBoostThreshold | Maximum view boost at which per texture bias will be increased. This prevents temporary small FOV from downgrading permanentely texture quality. |
| r.Streaming.PoolSize | -1: Default texture pool size, otherwise the size in MB |
| r.Streaming.StressTest | Set to non zero to stress test the streaming update. Negative values also slow down the IO. |
| r.Streaming.StressTest.ExtaIOLatency | An extra latency in milliseconds for each stream-in requests when doing the stress test. |
| r.Streaming.StressTest.ExtraAsyncLatency | An extra latency in milliseconds for each async task when doing the stress test. |
| r.Streaming.StressTest.FramesForFullUpdate | Num frames to update texture states when doing the stress tests. |
| r.Streaming.UseAllMips | If non-zero, all available mips will be used |
| r.Streaming.UseBackgroundThreadPool | If true, use the background thread pool for mip calculations. |
| r.Streaming.UseFixedPoolSize | If non-zero, do not allow the pool size to change at run time. |
| r.Streaming.UseMaterialData | If non-zero, material texture scales and coord will be used |
| r.Streaming.UseNewMetrics | If non-zero, will use improved set of metrics and heuristics. |
| r.Streaming.UsePerTextureBias | If non-zero, each texture will be assigned a mip bias between 0 and MipBias as required to fit in budget. |
| r.SubsurfaceScattering | 0: disabled 1: enabled (default) |
| r.SupportAllShaderPermutations | Local user config override to force all shader permutation features on. |
| r.SupportAtmosphericFog | Enables AtmosphericFog shader permutations. |
| r.SupportDepthOnlyIndexBuffers | Enables depth-only index buffers. Saves a little time at the expense of doubling the size of index buffers. |
| r.SupportLowQualityLightmaps | Support low quality lightmap shader permutations |
| r.SupportMaterialLayers | Support new material layering in 4.19. Disabling it reduces some overhead in place to support the experimental feature. |
| r.SupportPointLightWholeSceneShadows | Enables shadowcasting point lights. |
| r.SupportReversedIndexBuffers | Enables reversed index buffers. Saves a little time at the expense of doubling the size of index buffers. |
| r.SupportSimpleForwardShading | Whether to compile the shaders to support r.SimpleForwardShading being enabled (PC only). |
| r.SupportStationarySkylight | Enables Stationary and Dynamic Skylight shader permutations. |
| r.SurfelDensity | |
| r.SurfelLODDensityFraction | |
| r.SurfelMaxPerObject | |
| r.TemporalAA.AllowDownsampling | Allows half-resolution color buffer to be produced during TAA. Only possible when motion blur is off and when using compute shaders for post processing. |
| r.TemporalAA.HistoryScreenPercentage | Size of temporal AA’s history. |
| r.TemporalAA.Upsampling | Whether to do primary screen percentage with temporal AA or not. 0: use spatial upscale pass independently of TAA (default); 1: TemporalAA performs spatial and temporal upscale as screen percentage method. |
| r.TemporalAACatmullRom | Whether to use a Catmull-Rom filter kernel. Should be a bit sharper than Gaussian. |
| r.TemporalAACurrentFrameWeight | Weight of current frame’s contribution to the history. Low values cause blurriness and ghosting, high values fail to hide jittering. |
| r.TemporalAAFilterSize | Size of the filter kernel. (1.0 = smoother, 0.0 = sharper but aliased). |
| r.TemporalAAPauseCorrect | Correct temporal AA in pause. This holds onto render targets longer preventing reuse and consumes more memory. |
| r.TemporalAASamples | Number of jittered positions for temporal AA (4, 8=default, 16, 32, 64). |
| r.TemporalAAUpsampleFiltered | Use filtering to fetch color history during TamporalAA upsampling (see AA_FILTERED define in TAA shader). Disabling this makes TAAU faster, but lower quality. |
| r.TessellationAdaptivePixelsPerTriangle | Global tessellation factor multiplier |
| r.Test.CameraCut | Force enabling camera cut for testing purposes. 0: disabled (default); 1: enabled. |
| r.Test.ClobberRenderRarget | Clears the texture returned by the rendertarget pool with a special color so we can see better which passes would need to clear. Doesn’t work on volume textures and non rendertargets yet. 0:off (default); 1: 1000 on RGBA channels; 2: NaN on RGBA channels; 3: +INFINITY on RGBA channels. |
| r.Test.ConstrainedView | Allows to test different viewport rectangle configuations (in game only) as they can happen when using Matinee/Editor. 0: off(default) 1..7: Various Configuations |
| r.Test.DynamicResolutionHell | Override the screen percentage interface for all view family with dynamic resolution hell. 0: off (default); 1: Dynamic resolution hell. |
| r.Test.EditorConstrainedView | Allows to test different viewport rectangle configuations (in game only) as they can happen when using Matinee/Editor. 0: off(default) 1..7: Various Configuations |
| r.Test.ForceBlackVelocityBuffer | Force the velocity buffer to have no motion vector for debugging purpose. |
| r.Test.FreezeTemporalHistories | Freezes all temporal histories as well as the temporal sequence. |
| r.Test.FreezeTemporalSequences | Freezes all temporal sequences. |
| r.Test.PrimaryScreenPercentageMethodOverride | Override the screen percentage method for all view family. 0: view family’s screen percentage interface choose; (default) 1: old fashion upscaling pass at the very end right before before UI; 2: TemporalAA upsample. |
| r.Test.SecondaryUpscaleOverride | Override the secondary upscale. 0: disabled; (default) 1: use secondary view fraction = 0.5 with nearest secondary upscale. |
| r.Test.ViewRectOffset | Moves the view rect within the renderer’s internal render target. 0: disabled (default); |
| r.TexelDebugging | Whether T + Left mouse click in the editor selects lightmap texels for debugging Lightmass. Lightmass must be recompiled with ALLOW_LIGHTMAP_SAMPLE_DEBUGGING enabled for this to work. |
| r.TextureStreaming | Allows to define if texture streaming is enabled, can be changed at run time. 0: off 1: on (default) |
| r.TiledDeferredShading | Whether to use tiled deferred shading. 0 is off, 1 is on (default) |
| r.TiledDeferredShading.MinimumCount | Number of applicable lights that must be on screen before switching to tiled deferred. 0 means all lights that qualify (e.g. no shadows, …) are rendered tiled deferred. Default: 80 |
| r.TogglePreCulledIndexBuffers | Toggles use of preculled index buffers from the command ‘PreCullIndexBuffers’ |
| r.Tonemapper.ConfigIndexOverride | direct configindex override. Ignores all other tonemapper configuration cvars |
| r.Tonemapper.GrainQuantization | 0: low (minor performance benefit) 1: high (default, with high frequency pixel pattern to fight 8 bit color quantization) |
| r.Tonemapper.MergeWithUpscale.Mode | ScreenPercentage upscale integrated into tonemapper pass (if certain conditions apply, e.g., no FXAA) if enabled both features are done in one pass (faster, affects post process passes after the tonemapper including material post process e.g. sharpen) 0: off, the features run in separate passes (default) 1: always enabled, try to merge the passes unless something makes it impossible 2: merge when the ratio of areas is above the r.Tonemapper.MergeWithUpscale.Threshold and it is otherwise possible |
| r.Tonemapper.MergeWithUpscale.Threshold | If r.Tonemapper.MergeWithUpscale.Mode is 2, the ratio of the area before upscale/downscale to the area afterwards is compared to this threshold when deciding whether or not to merge the passes. The reasoning is that if the ratio is too low, running the tonemapper on the higher number of pixels is more expensive than doing two passes Defauls to 0.49 (e.g., if r.ScreenPercentage is 70 or higher, try to merge) |
| r.Tonemapper.Quality | Defines the Tonemapper Quality in the range 0..5 Depending on the used settings we might pick a faster shader permutation 0: basic tonemapper only, lowest quality 1: + FilmContrast 2: + Vignette 3: + FilmShadowTintAmount 4: + Grain 5: + GrainJitter = full quality (default) |
| r.Tonemapper.Sharpen | Sharpening in the tonemapper (not for ES2), actual implementation is work in progress, clamped at 10 0: off(default) 0.5: half strength 1: full strength |
| r.TonemapperFilm | Use new film tone mapper |
| r.TonemapperGamma | 0: Default behavior #: Use fixed gamma # instead of sRGB or Rec709 transform |
| r.TransientResourceAliasing.Buffers | Enables transient resource aliasing for specified buffers. Used only if GSupportsTransientResourceAliasing is true. |
| r.TransitionChecksEnableDX11 | Enables transition checks in the DX11 RHI. |
| r.TranslucencyLightingVolumeDim | Dimensions of the volume textures used for translucency lighting. Larger textures result in higher resolution but lower performance. |
| r.TranslucencyLightingVolumeInnerDistance | Distance from the camera that the first volume cascade should end |
| r.TranslucencyLightingVolumeOuterDistance | Distance from the camera that the second volume cascade should end |
| r.TranslucencyVolumeBlur | Whether to blur the translucent lighting volumes. 0:off, otherwise on, default is 1 |
| r.TranslucentLightingVolume | Whether to allow updating the translucent lighting volumes. 0:off, otherwise on, default is 1 |
| r.TranslucentSortPolicy | 0: Sort based on distance from camera centerpoint to bounding sphere centerpoint. (default, best for 3D games) 1: Sort based on projected distance to camera.2: Sort based on the projection onto a fixed axis. (best for 2D games) |
| r.TranslucentVolumeFOVSnapFactor | FOV will be snapped to a factor of this before computing volume bounds. |
| r.TranslucentVolumeMinFOV | Minimum FOV for translucent lighting volume. Prevents popping in lighting when zooming in. |
| r.TriangleOrderOptimization | Controls the algorithm to use when optimizing the triangle order for the post-transform cache. 0: Use NVTriStrip (slower) 1: Use Forsyth algorithm (fastest)(default)2: No triangle order optimization. (least efficient, debugging purposes only) |
| r.UITextureLODBias | Extra LOD bias to apply to UI textures. (default=0) |
| r.UnbindResourcesBetweenDrawsInDX11 | Unbind resources between material changes in DX11. |
| r.UniformBufferPooling | If we pool object in RHICreateUniformBuffer to have less real API calls to creat buffers 0: off (for debugging) 1: on (optimization) |
| r.UpdateReflectionCaptureEveryFrame | When set, reflection captures will constantly be scheduled for update. |
| r.Upscale.Panini.D | Allow and configure to apply a panini distortion to the rendered image. Values between 0 and 1 allow to fade the effect (lerp). Implementation from research paper « Pannini: A New Projection for Rendering Wide Angle Perspective Images » 0: off (default) >0: enabled (requires an extra post processing pass if upsampling wasn’t used – see r.ScreenPercentage) 1: Panini cylindrical stereographic projection |
| r.Upscale.Panini.S | Panini projection’s hard vertical compression factor. 0: no vertical compression factor (default) 1: Hard vertical compression |
| r.Upscale.Panini.ScreenFit | Panini projection screen fit effect factor (lerp). 0: fit vertically 1: fit horizontally (default) |
| r.Upscale.Quality | Defines the quality in which ScreenPercentage and WindowedFullscreen scales the 3d rendering. 0: Nearest filtering 1: Simple Bilinear 2: Directional blur with unsharp mask upsample. 3: 5-tap Catmull-Rom bicubic, approximating Lanczos 2. (default) 4: 13-tap Lanczos 3. 5: 36-tap Gaussian-filtered unsharp mask (very expensive, but good for extreme upsampling). |
| r.Upscale.Softness | Amount of sharpening for Gaussian Unsharp filter (r.UpscaleQuality=5). Reduce if ringing is visible 1: Normal sharpening (default) 0: No sharpening (pure Gaussian). |
| r.UseClusteredDeferredShading | Toggle use of clustered deferred shading for lights that support it. 0 is off (default), 1 is on (also required is SM5 to actually turn on). |
| r.UseFastDebugObjectDiscovery | Enable new optimised debug object discovery |
| r.UseFastIntersect | Use optimized 8 plane fast intersection code if we have 8 permuted planes. |
| r.UseMobileBloom | HACK: Set to 1 to use mobile bloom. |
| r.UseParallelGetDynamicMeshElementsTasks | If > 0, and if FApp::ShouldUseThreadingForPerformance(), then parts of GetDynamicMeshElements will be done in parallel. |
| r.UsePreExposure | 0 to disable pre-exposure, 1 to enable it (default). Pre-exposure allows the engine to apply the last frame exposure to luminance values before writing them in rendertargets. It avoids rendertarget overflow when using low precision formats like fp16. The pre-exposure value can be overriden through r.EyeAdaptation.PreExposureOverride |
| r.VelocityTest | Allows to enable some low level testing code for the velocity rendering (Affects object motion blur and TemporalAA). 0: off (default) 1: add random data to the buffer where we store skeletal mesh bone data to test if the code (good to test in PAUSED as well). |
| r.VertexFoggingForOpaque | Causes opaque materials to use per-vertex fogging, which costs less and integrates properly with MSAA. Only supported with forward shading. |
| r.ViewDistanceScale | Controls the view distance scale. A primitive’s MaxDrawDistance is scaled by this value. Higher values will increase view distance but at a performance cost. Default = 1. |
| r.ViewDistanceScale.ApplySecondaryScale | If true applies the secondary view distance scale to primitive draw distances. Default = 0. |
| r.ViewDistanceScale.FieldOfViewAffectsHLOD | If enabled, applies the field of view scaling to HLOD draw distances as well as non-HLODs. |
| r.ViewDistanceScale.FieldOfViewMaxAngle | Scales the scene view distance scale with camera field of view. Maximum angle of the blend range. Applies the maximum scale when the camera is at or above this angle. |
| r.ViewDistanceScale.FieldOfViewMaxAngleScale | Scales the scene view distance scale with camera field of view. This value is applied when the camera is at or above the maximum angle. |
| r.ViewDistanceScale.FieldOfViewMinAngle | Scales the scene view distance scale with camera field of view. Minimum angle of the blend range. Applies the minimum scale when the camera is at or below this angle. |
| r.ViewDistanceScale.FieldOfViewMinAngleScale | Scales the scene view distance scale with camera field of view. This value is applied when the camera is at or below the minimum angle. |
| r.ViewDistanceScale.SecondaryScale | Controls the secondary view distance scale, Default = 1.0. This is an optional scale intended to allow some features or gamemodes to opt-in. |
| r.ViewMode.ShaderTimeSlice | Max time to allocate each frame to generate new shaders. 0 disables (default=.02 |
| r.ViewRectUseScreenBottom | WARNING: This is an experimental, unsupported feature and does not work with all postprocesses (e.g DOF and DFAO) If enabled, the view rectangle will use the bottom left corner instead of top left |
| r.ViewTextureMipBias.Min | Automatic view mip bias’s minimum value (default to -1). |
| r.ViewTextureMipBias.Offset | Automatic view mip bias’s constant offset (default to -0.3). |
| r.VirtualTexture | If set to 1, textures will use virtual memory so they can be partially resident. |
| r.VirtualTexturedLightmaps | Controls wether to stream the lightmaps using virtual texturing. 0: Disabled. 1: Enabled. |
| r.VirtualTextureReducedMemory | If set to 1, the cost of virtual textures will be reduced by using a more packed layout. |
| r.VirtualTextures | Is virtual texture streaming enabled? |
| r.VisualizeOccludedPrimitives | Draw boxes for all occluded primitives |
| r.VisualizeTexture.AllowBlinking | Whether to allow blinking when visualizing NaN or inf that can become irritating over time. |
| r.VisualizeTexturePool | Allows to enable the visualize the texture pool (currently only on console). 0: off (default) 1: on |
| r.VolumetricFog | Whether to allow the volumetric fog feature. |
| r.VolumetricFog.DepthDistributionScale | Scales the slice depth distribution. |
| r.VolumetricFog.GridPixelSize | XY Size of a cell in the voxel grid, in pixels. |
| r.VolumetricFog.GridSizeZ | How many Volumetric Fog cells to use in z. |
| r.VolumetricFog.HistoryMissSupersampleCount | Number of lighting samples to compute for voxels whose history value is not available. This reduces noise when panning or on camera cuts, but introduces a variable cost to volumetric fog computation. Valid range [1, 16]. |
| r.VolumetricFog.HistoryWeight | How much the history value should be weighted each frame. This is a tradeoff between visible jittering and responsiveness. |
| r.VolumetricFog.InjectShadowedLightsSeparately | Whether to allow the volumetric fog feature. |
| r.VolumetricFog.InverseSquaredLightDistanceBiasScale | Scales the amount added to the inverse squared falloff denominator. This effectively removes the spike from inverse squared falloff that causes extreme aliasing. |
| r.VolumetricFog.Jitter | Whether to apply jitter to each frame’s volumetric fog computation, achieving temporal super sampling. |
| r.VolumetricFog.LightFunctionSupersampleScale | Scales the slice depth distribution. |
| r.VolumetricFog.TemporalReprojection | Whether to use temporal reprojection on volumetric fog. |
| r.VolumetricFog.VoxelizationShowOnlyPassIndex | When >= 0, indicates a single voxelization pass to render for debugging. |
| r.VolumetricFog.VoxelizationSlicesPerGSPass | How many depth slices to render in a single voxelization pass (max geometry shader expansion). Must recompile voxelization shaders to propagate changes. |
| r.VolumetricLightmap.VisualizationMinScreenFraction | Minimum screen size of a volumetric lightmap visualization sphere |
| r.VolumetricLightmap.VisualizationRadiusScale | Scales the size of the spheres used to visualize volumetric lightmap samples. |
| r.VPLDirectionalLightTraceDistance | |
| r.VPLGridDimension | |
| r.VPLMeshGlobalIllumination | |
| r.VPLPlacementCameraRadius | |
| r.VPLSelfOcclusionReplacement | |
| r.VPLSpreadUpdateOver | |
| r.VPLSurfelRepresentation | |
| r.VPLViewCulling | |
| r.VSync | 0: VSync is disabled.(default) 1: VSync is enabled. |
| r.VSyncEditor | 0: VSync is disabled in editor.(default) 1: VSync is enabled in editor. |
| r.VT.Borders | If > 0, debug borders will enabled |
| r.VT.CodecAgeThreshold | Mininum number of frames VT codec must be unused before possibly being retired |
| r.VT.CodecNumThreshold | Once number of VT codecs exceeds this number, attempt to retire codecs that haven’t been recently used |
| r.VT.Dump | Lot a whole lot of info on the VT system state. |
| r.VT.EnableCompressCrunch | Enable Crunch compression for virtual textures, for supported formats |
| r.VT.EnableCompressZlib | Enables Zlib compression for virtual textures, if no compression is enabled/supported |
| r.VT.EnableFeedBack | process readback buffer? dev option. |
| r.VT.EnableLossyCompressLightmaps | Enables lossy compression on virtual texture lightmaps. Lossy compression tends to have lower quality on lightmap textures, vs regular color textures. |
| r.vt.FeedbackFactor | The size of the VT feedback buffer is calculated by dividing the render resolution by this factor |
| r.VT.Flush | Flush all the physical caches in the VT system. |
| r.VT.FlushAndEvictFileCache | Flush both the virtual texture physcial page cache and disk file cachje |
| r.VT.ListPhysicalPools | Lot a whole lot of info on the VT system state. |
| r.VT.MaskedPageTableUpdates | Masks the page table update quads to reduce pixel fill costs |
| r.VT.MaxUploadsPerFrame | Max number of page uploads per frame |
| r.VT.NumFeedbackTasks | Number of tasks to create to process virtual texture updates. |
| r.VT.NumGatherTasks | Number of tasks to create to process virtual texture updates. |
| r.VT.NumTranscodeRequests | Number of transcode request that can be in flight. default 128 |
| r.VT.PageUpdateFlushCount | Number of page updates to buffer before attempting to flush by taking a lock. |
| r.VT.ParallelTileCompression | Enables parallel compression of macro tiles |
| r.VT.RefreshEntirePageTable | Refreshes the entire page table texture every frame |
| r.VT.TileBorderSize | Size in pixels to use for virtual texture tiles borders (rounded to next power-of-2) |
| r.VT.TileSize | Size in pixels to use for virtual texture tiles (rounded to next power-of-2) |
| r.VT.TranscodeRetireAge | If a VT transcode request is not picked up after this number of frames, drop it and put request in cache as free. default 60 |
| r.VT.Verbose | Be pedantic about certain things that shouln’t occur unless something is wrong. This may cause a lot of logspam 100’s of lines per frame. |
| r.Vulkan.AllowAsyncCompute | 0 to disable async compute queue(if available)1 to allow async compute queue |
| r.Vulkan.AllowPresentOnComputeQueue | 0 to present on the graphics queue1 to allow presenting on the compute queue if available |
| r.Vulkan.AllowUniformUpload | Allow Uniform Buffer uploads outside of renderpasses 0: Disabled, buffers are always reallocated 1: Enabled, buffers are uploaded outside renderpasses |
| r.Vulkan.AlwaysWriteDS | |
| r.Vulkan.CPURenderthreadFramePacer | Whether to enable the simple RHI thread CPU Framepacer for Vulkan |
| r.Vulkan.CPURHIThreadFramePacer | Whether to enable the simple RHI thread CPU Framepacer for Vulkan |
| r.Vulkan.CpuWaitForFence | Whether to have the Cpu wait for the fence in AcquireImageIndex |
| r.Vulkan.DebugBarrier | Forces a full barrier for debugging. This is a mask/bitfield (so add up the values)! 0: Don’t (default) 1: Enable heavy barriers after EndRenderPass() 2: Enable heavy barriers after every dispatch 4: Enable heavy barriers after upload cmd buffers 8: Enable heavy barriers after active cmd buffers 16: Enable heavy buffer barrier after uploads 32: Enable heavy buffer barrier between acquiring back buffer and blitting into swapchain |
| r.Vulkan.DebugVsync | Whether to print vulkan vsync data |
| r.Vulkan.DelayAcquireBackBuffer | Whether to delay acquiring the back buffer 0: acquire next image on frame start 1: acquire next image just before presenting, rendering is done to intermediate image which is then copied to a real backbuffer (default) 2: acquire next image on first use |
| r.Vulkan.DescriptorSetLayoutMode | 0 to not change layouts (eg Set 0 = Vertex, 1 = Pixel, etc 1 to use a new set for common Uniform Buffers 2 to collapse all sets into Set 0 |
| r.Vulkan.DSetCacheMaxPoolLookups | Maximum count of pool’s caches to lookup before allocating new descriptor. |
| r.Vulkan.DSetCacheTargetSetsPerPool | Target number of descriptor set allocations per single pool. |
| r.Vulkan.DynamicGlobalUBs | 2 to treat ALL uniform buffers as dynamic 1 to treat global/packed uniform buffers as dynamic [default] 0 to treat them as regular |
| r.Vulkan.EnableValidation | 0 to disable validation layers (default) 1 to enable errors 2 to enable errors & warnings 3 to enable errors, warnings & performance warnings 4 to enable errors, warnings, performance & information messages 5 to enable all messages |
| r.Vulkan.ExtensionFramePacer | Whether to enable the google extension Framepacer for Vulkan (when available on device) |
| r.Vulkan.ForceCoherentOperations | 1 forces memory invalidation and flushing of coherent memory |
| r.Vulkan.IgnoreCPUReads | Debugging utility for GPU->CPU reads. 0 will read from the GPU (default). 1 will read from GPU but fill the buffer instead of copying from a texture. 2 will NOT read from the GPU and fill with zeros. |
| r.Vulkan.KeepSwapChain | Whether to keep old swap chain to pass through when creating the next one |
| r.Vulkan.PipelineCacheCompression | Enable/disable compression on the Vulkan pipeline cache disk file |
| r.Vulkan.PipelineCacheFromShaderPipelineCache | 0 look for a pipeline cache in the normal locations with the normal names.1 tie the vulkan pipeline cache to the shader pipeline cache, use the PSOFC guid as part of the filename, etc. |
| r.Vulkan.PipelineCacheLoad | 0 to disable loading the pipeline cache1 to enable using pipeline cache |
| r.Vulkan.PipelineLRUCacheEvictBinaryPreloadScreen | 1: Use a preload screen while loading preevicted PSOs ala r.Vulkan.PipelineLRUCacheEvictBinary |
| r.Vulkan.ProfileCmdBuffers | Insert GPU timing queries in every cmd buffer |
| r.Vulkan.RHIThread | 0 to only use Render Thread 1 to use ONE RHI Thread 2 to use multiple RHI Thread |
| r.Vulkan.RobustBufferAccess | 0 to disable robust buffer access1 to enable (default) |
| r.Vulkan.StandardValidation | 2 to use VK_LAYER_KHRONOS_validation (default) if available 1 to use VK_LAYER_LUNARG_standard_validation if available, or 0 to use individual validation layers (deprecated) |
| r.Vulkan.SubmitAfterEveryEndRenderPass | Forces a submit after every end render pass. 0: Don’t(default) 1: Enable submitting |
| r.Vulkan.SubmitOcclusionBatchCmdBuffer | 1 to submit the cmd buffer after end occlusion query batch (default) |
| r.Vulkan.SubmitOnCopyToResolve | Submits the Queue to the GPU on every RHICopyToResolveTarget call. 0: Do not submit (default) 1: Submit |
| r.Vulkan.SubmitOnDispatch | 0 to not do anything special on dispatch(default) 1 to submit the cmd buffer after each dispatch |
| r.Vulkan.SubmitOnTextureUnlock | Whether to submit upload cmd buffer on each texture unlock. 0: Do not submit 1: Submit (default) |
| r.Vulkan.UniqueValidationMessages | Filter out validation errors with the same code (only when r.Vulkan.EnableValidation is non zero) |
| r.Vulkan.UseBufferBinning | Enable binning sub-allocations within buffers to help reduce fragmentation at the expense of higher high watermark [read-only] |
| r.Vulkan.UseRealUBs | 0: Emulate uniform buffers on Vulkan SM4/SM5 (debugging ONLY) 1: Use real uniform buffers [default] |
| r.Vulkan.UseSingleQueue | Forces using the same queue for uploads and graphics. 0: Uses multiple queues(default) 1: Always uses the gfx queue for submissions |
| r.Vulkan.WaitForIdleOnSubmit | Waits for the GPU to be idle on every submit. Useful for tracking GPU hangs. 0: Do not wait(default) 1: Wait |
| r.WarningOnRedundantTransformUpdate | Produce a warning when UpdatePrimitiveTransform_RenderThread is called redundantly. |
| r.WarnOfBadDrivers | On engine startup we can check the current GPU driver and warn the user about issues and suggest a specific version The test is fast so this should not cost any performance. 0: off 1: a message on startup might appear (default) 2: Simulating the system has a blacklisted NVIDIA driver (UI should appear) 3: Simulating the system has a blacklisted AMD driver (UI should appear) 4: Simulating the system has a not blacklisted AMD driver (no UI should appear) 5: Simulating the system has a Intel driver (no UI should appear) |
| r.WideCustomResolve | Use a wide custom resolve filter when MSAA is enabled0: Disabled [hardware box filter]1: Wide (r=1.25, 12 samples)2: Wider (r=1.4, 16 samples)3: Widest (r=1.5, 20 samples) |
| r.WireframeCullThreshold | Threshold below which objects in ortho wireframe views will be culled. |
| r.XGEController.Enabled | Enables or disables the use of XGE for various build tasks in the engine. 0: Local builds only. 1: Distribute builds using XGE (default). |
| r.XGEController.Timeout | The time, in seconds, to wait after all tasks have been completed before shutting down the controller. (default: 2 seconds). |
| r.XGEShaderCompile | Enables or disables the use of XGE to build shaders. 0: Local builds only. 1: Distribute builds using XGE (default). |
| r.XGEShaderCompile.Mode | Selects which dispatch mode to use. 0: Use legacy xml dispatch mode. (default) 1: Prefer interception mode if available (requires XGE controller support). Falls back to legacy mode otherwise. 2: Force interception mode. Disables XGE shader compiling if XGE controller is not available. |
| r.XGEShaderCompile.Xml.BatchGroupSize | Specifies the number of batches to fill with shaders. Shaders are spread across this number of batches until all the batches are full. This allows the XGE compile to go wider when compiling a small number of shaders. Default = 128 |
| r.XGEShaderCompile.Xml.BatchSize | Specifies the number of shaders to batch together into a single XGE task. Default = 16 |
| r.XGEShaderCompile.Xml.JobTimeout | The number of seconds to wait for additional shader jobs to be submitted before starting a build. Default = 0.5 |