RtxOptions.md

RTX Options

RTX Options are configurable parameters for RTX pipeline components. They can be set via rtx.conf in a following format:

<RTX Option int scalar> = <Integer value>
<RTX Option float scalar> = <Floating point value>
<RTX Option int vector> = <Integer value>, <Integer value>, ...
<RTX Option float vector> = <Floating point value>, <Floating point value>, ...
<RTX Option boolean> = True/False
<RTX Option string> = <String value, no quotes>
<RTX Option hash set/vector> = <Hex string>, <Hex string>, ...

Practical examples of syntax:

rtx.someIntScalar = 38
rtx.someFloatScalar = 29.39
rtx.someIntVector = 1, -2, 3
rtx.someFloatVector = 1.0, -2.0, 3.0
rtx.someBoolean = True
# Note: Leading whitespace in a string is removed, allowing for nicer option formatting like this without messing up the string.
# Additionally, strings should not be surrounded with quotes as these will be treated as part of the string.
rtx.someString = This is a string
# Note: 0x prefix on hash hex values here is optional, similarly these values are case-insensitive. 16 hex characters = 64 bit hash.
rtx.someHashSet = 8DD6F568BD126398, EEF8EFD4B8A1B2A5, ...

RTX Options may be set in multiple places, specifically a hardcoded set in src/util/config/config.cpp which is assigned per-application based on process name, and the two user-configurable files dxvk.conf and rtx.conf. If not set the options will inherit their default values. The full order of precedence for how each set of options overrides the previous is as follows:

1. Default option value (Implicit)
2. dxvk.conf ("User Config")
3. Per-application config.cpp configuration ("Built-in Config")
4. rtx.conf ("RTX User Config")
5. baseGameModPath/rtx.conf (Mod-specific extension of "RTX User Config")

Additionally, upon saving options from the Remix UI options are written only to rtx.conf.

Tables below enumerate all the options and their defaults set by RTX Remix. Note that this information is auto-generated by the RTX Remix application. To re-generate this file, run Remix with DXVK_DOCUMENTATION_WRITE_RTX_OPTIONS_MD=1 defined in the environment variables.

Simple Types

RTX Option	Type	Default Value	Description
rtx.adaptiveAccumulation	bool	True
rtx.adaptiveResolutionDenoising	bool	True
rtx.adaptiveResolutionReservedCPUMemoryGiB	int	2	The amount of CPU memory in gibibytes to reserve away from consideration for adaptive resolution replacement textures. This value should only be changed to reflect the estimated amount of memory Remix itself consumes on the CPU (aside from texture loading) and should not be changed otherwise. Only relevant when force high resolution replacement textures is disabled and adaptive resolution replacement textures is enabled. See asset estimated size parameter for more information.
rtx.adaptiveResolutionReservedGPUMemoryGiB	int	2	The amount of GPU memory in gibibytes to reserve away from consideration for adaptive resolution replacement textures. This value should only be changed to reflect the estimated amount of memory Remix itself consumes on the GPU (aside from texture loading, mostly from rendering-related buffers) and should not be changed otherwise. Only relevant when force high resolution replacement textures is disabled and adaptive resolution replacement textures is enabled. See asset estimated size parameter for more information.
rtx.allowFSE	bool	False	A flag indicating if the application should be able to utilize exclusive full screen mode when set to true, otherwise force it to be disabled when set to false. Exclusive full screen may see performance benefits over other fullscreen modes at the cost of stability in some cases. Do note that on modern Windows full screen optimizations will likely be used regardless which in most cases results in performance similar to exclusive full screen even when it is not in use.
rtx.alwaysWaitForAsyncTextures	bool	False
rtx.antiCulling.antiCullingFovScale	float	1.15	[Experimental] Scalar of the FOV of Anti-Culling Frustum.
rtx.antiCulling.enableAntiCulling	bool	False	[Experimental] Enable Anti-Culling, allow extending life of objects outside the anti-culling frustum.
rtx.antiCulling.numKeepInstances	int	1000	[Experimental] When enable anti-culling, the maximum number of RayTracing instances we hold in the BVH. If the total number of RT instances pass this threshold, instances pass their original life length (it may be extended after anti-culling) will be removed.
rtx.applicationId	int	102100511	Used to uniquely identify the application to DLSS. Generally should not be changed without good reason.
rtx.assetEstimatedSizeGiB	int	2	The estimated size in gibibytes of all of the assets expected to be loaded typically in a standard scene. This value is important to set on more production-ready games as it will allow texture loading to calculate which mip levels to load up to in order to ensure memory usage does not exceed CPU or GPU memory limits. Note that setting this value too high may force textures to load as lower quality than they may be able to if there is enough memory available (as this is just an estimate), so it is better to estimate a lower size than a higher one. Finally, this value is only relevant when force high resolution replacement textures is disabled and adaptive resolution replacement textures is enabled. For more information the mip calculations in the code should be referenced, but generally this value is used in conjunction with the estimated GPU pipeline resource and CPU game data sizes as well as the general CPU/GPU free memory to determine which mip level will fit in the remaining space.
rtx.asyncTextureUploadPreloadMips	int	8
rtx.autoExposure.autoExposureSpeed	float	5	Average exposure changing speed when the image changes.
rtx.autoExposure.centerMeteringSize	float	0.5	The importance of pixels around the screen center.
rtx.autoExposure.enabled	bool	True	Automatically adjusts exposure so that the image won't be too bright or too dark.
rtx.autoExposure.evMaxValue	float	5	Min/Max values tuned by moving from bright/dark locations in game, and adjusting until they look correct.
rtx.autoExposure.evMinValue	float	-2	Min/Max values tuned by moving from bright/dark locations in game, and adjusting until they look correct.
rtx.autoExposure.exposureAverageMode	int	1	Average mode. Valid values: <Mean=0, Median=1>. The mean mode averages exposures across pixels. The median mode is more stable for extreme pixel values.
rtx.autoExposure.exposureCenterMeteringEnabled	bool	False	Gives higher weight to pixels around the screen center.
rtx.autoExposure.exposureWeightCurve0	float	1	Curve control point 0.
rtx.autoExposure.exposureWeightCurve1	float	1	Curve control point 1.
rtx.autoExposure.exposureWeightCurve2	float	1	Curve control point 2.
rtx.autoExposure.exposureWeightCurve3	float	1	Curve control point 3.
rtx.autoExposure.exposureWeightCurve4	float	1	Curve control point 4.
rtx.autoExposure.useExposureCompensation	bool	False	Uses a curve to determine the importance of different exposure levels when calculating average exposure.
rtx.blockInputToGameInUI	bool	True
rtx.bloom.enable	bool	True
rtx.bloom.intensity	float	0.06
rtx.bloom.sigma	float	0.1
rtx.calculateLightIntensityUsingLeastSquares	bool	True	Enable usage of least squares for approximating a light's falloff curve rather than a more basic single point approach. This will generally result in more accurate matching of the original application's custom light attenuation curves, especially with non physically based linear-style attenuation.
rtx.calculateMeshBoundingBox	bool	False	Calculate bounding box for every mesh.
rtx.camera.enableFreeCamera	bool	False	Enable free camera.
rtx.camera.freeCameraPitch	float	0	Free camera's pitch.
rtx.camera.freeCameraPosition	float3	0, 0, 0	Free camera's position.
rtx.camera.freeCameraViewRelative	bool	True	Free camera transform is relative to the view.
rtx.camera.freeCameraYaw	float	0	Free camera's position.
rtx.camera.lockFreeCamera	bool	False	Locks free camera.
rtx.camera.trackCamerasSeenStats	bool	False
rtx.cameraAnimationAmplitude	float	2
rtx.cameraAnimationMode	int	3
rtx.cameraShakePeriod	int	20
rtx.captureDebugImage	bool	False
rtx.captureFramesPerSecond	int	24
rtx.captureMaxFrames	int	1
rtx.captureMeshColorDelta	float	0.3	Inter-frame color min delta warrants new time sample.
rtx.captureMeshNormalDelta	float	0.3	Inter-frame normal min delta warrants new time sample.
rtx.captureMeshPositionDelta	float	0.3	Inter-frame position min delta warrants new time sample.
rtx.captureMeshTexcoordDelta	float	0.3	Inter-frame texcoord min delta warrants new time sample.
rtx.captureNoInstance	bool	False
rtx.compositePrimaryDirectDiffuse	bool	True
rtx.compositePrimaryDirectSpecular	bool	True
rtx.compositePrimaryIndirectDiffuse	bool	True
rtx.compositePrimaryIndirectSpecular	bool	True
rtx.compositeSecondaryCombinedDiffuse	bool	True
rtx.compositeSecondaryCombinedSpecular	bool	True
rtx.debugView.debugViewIdx	int	0
rtx.debugView.displayType	int	0
rtx.debugView.enablePseudoColor	bool	False
rtx.debugView.evMaxValue	int	4
rtx.debugView.evMinValue	int	-4
rtx.debugView.maxValue	float	1
rtx.debugView.minValue	float	0
rtx.decalNormalOffset	float	0.003	Distance along normal to offset between two adjacent decals to prevent coplanar rendering issues such as Z-fighting.
rtx.defaultToAdvancedUI	bool	False
rtx.demodulate.demodulateRoughness	bool	True	Demodulate roughness to improve specular details.
rtx.demodulate.demodulateRoughnessOffset	float	0.1	Strength of roughness demodulation, lower values are stronger.
rtx.demodulate.directLightBoilingThreshold	float	5	Remove direct light sample when its luminance is higher than the average one multiplied by this threshold .
rtx.demodulate.enableDirectLightBoilingFilter	bool	True	Boiling filter removing direct light sample when its luminance is too high.
rtx.denoiseDirectAndIndirectLightingSeparately	bool	True	Denoising quality, high uses separate denoising of direct and indirect lighting for higher quality at the cost of performance.
rtx.denoiser.maxDirectHitTContribution	float	-1
rtx.denoiser.nrd.timeDeltaBetweenFrames	float	-1
rtx.denoiserIndirectMode	int	16
rtx.denoiserMode	int	16
rtx.di.confidenceGradientPower	float	8
rtx.di.confidenceGradientScale	float	6
rtx.di.confidenceHistoryLength	float	8
rtx.di.confidenceHitDistanceSensitivity	float	300
rtx.di.disocclusionFrames	int	8
rtx.di.disocclusionSamples	int	4	The number of spatial reuse samples in disocclusion areas.
rtx.di.enableBestLightSampling	bool	True	Whether to include a single best light from the previous frame's pixel neighborhood into initial sampling.
rtx.di.enableCrossPortalLight	bool	True
rtx.di.enableDenoiserConfidence	bool	True
rtx.di.enableDiscardEnlargedPixels	bool	True
rtx.di.enableDiscardInvisibleSamples	bool	True	Whether to discard reservoirs that are determined to be invisible in final shading.
rtx.di.enableInitialVisibility	bool	True	Whether to trace a visibility ray for the light sample selected in the initial sampling pass.
rtx.di.enableRayTracedBiasCorrection	bool	True	Whether to use ray traced bias correction in the spatial reuse pass.
rtx.di.enableSampleStealing	bool	True	No visibile IQ gains, but exhibits considerable perf drop (8% in integrate pass).
rtx.di.enableSpatialReuse	bool	True	Whether to apply spatial reuse.
rtx.di.enableTemporalBiasCorrection	bool	True
rtx.di.enableTemporalReuse	bool	True	Whether to apply temporal reuse.
rtx.di.gradientFilterPasses	int	4
rtx.di.gradientHitDistanceSensitivity	float	10
rtx.di.initialSampleCount	int	4	The number of lights randomly selected from the global pool to consider when selecting a light with RTXDI.
rtx.di.maxHistoryLength	int	4	Maximum age of reservoirs for temporal reuse.
rtx.di.minimumConfidence	float	0.1
rtx.di.permutationSamplingNthFrame	int	0	Apply permutation sampling when (frameIdx % this == 0), 0 means off.
rtx.di.spatialSamples	int	2	The number of spatial reuse samples in converged areas.
rtx.di.stealBoundaryPixelSamplesWhenOutsideOfScreen	bool	True	Steal screen boundary samples when a hit point is outside the screen.
rtx.dlssEnhancementDirectLightMaxValue	float	10	The maximum strength of direct lighting enhancement.
rtx.dlssEnhancementDirectLightPower	float	0.7	The overall strength of direct lighting enhancement.
rtx.dlssEnhancementIndirectLightMaxValue	float	1.5	The maximum strength of indirect lighting enhancement.
rtx.dlssEnhancementIndirectLightMinRoughness	float	0.3	The reference roughness in indirect lighting enhancement.
rtx.dlssEnhancementIndirectLightPower	float	1	The overall strength of indirect lighting enhancement.
rtx.dlssEnhancementMode	int	1	The enhancement filter type. Valid values: <Normal Difference=1, Laplacian=0>. Normal difference mode provides more normal detail at the cost of some noise. Laplacian mode is less aggressive.
rtx.dlssPreset	int	1	Combined DLSS Preset for quickly controlling Upscaling, Frame Interpolation and Latency Reduction.
rtx.drawCallRange	int2	0, 2147483647
rtx.effectLightIntensity	float	1
rtx.effectLightPlasmaBall	bool	False
rtx.effectLightRadius	float	5
rtx.emissiveBlendOverrideEmissiveIntensity	float	0.2	The emissive intensity to use when the emissive blend override is enabled. Adjust this if particles for example look overly bright globally.
rtx.emissiveIntensity	float	1	A general scale factor on all emissive intensity values globally. Generally per-material emissive intensities should be used, but this option may be useful for debugging without needing to author materials.
rtx.enableAdaptiveResolutionReplacementTextures	bool	True	A flag to enable or disable adaptive resolution replacement textures. When enabled, this mode allows replacement textures to load in only up to an adaptive minimum mip level to cut down on memory usage, but only when force high resolution replacement textures is disabled. This should generally always be enabled to ensure Remix does not starve the system of CPU or GPU memory while loading textures. Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.enableAlphaBlend	bool	True	Enable rendering alpha blended geometry, used for partial opacity and other blending effects on various surfaces in many games.
rtx.enableAlphaTest	bool	True	Enable rendering alpha tested geometry, used for cutout style opacity in some games.
rtx.enableAsyncTextureUpload	bool	True
rtx.enableBillboardOrientationCorrection	bool	True
rtx.enableCulling	bool	True	Enable front/backface culling for opaque objects. Objects with alpha blend or alpha test are not culled.
rtx.enableCullingInSecondaryRays	bool	False	Enable front/backface culling for opaque objects. Objects with alpha blend or alpha test are not culled. Only applies in secondary rays, defaults to off. Generally helps with light bleeding from objects that aren't watertight.
rtx.enableDLSSEnhancement	bool	True	Enhances lighting details when DLSS is on.
rtx.enableDecalMaterialBlending	bool	True	A flag to enable or disable material blending on decals. This should generally always be enabled when decals are in use as this allows decals to be blended down on to the surface they sit slightly above which results in more convincing decals rendering.
rtx.enableDeveloperOptions	bool	False
rtx.enableDirectLighting	bool	True	Enables direct lighting (lighting directly from lights on to a surface) on surfaces when set to true, otherwise disables it.
rtx.enableDirectTranslucentShadows	bool	False	Include OBJECT_MASK_TRANSLUCENT into primary visibility rays.
rtx.enableEmissiveBlendEmissiveOverride	bool	True	Override typical material emissive information on draw calls with any emissive blending modes to emulate their original look more accurately.
rtx.enableFallbackLightShaping	bool	False	Enables light shaping on the fallback light (only used for non-Distant light types).
rtx.enableFallbackLightViewPrimaryAxis	bool	False	Enables usage of the camera's view axis as the primary axis for the fallback light's shaping (only used for non - Distant light types). Typically the shaping primary axis may be specified directly, but if desired it may be set to the camera's view axis for a "flashlight" effect.
rtx.enableFirstBounceLobeProbabilityDithering	bool	True	A flag to enable or disable screen-space probability dithering on the first indirect lobe sampled. Generally sampling a diffuse, specular or other lobe relies on a random number generated against the probability of sampling each lobe, effectively focusing more rays/paths on lobes which matter more. This can cause issues however with denoisers which do not handle sparse stochastic signals (like those from path tracing) well as they may be expecting a more "complete" signal like those used in simpler branching ray tracing setups. To help solve this issue this option uses a temporal screenspace dithering based on the probability rather than a purely random choice to determine which lobe to sample from on the first indirect bounce. This as a result helps ensure there will always be a diffuse or specular sample within the dithering pattern's area and should help the denoising resolve a more stable result.
rtx.enableFog	bool	True
rtx.enableFogColorRemap	bool	False	A flag to enable or disable remapping fixed function fox's color. Only takes effect when fog remapping in general is enabled. Enables or disables remapping functionality relating to the color parameter of fixed function fog with the exception of the multiscattering scale (as this scale can be set to 0 to disable it). This allows dynamic changes to the game's fog color to be reflected somewhat in the volumetrics system. Overrides the specified volumetric transmittance color.
rtx.enableFogMaxDistanceRemap	bool	True	A flag to enable or disable remapping fixed function fox's max distance. Only takes effect when fog remapping in general is enabled. Enables or disables remapping functionality relating to the max distance parameter of fixed function fog. This allows dynamic changes to the game's fog max distance to be reflected somewhat in the volumetrics system. Overrides the specified volumetric transmittance measurement distance.
rtx.enableFogRemap	bool	False	A flag to enable or disable fixed function fog remapping. Only takes effect when volumetrics are enabled. Typically many old games used fixed function fog for various effects and while sometimes this fog can be replaced with proper volumetrics globally, other times require some amount of dynamic behavior controlled by the game. When enabled this option allows for remapping of fixed function fog parameters from the game to volumetric parameters to accomodate this dynamic need.
rtx.enableIndirectTranslucentShadows	bool	False	Include OBJECT_MASK_TRANSLUCENT into secondary visibility rays.
rtx.enableNearPlaneOverride	bool	False	A flag to enable or disable the Camera's near plane override feature. Since the camera is not used directly for ray tracing the near plane the application uses typically does not matter, but for certain matrix-based operations (such as temporal reprojection or voxel grid projection) it is still relevant. The issue arises when geometry is ray traced that is behind where the chosen Camera's near plane is located, typically common on viewmodels especially with how they are ray traced, causing graphical artifacts and other issues. This option helps correct this issue by overriding the near plane value to else (usually smaller) to sit behind the objects in question (such as the view model). As such this option should usually be enabled on games with viewmodels. Do note that when adjusting the near plane the larger the relative magnitude gap between the near and far plane the worse the precision of matrix operations will be, so the near plane should be set as high as possible even when overriding.
rtx.enablePSRR	bool	True	A flag to enable or disable reflection PSR (Primary Surface Replacement). When enabled this feature allows higher quality mirror-like reflections in special cases by replacing the G-Buffer's surface with the reflected surface. Should usually be enabled for the sake of quality as almost all applications will utilize it in the form of glass or mirrors.
rtx.enablePSTR	bool	True	A flag to enable or disable transmission PSR (Primary Surface Replacement). When enabled this feature allows higher quality glass-like refraction in special cases by replacing the G-Buffer's surface with the refracted surface. Should usually be enabled for the sake of quality as almost all applications will utilize it in the form of glass.
rtx.enablePSTROutgoingSplitApproximation	bool	True	Enable transmission PSR on outgoing transmission events such as leaving translucent materials (rather than respecting no-split path PSR rule). Typically this results in better looking glass when enabled (at the cost of accuracy due to ignoring non-TIR inter-reflections within the glass itself).
rtx.enablePSTRSecondaryIncidentSplitApproximation	bool	True	Enable transmission PSR on secondary incident transmission events such as entering a translucent material on an already-transmitted path (rather than respecting no-split path PSR rule). Typically this results in better looking glass when enabled (at the cost accuracy due to ignoring reflections off of glass seen through glass for example).
rtx.enablePortalFadeInEffect	bool	False
rtx.enablePresentThrottle	bool	False	A flag to enable or disable present throttling, when set to true a sleep for a time specified by the throttle delay will be inserted into the DXVK presentation thread. Useful to manually reduce the framerate if the application is running too fast or to reduce GPU power usage during development to keep temperatures down. Should not be enabled in anything other than development situations.
rtx.enablePreviousTLAS	bool	True
rtx.enableRaytracing	bool	True	Globally enables or disables ray tracing. When set to false the original game should render mostly as it would in DXVK typically. Some artifacts may still appear however compared to the original game either due to issues with the underlying DXVK translation or issues in Remix itself.
rtx.enableReplacementAssets	bool	True	Globally enables or disables all enhanced asset replacement (materials, meshes, lights) functionality.
rtx.enableReplacementLights	bool	True	Enables or disables enhanced light replacements. Requires replacement assets in general to be enabled to have any effect.
rtx.enableReplacementMaterials	bool	True	Enables or disables enhanced material replacements. Requires replacement assets in general to be enabled to have any effect.
rtx.enableReplacementMeshes	bool	True	Enables or disables enhanced mesh replacements. Requires replacement assets in general to be enabled to have any effect.
rtx.enableRussianRoulette	bool	True	A flag to enable or disable Russian Roulette, a rendering technique to give paths a chance of terminating randomly with each bounce based on their importance. This is usually useful to have enabled as it will ensure useless paths are terminated earlier while more important paths are allowed to accumulate more bounces. Furthermore this allows for the renderer to remain unbiased whereas a hard clamp on the number of bounces will introduce bias (though this is also done in Remix for the sake of performance). On the other hand, randomly terminating paths too aggressively may leave threads in GPU warps without work which may hurt thread occupancy when not used with a thread-reordering technique like SER.
rtx.enableSecondaryBounces	bool	True	Enables indirect lighting (lighting from diffuse/specular bounces to one or more other surfaces) on surfaces when set to true, otherwise disables it.
rtx.enableSeparateUnorderedApproximations	bool	True	Use a separate loop during resolving for surfaces which can have lighting evaluated in an approximate unordered way on each path segment (such as particles). This improves performance typically in how particles or decals are rendered and should usually always be enabled. Do note however the unordered nature of this resolving method may result in visual artifacts with large numbers of stacked particles due to difficulty in determining the intended order. Additionally, unordered approximations will only be done on the first indirect ray bounce (as particles matter less in higher bounces), and only if enabled by its corresponding setting.
rtx.enableShaderExecutionReorderingInPathtracerGbuffer	bool	False
rtx.enableShaderExecutionReorderingInPathtracerIntegrateIndirect	bool	True
rtx.enableStochasticAlphaBlend	bool	True	Use stochastic alpha blend.
rtx.enableUnorderedEmissiveParticlesInIndirectRays	bool	False	A flag to enable or disable unordered resolve emissive particles specifically in indirect rays. Should be enabled in higher quality rendering modes as emissive particles are fairly important in reflections, but may be disabled to skip such interactions which can improve performance on lower end hardware. Note that rtx.enableUnorderedResolveInIndirectRays must first be enabled for this option to take any effect (as it will control if unordered resolve is used to begin with in indirect rays).
rtx.enableUnorderedResolveInIndirectRays	bool	True	A flag to enable or disable unordered resolve approximations in indirect rays. This allows for the presence of unordered approximations in resolving to be overridden in indirect rays and as such requires separate unordered approximations to be enabled to have any effect. This option should be enabled if objects which can be resolvered in an unordered way in indirect rays are expected for higher quality in reflections, but may come at a performance cost. Note that even with this option enabled, unordered resolve approximations are only done on the first indirect bounce for the sake of performance overall.
rtx.enableVolumetricLighting	bool	False	Enabling volumetric lighting provides higher quality ray traced physical volumetrics, disabling falls back to cheaper depth based fog. Note that disabling this option does not disable the froxel radiance cache as a whole as it is still needed for other non-volumetric lighting approximations.
rtx.enableVolumetricsInPortals	bool	True	Enables using extra frustum-aligned volumes for lighting in portals. Note that enabling this option will require 3x the memory of the typical froxel grid as well as degrade performance in some cases. This option should be enabled always in games using ray portals for proper looking volumetrics through them, but should be disabled on any game not using ray portals. Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.fallbackLightAngle	float	5	The spread angle to use for the fallback light (used only for Distant light types).
rtx.fallbackLightConeAngle	float	25	The cone angle to use for the fallback light shaping (used only for non-Distant light types with shaping enabled).
rtx.fallbackLightConeSoftness	float	0.1	The cone softness to use for the fallback light shaping (used only for non-Distant light types with shaping enabled).
rtx.fallbackLightDirection	float3	-0.2, -1, 0.4	The direction to use for the fallback light (used only for Distant light types)
rtx.fallbackLightFocusExponent	float	2	The focus exponent to use for the fallback light shaping (used only for non-Distant light types with shaping enabled).
rtx.fallbackLightMode	int	1	The mode to determine when to create a fallback light. Never (0) never creates the light, NoLightsPresent (1) creates the fallback light only when no lights are provided to Remix, and Always (2) always creates the fallback light. Primarily a debugging feature, users should create their own lights via the Remix workflow rather than relying on this feature to provide lighting. As such, this option should be set to Never for "production" builds of Remix creations to avoid the fallback light from appearing in games unintentionally in cases where no lights exist (which is the default behavior when set to NoLightsPresent).
rtx.fallbackLightPositionOffset	float3	0, 0, 0	The position offset from the camera origin to use for the fallback light (used only for non-Distant light types).
rtx.fallbackLightPrimaryAxis	float3	0, 0, -1	The primary axis to use for the fallback light shaping (used only for non-Distant light types).
rtx.fallbackLightRadiance	float3	1.6, 1.8, 2	The radiance to use for the fallback light (used across all light types).
rtx.fallbackLightRadius	float	5	The radius to use for the fallback light (used only for Sphere light types).
rtx.fallbackLightType	int	0	The light type to use for the fallback light. Determines which other fallback light options are used.
rtx.fireflyFilteringLuminanceThreshold	float	1000	Maximum luminance threshold for the firefly filtering to clamp to.
rtx.fogColorScale	float	0.25
rtx.fogRemapColorMultiscatteringScale	float	1	A value representing the scale of the fixed function fog's color in the multiscattering approximation. This scaling factor is applied to the fixed function fog's color and becomes a multiscattering approximation in the volumetrics system. Sometimes useful but this multiscattering approximation is very basic (just a simple ambient term for now essentially) and may not look very good depending on various conditions.
rtx.fogRemapMaxDistanceMax	float	4000	A value controlling the "max distance" fixed function fog parameter's maximum remapping bound. Note that fog remapping and fog max distance remapping must be enabled for this setting to have any effect.
rtx.fogRemapMaxDistanceMin	float	100	A value controlling the "max distance" fixed function fog parameter's minimum remapping bound. Note that fog remapping and fog max distance remapping must be enabled for this setting to have any effect.
rtx.fogRemapTransmittanceMeasurementDistanceMax	float	12000	A value representing the transmittance measurement distance's maximum remapping bound. When the fixed function fog's "max distance" parameter is at or above its specified maximum the volumetric system's transmittance measurement distance will be set to this value and interpolated upwards. Note that fog remapping and fog max distance remapping must be enabled for this setting to have any effect.
rtx.fogRemapTransmittanceMeasurementDistanceMin	float	2000	A value representing the transmittance measurement distance's minimum remapping bound. When the fixed function fog's "max distance" parameter is at or below its specified minimum the volumetric system's transmittance measurement distance will be set to this value and interpolated upwards. Note that fog remapping and fog max distance remapping must be enabled for this setting to have any effect.
rtx.forceCameraJitter	bool	False
rtx.forceCutoutAlpha	float	0.5	When an object is added to the cutout textures list it will have a cutout alpha mode forced on it, using this value for the alpha test. This is meant to improve the look of some legacy mode materials using low-resolution textures and alpha blending instead of alpha cutout as this can cause blurry halos around edges due to the difficulty of handling this sort of blending in Remix. Such objects are generally better handled with actual replacement assets using fully opaque geometry replacements or alpha cutout with higher resolution textures, so this should only be relied on until proper replacements can be authored.
rtx.forceHighResolutionReplacementTextures	bool	False	A flag to enable or disable forcing high resolution replacement textures. When enabled this mode overrides all other methods of mip calculation (adaptive resolution and the minimum mipmap level) and forces it to be 0 to always load in the highest quality of textures. This generally should not be used other than for various forms of debugging or visual comparisons as this mode will ignore any constraints on CPU or GPU memory which may starve the system or Remix of memory. Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.forceVsyncOff	bool	False	Forces V-Sync to off by setting the present interval to 0 and ignores requests from the application to change the present interval.
rtx.freeCameraSpeed	float	200	Free camera speed [GameUnits/s].
rtx.froxelDepthSliceDistributionExponent	float	2	The exponent to use on depth values to nonlinearly distribute froxels away from the camera. Higher values bias more froxels closer to the camera with 1 being linear.
rtx.froxelDepthSlices	int	48	The z dimension of the froxel grid. Must be constant after initialization.
rtx.froxelFilterGaussianSigma	float	1.2	The sigma value of the gaussian function used to filter volumetric radiance values. Larger values cause a smoother filter to be used.
rtx.froxelFireflyFilteringLuminanceThreshold	float	1000	Sets the maximum luminance threshold for the volumetric firefly filtering to clamp to.
rtx.froxelGridResolutionScale	int	16	The scale factor to divide the x and y render resolution by to determine the x and y dimensions of the froxel grid.
rtx.froxelKernelRadiusStabilityHistoryPower	float	2	The power to apply to the kernel radius stability history weight.
rtx.froxelMaxDistance	float	2000	The maximum distance in world units to allocate the froxel grid out to. Should be less than the distance between the camera's near and far plane, as the froxel grid will clip to the far plane otherwise.
rtx.froxelMaxKernelRadius	int	4	The maximum filtering kernel radius to use when stability is at its minimum, should be at least 1 and greater than or equal to the minimum.
rtx.froxelMaxKernelRadiusStabilityHistory	int	64	The maximum history to consider history at maximum stability for filtering.
rtx.froxelMaxReservoirSamples	int	6	The maximum number of Reservoir samples to do for each froxel cell when stability is at its minimum, should be at least 1 and greater than or equal to the minimum.
rtx.froxelMaxReservoirSamplesStabilityHistory	int	64	The maximum history to consider history at maximum stability for Reservoir samples.
rtx.froxelMinKernelRadius	int	2	The minimum filtering kernel radius to use when stability is at its maximum, should be at least 1.
rtx.froxelMinKernelRadiusStabilityHistory	int	1	The minimum history to consider history at minimum stability for filtering.
rtx.froxelMinReservoirSamples	int	1	The minimum number of Reservoir samples to do for each froxel cell when stability is at its maximum, should be at least 1.
rtx.froxelMinReservoirSamplesStabilityHistory	int	1	The minimum history to consider history at minimum stability for Reservoir samples.
rtx.froxelReservoirSamplesStabilityHistoryPower	float	2	The power to apply to the Reservoir sample stability history weight.
rtx.fusedWorldViewMode	int	0	Set if game uses a fused World-View transform matrix.
rtx.graphicsPreset	int	5	Overall rendering preset, higher presets result in higher image quality, lower presets result in better performance.
rtx.hideSplashMessage	bool	False	A flag to disable the splash message indicating how to use Remix from appearing when the application starts. When set to true this message will be hidden, otherwise it will be displayed on every launch.
rtx.highlightedTexture	int	0	Hash of a texture that should be highlighted.
rtx.ignoreGameDirectionalLights	bool	False	Ignores any directional lights coming from the original game (lights added via toolkit still work).
rtx.ignoreGamePointLights	bool	False	Ignores any point lights coming from the original game (lights added via toolkit still work).
rtx.ignoreGameSpotLights	bool	False	Ignores any spot lights coming from the original game (lights added via toolkit still work).
rtx.ignoreStencilVolumeHeuristics	bool	True	Tries to detect stencil volumes and ignore those when pathtracing. Stencil buffer was used for a variety of effects in the D3D7-9 era, mostly for geometry based lights and shadows - things we don't need when pathtracing.
rtx.indirectRaySpreadAngleFactor	float	0.05	A tuning factor applied to the spread angle calculated from the sampled lobe solid angle PDF. Should be 0-1. This scaled spread angle is used to widen a ray's cone angle after indirect lighting BRDF samples to essentially prefilter the effects of the BRDF lobe's spread which potentially may reduce noise from indirect rays (e.g. reflections). Prefiltering will overblur detail however compared to the ground truth of casting multiple samples especially given this calculated spread angle is a basic approximation and ray cones to begin with are a simple approximation for ray pixel footprint. As such rather than using the spread angle fully this spread angle factor allows it to be scaled down to something more narrow so that overblurring can be minimized. Similarly, setting this factor to 0 disables this cone angle widening feature.
rtx.initializer.asyncAssetLoading	bool	True
rtx.initializer.asyncShaderFinalizing	bool	True
rtx.initializer.asyncShaderPrewarming	bool	True
rtx.instanceOverrideInstanceIdx	int	-1
rtx.instanceOverrideInstanceIdxRange	int	15
rtx.instanceOverrideSelectedInstancePrintMaterialHash	bool	False
rtx.instanceOverrideWorldOffset	float3	0, 0, 0
rtx.io.enabled	bool	False
rtx.io.memoryBudgetMB	int	256
rtx.io.useAsyncQueue	bool	True
rtx.isLHS	bool	False
rtx.isReflexSupported	bool	True
rtx.isShaderExecutionReorderingSupported	bool	False
rtx.keepTexturesForTagging	bool	False	A flag to keep all textures in video memory, which can drastically increase VRAM consumption. Intended to assist with tagging textures that are only used for a short period of time (such as loading screens). Use only when necessary!
rtx.legacyMaterial.albedoConstant	float3	1, 1, 1	The default albedo constant to use for non-replaced "legacy" materials. Should be a color in sRGB colorspace with gamma encoding.
rtx.legacyMaterial.alphaIsThinFilmThickness	bool	False	A flag to determine if the alpha channel from the albedo source should be treated as thin film thickness on non-replaced "legacy" materials.
rtx.legacyMaterial.anisotropy	float	0	The default roughness anisotropy to use for non-replaced "legacy" materials. Should be in the range -1 to 1, where 0 is isotropic.
rtx.legacyMaterial.emissiveColorConstant	float3	0, 0, 0	The default emissive color constant to use for non-replaced "legacy" materials. Should be a color in sRGB colorspace with gamma encoding.
rtx.legacyMaterial.emissiveIntensity	float	0	The default emissive intensity to use for non-replaced "legacy" materials.
rtx.legacyMaterial.enableEmissive	bool	False	A flag to determine if emission should be used on non-replaced "legacy" materials.
rtx.legacyMaterial.enableThinFilm	bool	False	A flag to determine if a thin-film layer should be used on non-replaced "legacy" materials.
rtx.legacyMaterial.metallicConstant	float	0.1	The default metallic constant to use for non-replaced "legacy" materials. Should be in the range 0 to 1.
rtx.legacyMaterial.opacityConstant	float	1	The default opacity constant to use for non-replaced "legacy" materials. Should be in the range 0 to 1.
rtx.legacyMaterial.roughnessConstant	float	0.7	The default perceptual roughness constant to use for non-replaced "legacy" materials. Should be in the range 0 to 1.
rtx.legacyMaterial.thinFilmThicknessConstant	float	200	The thickness (in nanometers) of the thin-film layer assuming it is enabled on non-replaced "legacy" materials. Should be any value larger than 0, typically within the wavelength of light, but must be less than or equal to OPAQUE_SURFACE_MATERIAL_THIN_FILM_MAX_THICKNESS ((1500.0f) nm).
rtx.legacyMaterial.useAlbedoTextureIfPresent	bool	True	A flag to determine if an "albedo" texture (a qualifying color texture) from the original application should be used if present on non-replaced "legacy" materials.
rtx.lightConversionDistantLightFixedAngle	float	0.0349	The angular size in radiance of the distant light source for legacy lights converted to distant lights. Set to ~2 degrees in radians by default.
rtx.lightConversionDistantLightFixedIntensity	float	1	The fixed intensity (in W/sr) to use for legacy lights converted to distant lights (currently directional lights will convert to distant lights).
rtx.lightConversionEqualityDirectionThreshold	float	0.99	The lower cosine angle threshold between two directions used to determine if two directional lights as the same light when uniquely identifying legacy lights for conversion.
rtx.lightConversionEqualityDistanceThreshold	float	0.05	The upper distance threshold between two positions used to determine if two positional lights as the same light when uniquely identifying legacy lights for conversion.
rtx.lightConversionSphereLightFixedRadius	float	4	The fixed radius in world units to use for legacy lights converted to sphere lights (currently point and spot lights will convert to sphere lights). Use caution with large light radii as many legacy lights will be placed close to geometry and intersect it, causing suboptimal light sampling performance or other visual artifacts (lights clipping through walls, etc).
rtx.localtonemap.boostLocalContrast	bool	False	Boosts contrast on local features.
rtx.localtonemap.displayMip	int	0	Bottom mip level of tone map pyramid.
rtx.localtonemap.exposure	float	0.75	Exposure factor applied on average exposure.
rtx.localtonemap.exposurePreferenceOffset	float	0	Offset to reference luminance when calculating the weights a pixel belongs to shadow/normal/highlight areas.
rtx.localtonemap.exposurePreferenceSigma	float	4	Transition sharpness between different areas of exposure. Smaller values result in sharper transitions.
rtx.localtonemap.finalizeWithACES	bool	True	Applies ACES tone mapping on final result.
rtx.localtonemap.highlights	float	4	Highlight area strength. Higher values cause darker highlight.
rtx.localtonemap.mip	int	3	Top mip level of tone map pyramid.
rtx.localtonemap.shadows	float	2	Shadow area strength. Higher values cause brighter shadows.
rtx.localtonemap.useGaussian	bool	True	Uses gaussian kernel to generate tone map pyramid.
rtx.logLegacyHashReplacementMatches	bool	False
rtx.maxAccumulationFrames	int	254	The number of frames to accumulate volume lighting samples over, maximum of 254. Large values result in greater image stability at the cost of potentially more temporal lag.Should generally be set to as large a value as is viable as the froxel radiance cache is assumed to be fairly noise-free and stable which temporal accumulation helps with.
rtx.maxAnisotropySamples	float	8	The maximum number of samples to use when anisotropic filtering is enabled. The actual max anisotropy used will be the minimum between this value and the hardware's maximum. Higher values increase quality but will likely reduce performance.
rtx.maxFogDistance	float	65504
rtx.maxPrimsInMergedBLAS	int	50000
rtx.minOpaqueDiffuseLobeSamplingProbability	float	0.25	The minimum allowed non-zero value for opaque diffuse probability weights.
rtx.minOpaqueOpacityTransmissionLobeSamplingProbability	float	0.25	The minimum allowed non-zero value for opaque opacity probability weights.
rtx.minOpaqueSpecularLobeSamplingProbability	float	0.25	The minimum allowed non-zero value for opaque specular probability weights.
rtx.minPrimsInStaticBLAS	int	1000
rtx.minReplacementTextureMipMapLevel	int	0	A parameter controlling the minimum replacement texture mipmap level to use, higher values will lower texture quality, 0 for default behavior of effectively not enforcing a minimum. This minimum will always be considered as long as force high resolution replacement textures is not enabled, meaning that with or without adaptive resolution replacement textures enabled this setting will always enforce a minimum mipmap restriction. Generally this should be changed to reduce the texture quality globally if desired to reduce CPU and GPU memory usage and typically should be controlled by some sort of texture quality setting. Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.minTranslucentSpecularLobeSamplingProbability	float	0.3	The minimum allowed non-zero value for translucent specular probability weights.
rtx.minTranslucentTransmissionLobeSamplingProbability	float	0.25	The minimum allowed non-zero value for translucent transmission probability weights.
rtx.nativeMipBias	float	0	Specifies a mipmapping level bias to add to all material texture filtering. Stacks with the upscaling mip bias. Mipmaps are determined based on how far away a texture is, using this can bias the desired level in a lower quality direction (positive bias), or a higher quality direction with potentially more aliasing (negative bias). Note that mipmaps are also important for good spatial caching of textures, so too far negative of a mip bias may start to significantly affect performance, therefore changing this value is not recommended
rtx.nearPlaneOverride	float	0.1	The near plane value to use for the Camera when the near plane override is enabled. Only takes effect when rtx.enableNearPlaneOverride is enabled, see that option for more information about why this is useful.
rtx.nisPreset	int	1	Adjusts NIS scaling factor, trades quality for performance.
rtx.noiseClampHigh	float	2
rtx.noiseClampLow	float	0.5
rtx.noiseMixRatio	float	0.2
rtx.noiseNormalPower	float	0.5
rtx.numFramesToKeepBLAS	int	4
rtx.numFramesToKeepGeometryData	int	5
rtx.numFramesToKeepInstances	int	1
rtx.numFramesToKeepLights	int	100
rtx.numFramesToKeepMaterialTextures	int	30
rtx.opacityMicromap.conservativeEstimationMaxTexelTapsPerMicroTriangle	int	64	Set to 64 as a safer cap. 512 has been found to cause a timeout.
rtx.opacityMicromap.enable	bool	True
rtx.opacityMicromap.enableParticles	bool	True
rtx.opacityMicromap.enableResetEveryFrame	bool	False
rtx.opacityMicromap.maxBudgetSizeMB	int	1536
rtx.opacityMicromap.maxOmmBuildRequests	int	5000
rtx.opacityMicromap.maxVidmemSizePercentage	float	0.15
rtx.opacityMicromap.minBudgetSizeMB	int	512
rtx.opacityMicromap.minFreeVidmemMBToNotAllocate	int	2560
rtx.opacityMicromap.numFramesAtStartToBuildWithHighWorkload	int	0
rtx.opacityMicromap.ommBuildRequest_minInstanceFrameAge	int	1
rtx.opacityMicromap.ommBuildRequest_minNumFramesRequested	int	5
rtx.opacityMicromap.ommBuildRequest_minNumRequests	int	10
rtx.opacityMicromap.subdivisionLevel	int	8
rtx.opacityMicromap.workloadHighWorkloadMultiplier	int	20
rtx.opaqueDiffuseLobeSamplingProbabilityZeroThreshold	float	0.01	The threshold for which to zero opaque diffuse probability weight values.
rtx.opaqueMaterial.albedoBias	float	0	A bias factor to add to all albedo values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.albedoScale	float	1	A scale factor to apply to all albedo values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.enableThinFilmOverride	bool	False	A flag to force the thin-film layer on the opaque material to be enabled. Should only be used for debugging or development.
rtx.opaqueMaterial.layeredWaterNormalEnable	bool	True	A flag indicating if layered water normal should be enabled or disabled. Note that objects must be properly classified as animated water to be rendered with this mode.
rtx.opaqueMaterial.layeredWaterNormalLodBias	float	5	The LoD bias to use when sampling from the normal map on layered water for the second layer of detail. This value typically should be greater than 0 to allow for a more blurry mip to be selected as this allows for a low frequency variation of normals to be applied to the higher frequency variation from the typical normal map. Only takes effect when layered water normals are enabled (and an object is properly classified as animated water).
rtx.opaqueMaterial.layeredWaterNormalMotion	float2	-0.25, -0.3	A vector describing the motion in the U and V axes across a texture to apply for layered water. Only takes effect when layered water normals are enabled (and an object is properly classified as animated water).
rtx.opaqueMaterial.layeredWaterNormalMotionScale	float	9	A scale factor applied to the layered water normal motion vector. Only takes effect when layered water normals are enabled (and an object is properly classified as animated water).
rtx.opaqueMaterial.metallicBias	float	0	A bias factor to add to all metallic values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.metallicScale	float	1	A scale factor to apply to all metallic values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.normalIntensity	float	1	An arbitrary strength scale factor to apply when decoding normals in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.roughnessBias	float	0	A bias factor to add to all roughness values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.roughnessScale	float	1	A scale factor to apply to all roughness values in the opaque material. Should only be used for debugging or development.
rtx.opaqueMaterial.thinFilmThicknessOverride	float	0	The thin-film layer's thickness in nanometers for the opaque material when the thin-film override is enabled. Should be any value larger than 0, typically within the wavelength of light, but must be less than or equal to OPAQUE_SURFACE_MATERIAL_THIN_FILM_MAX_THICKNESS ((1500.0f) nm). Should only be used for debugging or development.
rtx.opaqueOpacityTransmissionLobeSamplingProbabilityZeroThreshold	float	0.01	The threshold for which to zero opaque opacity probability weight values.
rtx.opaqueSpecularLobeSamplingProbabilityZeroThreshold	float	0.01	The threshold for which to zero opaque specular probability weight values.
rtx.particleSoftnessFactor	float	0.05	Multiplier for the view distance that is used to calculate the particle blending range.
rtx.pathMaxBounces	int	4	The maximum number of indirect bounces the path will be allowed to complete. Must be < 16. Higher values result in better indirect lighting quality due to biasing the signal less, lower values result in better performance. Very high values are not recommended however as while long paths may be technically needed for unbiased rendering, in practice the contributions from higher bounces have diminishing returns.
rtx.pathMinBounces	int	1	The minimum number of indirect bounces the path must complete before Russian Roulette can be used. Must be < 16. This value is recommended to stay fairly low (1 for example) as forcing longer paths when they carry little contribution quickly becomes detrimental to performance.
rtx.pipeline.useDeferredOperations	bool	True
rtx.pixelHighlightReuseStrength	float	0.5	The specular portion when we reuse last frame's pixel value.
rtx.playerModel.backwardOffset	float	18
rtx.playerModel.enableInPrimarySpace	bool	False
rtx.playerModel.enablePrimaryShadows	bool	True
rtx.playerModel.enableVirtualInstances	bool	True
rtx.playerModel.eyeHeight	float	64
rtx.playerModel.horizontalDetectionDistance	float	34
rtx.playerModel.intersectionCapsuleHeight	float	68
rtx.playerModel.intersectionCapsuleRadius	float	24
rtx.playerModel.verticalDetectionDistance	float	64
rtx.postFilterThreshold	float	3	Clamps a pixel when its luminance exceeds x times of the average.
rtx.postfx.blurDiameterFraction	float	0.02	The diameter of the circle that motion blur samplings occur. Motion vectors beyond this circle will be clamped.
rtx.postfx.chromaticAberrationAmount	float	0.02	The strength of chromatic aberration.
rtx.postfx.chromaticCenterAttenuationAmount	float	0.975	Control the amount of chromatic aberration effect that attunuated when close to the center of screen.
rtx.postfx.enable	bool	True	Enables post-processing effects.
rtx.postfx.enableChromaticAberration	bool	True	Enables chromatic aberration post-processing effect.
rtx.postfx.enableMotionBlur	bool	True	Enables motion blur post-processing effect.
rtx.postfx.enableMotionBlurEmissive	bool	True	Enable Motion Blur for Emissive surfaces. Disable this when the motion blur on emissive surfaces cause severe artifacts.
rtx.postfx.enableMotionBlurNoiseSample	bool	True	Enable random distance sampling for every step along the motion vector. The random pattern is generated with interleaved gradient noise.
rtx.postfx.enableVignette	bool	True	Enables vignette post-processing effect.
rtx.postfx.exposureFraction	float	0.4	Simulate the camera exposure, the longer exposure will cause stronger motion blur.
rtx.postfx.motionBlurDynamicDeduction	float	0.075	The deduction of motion blur for dynamic objects.
rtx.postfx.motionBlurJitterStrength	float	0.6	The jitter strength of every sample along the motion vector.
rtx.postfx.motionBlurMinimumVelocityThresholdInPixel	float	1	The minimum motion vector distance that enable the motion blur. The unit is pixel size.
rtx.postfx.motionBlurSampleCount	int	4	The number of samples along the motion vector. More samples could help to reduce motion blur noise.
rtx.postfx.vignetteIntensity	float	0.8	The darkness of vignette effect.
rtx.postfx.vignetteRadius	float	0.8	The radius that vignette effect starts. The unit is normalized screen space, 0 represents the center, 1 means the edge of the short edge of the rendering window. So, this setting can larger than 1 until reach to the long edge of the rendering window.
rtx.postfx.vignetteSoftness	float	0.2	The gradient that the color drop to black from the vignetteRadius to the edge of rendering window.
rtx.presentThrottleDelay	int	16	A time in milliseconds that the DXVK presentation thread should sleep for. Requires present throttling to be enabled to take effect. Note that the application may sleep for longer than the specified time as is expected with sleep functions in general.
rtx.primaryRayMaxInteractions	int	32	The maximum number of resolver interactions to use for primary (initial G-Buffer) rays. This affects how many Decals, Ray Portals and potentially particles (if unordered approximations are not enabled) may be interacted with along a ray at the cost of performance for higher amounts of interactions.
rtx.psrRayMaxInteractions	int	32	The maximum number of resolver interactions to use for PSR (primary surface replacement G-Buffer) rays. This affects how many Decals, Ray Portals and potentially particles (if unordered approximations are not enabled) may be interacted with along a ray at the cost of performance for higher amounts of interactions.
rtx.psrrMaxBounces	int	10	The maximum number of Reflection PSR bounces to traverse. Must be 15 or less due to payload encoding. Should be set higher when many mirror-like reflection bounces may be needed, though more bounces may come at a higher performance cost.
rtx.psrrNormalDetailThreshold	float	0	A threshold value to indicate that the denoiser's alternate disocclusion threshold should be used when normal map "detail" on a reflection PSR surface exceeds a desired amount. Normal detail is defined as 1-dot(tangent_normal, vec3(0, 0, 1)), or in other words it is 0 when no normal mapping is used, and 1 when the normal mapped normal is perpendicular to the underlying normal. This is typically used to reduce flickering artifacts resulting from reflection on surfaces like glass leveraging normal maps as often the denoiser is too aggressive with disocclusion checks frame to frame when DLSS or other camera jittering is in use.
rtx.pstrMaxBounces	int	10	The maximum number of Transmission PSR bounces to traverse. Must be 15 or less due to payload encoding. Should be set higher when refraction through many layers of glass may be needed, though more bounces may come at a higher performance cost.
rtx.pstrNormalDetailThreshold	float	0	A threshold value to indicate that the denoiser's alternate disocclusion threshold should be used when normal map "detail" on a transmission PSR surface exceeds a desired amount. Normal detail is defined as 1-dot(tangent_normal, vec3(0, 0, 1)), or in other words it is 0 when no normal mapping is used, and 1 when the normal mapped normal is perpendicular to the underlying normal. This is typically used to reduce flickering artifacts resulting from refraction on surfaces like glass leveraging normal maps as often the denoiser is too aggressive with disocclusion checks frame to frame when DLSS or other camera jittering is in use.
rtx.qualityDLSS	int	4	Adjusts internal DLSS scaling factor, trades quality for performance.
rtx.rayPortalCameraHistoryCorrection	bool	False	A flag to control if history correction on ray portal camera teleportation events is enabled or disabled. This allows for the previous camera matrix to be set to a virtual matrix to correct the large discontunity in position and view direction which happens when a camera teleports from moving through a ray portal (in games like Portal). As such this option should always be enabled in games utilizing ray portals the camera can pass through as it should fix artifacts from incorrectly calculated motion vectors or other deltas that rely on the current and previous camera matrix.
rtx.rayPortalCameraInBetweenPortalsCorrection	bool	False	A flag to contol correction when the camera is "in-between" a pair of ray portals. This is mostly relevant in applications which allow the camera to move through a ray portal (games like Portal) as often the ray portals are placed slightly off of a surface, allowing the camera to sometimes end up in this tiny gap for a frame. To correct this artifact (as it can mess up denoising and other temporal surface consistency checks due to the sudden frame of geometry in front of the camera) this option pushes the camera slightly backwards if this occurs when entering a ray portal. Similar to ray portal camera history correction this option should always be enabled in games utilizing ray portals the camera can pass through.
rtx.rayPortalCameraInBetweenPortalsCorrectionThreshold	float	0.1	The threshold to use for camera "in-between" ray portal detection in meters. When the camera is less than this distance behind the surface of a ray portal it will be pushed backwards to stay behind the ray portal. This value should stay small but be large enough to cover the gap between ray portals and the geometry behind them (if such a gap exists in the underlying application). Additionally, this setting must be set at startup and changing it will not take effect at runtime.
rtx.rayPortalEnabled	bool	False
rtx.rayPortalModelHeightAxis	float3	0, 1, 0	The axis in object space to map the ray portal geometry's height axis to. Currently unused (as PCA is not implemented).
rtx.rayPortalModelNormalAxis	float3	0, 0, 1	The axis in object space to map the ray portal geometry's normal axis to. Currently unused (as PCA is not implemented).
rtx.rayPortalModelWidthAxis	float3	1, 0, 0	The axis in object space to map the ray portal geometry's width axis to. Currently unused (as PCA is not implemented).
rtx.rayPortalSamplingWeightMaxDistance	float	1000	The maximum distance from a portal which the interpolation of the probability of light sampling through portals will end (and is at its minimum value such that no portal light sampling will happen beyond this point). Currently unimplemented, kept here for future use.
rtx.rayPortalSamplingWeightMinDistance	float	10	The minimum distance from a portal which the interpolation of the probability of light sampling through portals will begin (and is at its maximum value). Currently unimplemented, kept here for future use.
rtx.raytraceModePreset	int	1
rtx.recompileShadersOnLaunch	bool	False	When set to true runtime shader recompilation will execute on the first frame after launch.
rtx.reflexMode	int	1	Reflex mode selection, enabling it helps minimize input latency, boost mode may further reduce latency by boosting GPU clocks in CPU-bound cases.
rtx.renderPassGBufferRaytraceMode	int	2	The ray tracing mode to use for the G-Buffer pass which resolves the initial primary and secondary surfaces to apply lighting to.
rtx.renderPassIntegrateDirectRaytraceMode	int	0	The ray tracing mode to use for the Direct Lighting pass which applies lighting to the primary/secondary surfaces.
rtx.renderPassIntegrateIndirectRaytraceMode	int	2	The ray tracing mode to use for the Indirect Lighting pass which applies lighting to the primary/secondary surfaces.
rtx.replaceDirectSpecularHitTWithIndirectSpecularHitT	bool	True
rtx.resetBufferCacheOnEveryFrame	bool	True
rtx.resetDenoiserHistoryOnSettingsChange	bool	False
rtx.resolutionScale	float	0.75
rtx.resolveOpaquenessThreshold	float	0.996078	A threshold for which any opacity value above is considered totally opaque.
rtx.resolvePreCombinedMatrices	bool	True
rtx.resolveTransparencyThreshold	float	0.00392157	A threshold for which any opacity value below is considered totally transparent and may be safely skipped without as significant of a performance cost.
rtx.restirGI.biasCorrectionMode	int	4	Bias correction mode to combine central with its neighbors in spatial reuse.
rtx.restirGI.boilingFilterMaxThreshold	float	20	Boiling filter threshold when surface normal is parallel to view direction.
rtx.restirGI.boilingFilterMinThreshold	float	10	Boiling filter threshold when surface normal is perpendicular to view direction.
rtx.restirGI.boilingFilterRemoveReservoirThreshold	float	62	Removes a sample when a sample's weight exceeds this threshold.
rtx.restirGI.fireflyThreshold	float	50	Clamps specular input to suppress boiling.
rtx.restirGI.misMode	int	2	MIS mode to mix specular output with input.
rtx.restirGI.misRoughness	float	0.3	Reference roughness when roughness MIS is used. Higher values give ReSTIR inputs higher weight.
rtx.restirGI.pairwiseMISCentralWeight	float	0.1	The importance of central sample in pairwise bias correction modes.
rtx.restirGI.parallaxAmount	float	0.02	Parallax strength when parallax MIS is used. Higher values give ReSTIR inputs higher weight.
rtx.restirGI.permutationSamplingSize	int	2	Permutation sampling strength.
rtx.restirGI.reflectionMinParallax	float	3	When the parallax between normal and reflection reprojection is greater than this threshold, randomly choose one reprojected position and reuse the sample on it. Otherwise, get a sample between the two positions.
rtx.restirGI.roughnessClamp	float	0.01	Clamps minimum roughness a sample's importance is evaluated.
rtx.restirGI.stealBoundaryPixelSamplesWhenOutsideOfScreen	bool	True	Steals ReSTIR GI samples even a hit point is outside the screen. This will further improve highly specular samples at the cost of some bias.
rtx.restirGI.temporalAdaptiveHistoryLengthMs	int	500	Temporal history time length, when adaptive temporal history is enabled.
rtx.restirGI.temporalFixedHistoryLength	int	30	Fixed temporal history length, when adaptive temporal history is disabled.
rtx.restirGI.useAdaptiveTemporalHistory	bool	True	Adjust temporal history length based on frame rate.
rtx.restirGI.useBoilingFilter	bool	True	Enables boiling filter to suppress boiling artifacts.
rtx.restirGI.useDemodulatedTargetFunction	bool	False	Demodulates target function. This will improve the result in non-pairwise modes.
rtx.restirGI.useDiscardEnlargedPixels	bool	True	Discards enlarged samples when the camera is moving towards an object.
rtx.restirGI.useFinalVisibility	bool	True	Tests visiblity in output.
rtx.restirGI.usePermutationSampling	bool	True	Uses permutation sample to perturb samples. This will improve results in DLSS.
rtx.restirGI.useReflectionReprojection	bool	True	Uses reflection reprojection for reflective objects to achieve stable result when the camera is moving.
rtx.restirGI.useSampleStealing	int	2	Steals ReSTIR GI samples in path tracer. This will improve highly specular results.
rtx.restirGI.useSpatialReuse	bool	True	Enables spatial reuse.
rtx.restirGI.useTemporalBiasCorrection	bool	True	Corrects bias caused by temporal reprojection.
rtx.restirGI.useTemporalJacobian	bool	True	Calculates Jacobian determinant in temporal reprojection.
rtx.restirGI.useTemporalReuse	bool	True	Enables temporal reuse.
rtx.restirGI.useVirtualSample	bool	True	Uses virtual position for samples from highly specular surfaces.
rtx.restirGI.virtualSampleLuminanceThreshold	float	2	The last path vertex with luminance greater than 2 times of the previous accumulated radiance will get virtualized. Higher values tend to keep the first path vertex with non-zero contribution.
rtx.restirGI.virtualSampleRoughnessThreshold	float	0.2	Surface with roughness under this threshold is considered to be highly specular, i.e. a "mirror".
rtx.restirGI.virtualSampleSpecularThreshold	float	0.5	If a highly specular path vertex's direct specular light portion is higher than this. Its distance to the light source will get accumulated.
rtx.risLightSampleCount	int	7	The number of lights randomly selected from the global pool to consider when selecting a light with RIS. Higher values generally increases the quality of RIS light sampling, but also has diminishing returns and higher performance cost past a point. Note that RIS is only used when RTXDI is disabled for direct lighting, or for light sampling in indirect rays, so the impact of this effect will vary.
rtx.rngSeedWithFrameIndex	bool	True	Indicates that pseudo-random number generator should be seeded with the frame number of the application every frame, otherwise seed with 0. This should generally always be enabled as without the frame index each frame will typically be identical in the random values that are produced which will result in incorrect rendering. Only meant as a debugging tool.
rtx.russianRoulette1stBounceMaxContinueProbability	float	1	The maximum probability of continuing a path when Russian Roulette is being used on the first bounce. This is similar to the usual max continuation probability for Russian Roulette, but specifically only for the first bounce.
rtx.russianRoulette1stBounceMinContinueProbability	float	0.6	The minimum probability of continuing a path when Russian Roulette is being used on the first bounce. This ensures that on the first bounce rays are not terminated too aggressively as it may be useful for some denoisers to have a contribution even if it is a relatively unimportant one rather than a missing indirect sample.
rtx.russianRouletteMaxContinueProbability	float	0.9	The maximum probability of continuing a path when Russian Roulette is being used. This ensures all rays have a small probability of terminating each bounce, mostly to prevent infinite paths in perfectly reflective mirror rooms (though the maximum path bounce count will also ensure this).
rtx.sceneScale	float	1	Defines the ratio of rendering unit (1cm) to game unit, i.e. sceneScale = 1cm / GameUnit.
rtx.secondaryRayMaxInteractions	int	8	The maximum number of resolver interactions to use for secondary (indirect) rays. This affects how many Decals, Ray Portals and potentially particles (if unordered approximations are not enabled) may be interacted with along a ray at the cost of performance for higher amounts of interactions. This value is recommended to be set lower than the primary/PSR max ray interactions as secondary ray interactions are less visually relevant relative to the performance cost of resolving them.
rtx.serializeChangedOptionOnly	bool	True
rtx.shakeCamera	bool	False
rtx.showUI	int	0	0 = Don't Show, 1 = Show Simple, 2 = Show Advanced.
rtx.showUICursor	bool	False
rtx.skipDrawCallsPostRTXInjection	bool	False	Ignores all draw calls recorded after RTX Injection, the location of which varies but is currently based on when tagged UI textures begin to draw.
rtx.skipObjectsWithUnknownCamera	bool	False
rtx.skyBrightness	float	1
rtx.skyDrawcallIdThreshold	int	0	It's common in games to render the skybox first, and so, this value provides a simple mechanism to identify those early draw calls that are untextured (textured draw calls can still use the Sky Textures functionality.
rtx.skyForceHDR	bool	False	By default sky will be rasterized in the color format used by the game. Set the checkbox to force sky to be rasterized in HDR intermediate format. This may be important when sky textures replaced with HDR textures.
rtx.skyProbeSide	int	1024
rtx.skyUiDrawcallCount	int	0
rtx.stochasticAlphaBlendDepthDifference	float	0.1	Max depth difference for a valid neighbor.
rtx.stochasticAlphaBlendDiscardBlackPixel	bool	False	Discard black pixels.
rtx.stochasticAlphaBlendEnableFilter	bool	True	Filter samples to suppress noise.
rtx.stochasticAlphaBlendInitialSearchRadius	float	10	Initial search radius.
rtx.stochasticAlphaBlendNormalSimilarity	float	0.9	Min normal similarity for a valid neighbor.
rtx.stochasticAlphaBlendOpacityThreshold	float	0.95	Max opacity to use stochastic alpha blend.
rtx.stochasticAlphaBlendPlanarDifference	float	0.2	Max planar difference for a valid neighbor.
rtx.stochasticAlphaBlendRadianceVolumeMultiplier	float	1	Radiance volume multiplier.
rtx.stochasticAlphaBlendRadiusExpandFactor	float	1.6	Multiply radius by this factor if cannot find a good neighbor.
rtx.stochasticAlphaBlendSearchIteration	int	6	Search iterations.
rtx.stochasticAlphaBlendSearchTheSameObject	bool	True	Only use radiance samples from the same object.
rtx.stochasticAlphaBlendShareNeighbors	bool	True	Share result with other pixels to accelerate search.
rtx.stochasticAlphaBlendUseNeighborSearch	bool	True	Get radiance from neighbor opaque pixels.
rtx.stochasticAlphaBlendUseRadianceVolume	bool	True	Get radiance from radiance volume.
rtx.taauPreset	int	1	Adjusts TAA-U scaling factor, trades quality for performance.
rtx.temporalAA.colorClampingFactor	float	1
rtx.temporalAA.maximumRadiance	float	10000
rtx.temporalAA.newFrameWeight	float	1
rtx.tonemap.colorBalance	float3	1, 1, 1
rtx.tonemap.colorGradingEnabled	bool	False
rtx.tonemap.contrast	float	1
rtx.tonemap.curveShift	float	0	Range [0, inf). Amount by which to shift the tone curve up or down. Nonzero values will cause additional clipping.
rtx.tonemap.dynamicRange	float	15	Range [0, inf). Without further adjustments, the tone curve will try to fit the entire luminance of the scene into the range [-dynamicRange, 0] in linear photographic stops. Higher values adjust for ambient monitor lighting; perfect conditions -> 17.587 stops.
rtx.tonemap.exposureBias	float	0
rtx.tonemap.finalizeWithACES	bool	False
rtx.tonemap.maxExposureIncrease	float	5	Range [0, inf). Forces the tone curve to not increase luminance values at any point more than this value.
rtx.tonemap.saturation	float	1
rtx.tonemap.shadowContrast	float	0	Range [0, inf). Additional gamma power to apply to the tone of the tone curve below shadowContrastEnd.
rtx.tonemap.shadowContrastEnd	float	0	Range (-inf, 0]. High endpoint for the shadow contrast effect in linear stops; values above this are unaffected.
rtx.tonemap.shadowMinSlope	float	0	Range [0, inf). Forces the tone curve below a linear value of 0.18 to have at least this slope, making the tone darker.
rtx.tonemap.toneCurveMaxStops	float	8	High endpoint of the tone curve (in log2(linear)).
rtx.tonemap.toneCurveMinStops	float	-24	Low endpoint of the tone curve (in log2(linear)).
rtx.tonemap.tonemappingEnabled	bool	True
rtx.tonemap.tuningMode	bool	False
rtx.tonemappingMode	int	1	The tonemapping type to use, 0 for Global, 1 for Local (Default). Global tonemapping tonemaps the image with respect to global parameters, usually based on statistics about the rendered image as a whole. Local tonemapping on the other hand uses more spatially-local parameters determined by regions of the rendered image rather than the whole image. Local tonemapping can result in better preservation of highlights and shadows in scenes with high amounts of dynamic range whereas global tonemapping may have to comprimise between over or underexposure.
rtx.translucentDecalAlbedoFactor	float	10	A global scale factor applied to the albedo of decals that are applied to a translucent base material, to make the decals more visible. This is generally needed as albedo values for decals may be fairly low when dealing with opaque surfaces, but the translucent diffuse layer requires a fairly high albedo value to result in an expected look. The need for this option could be avoided by simply authoring decals applied to translucent materials with a higher albedo to begin with, but sometimes applications may share decals between different material types.
rtx.translucentMaterial.enableDiffuseLayerOverride	bool	False	A flag to force the diffuse layer on the translucent material to be enabled. Should only be used for debugging or development.
rtx.translucentMaterial.normalIntensity	float	1	An arbitrary strength scale factor to apply when decoding normals in the translucent material. Should only be used for debugging or development.
rtx.translucentMaterial.transmittanceColorBias	float	0	A bias factor to add to all transmittance color values in the opaque material. Should only be used for debugging or development.
rtx.translucentMaterial.transmittanceColorScale	float	1	A scale factor to apply to all transmittance color values in the translucent material. Should only be used for debugging or development.
rtx.translucentSpecularLobeSamplingProbabilityZeroThreshold	float	0.01	The threshold for which to zero translucent specular probability weight values.
rtx.translucentTransmissionLobeSamplingProbabilityZeroThreshold	float	0.01	The threshold for which to zero translucent transmission probability weight values.
rtx.uniqueObjectDistance	float	300	[cm]
rtx.upscalerType	int	1	Upscaling boosts performance with varying degrees of image quality tradeoff depending on the type of upscaler and the quality mode/preset.
rtx.upscalingMipBias	float	0	Specifies a mipmapping level bias to add to all material texture filtering when upscaling (such as DLSS) is used. Mipmaps are determined based on how far away a texture is, using this can bias the desired level in a lower quality direction (positive bias), or a higher quality direction with potentially more aliasing (negative bias). Note that mipmaps are also important for good spatial caching of textures, so too far negative of a mip bias may start to significantly affect performance, therefore changing this value is not recommended
rtx.useAnisotropicFiltering	bool	True	A flag to indicate if anisotropic filtering should be used on material textures, otherwise typical trilinear filtering will be used. This should generally be enabled as anisotropic filtering allows for less blurring on textures at grazing angles than typical trilinear filtering with only usually minor performance impact (depending on the max anisotropy samples).
rtx.useDenoiser	bool	True	Enables usage of denoiser(s) when set to true, otherwise disables denoising when set to false. Denoising is important for filtering the raw noisy ray traced signal into a smoother and more stable result at the cost of some potential spatial/temporal artifacts (ghosting, boiling, blurring, etc). Generally should remain enabled except when debugging behavior which requires investigating the output directly, or diagnosing denoising-related issues.
rtx.useDenoiserReferenceMode	bool	False	Enables the reference "denoiser" when set to true, otherwise uses the standard denoiser when set to false. Note this requires the denoiser to be enabled to function. The reference denoiser allows for a reference multi-sample per pixel contribution to accumulate which should converge slowly to the ideal result the renderer is working towards. Useful for analyzing quality differences in various denoising methods, post-processing filters, or for more accurately comparing subtle effects of potentially biased rendering techniques which may be hard to see through usual noise and filtering. Also useful for higher quality artistic renders of a scene beyond what is possible in realtime.
rtx.useHighlightLegacyMode	bool	False
rtx.useHighlightUnsafeAnchorMode	bool	False
rtx.useHighlightUnsafeReplacementMode	bool	False
rtx.useIntersectionBillboardsOnPrimaryRays	bool	False
rtx.useLiveShaderEditMode	bool	False	When set to true shaders will be automatically recompiled when any shader file is updated (saved for instance) in addition to the usual manual recompilation trigger.
rtx.useObsoleteHashOnTextureUpload	bool	False	Whether or not to use slower XXH64 hash on texture upload. New projects should not enable this option as this solely exists for compatibility with older hashing schemes.
rtx.usePartialDdsLoader	bool	True	A flag controlling if the partial DDS loader should be used, true to enable, false to disable and use GLI instead. Generally this should be always enabled as it allows for simple parsing of DDS header information without loading the entire texture into memory like GLI does to retrieve similar information. Should only be set to false for debugging purposes if the partial DDS loader's logic is suspected to be incorrect to compare against GLI's implementation.
rtx.usePostFilter	bool	True	Uses post filter to remove fireflies in the denoised result.
rtx.useRTXDI	bool	True	A flag indicating if RTXDI should be used, true enables RTXDI, false disables it and falls back on simpler light sampling methods. RTXDI provides improved direct light sampling quality over traditional methods and should generally be enabled for improved direct lighting quality at the cost of some performance.
rtx.useRayPortalVirtualInstanceMatching	bool	True
rtx.useReSTIRGI	bool	True	A flag indicating if ReSTIR GI should be used, true enables ReSTIR GI, false disables it and relies on typical GI sampling. ReSTIR GI provides improved indirect path sampling over typical importance sampling and should usually be enabled for better indirect diffuse and specular GI quality at the cost of some performance.
rtx.useVertexCapture	bool	True	When enabled, injects code into the original vertex shader to capture final shaded vertex positions. Is useful for games using simple vertex shaders, that still also set the fixed function transform matrices.
rtx.useVertexCapturedNormals	bool	True	When enabled, vertex normals are read from the input assembler and used in raytracing. This doesn't always work as normals can be in any coordinate space, but can help sometimes.
rtx.useVirtualShadingNormalsForDenoising	bool	True	A flag to enable or disable the usage of virtual shading normals for denoising passes. This is primairly important for anything that modifies the direction of a primary ray, so mainly PSR and ray portals as both of these will view a surface from an angle different from the "virtual" viewing direction perceived by the camera. This can cause some issues with denoising due to the normals not matching the expected perception of what the normals should be, for example normals facing away from the camera direction due to being viewed from a different angle via refraction or portal teleportation. To correct this, virtual normals are calculcated such that they always are oriented relative to the primary camera ray as if its direction was never altered, matching the virtual perception of the surface from the camera's point of view. As an aside, virtual normals themselves can cause issues with denoising due to the normals suddenly changing from virtual to "real" normals upon traveling through a portal, causing surface consistency failures in the denoiser, but this is accounted for via a special transform given to the denoiser on camera ray portal teleportation events. As such, this option should generally always be enabled when rendering with ray portals in the scene to have good denoising quality.
rtx.useWhiteMaterialMode	bool	False
rtx.validateCPUIndexData	bool	False
rtx.vertexColorStrength	float	0.6	A scalar to apply to how strong vertex color influence should be on materials. A value of 1 indicates that it should be fully considered (though do note the texture operation and relevant parameters still control how much it should be blended with the actual albedo color), a value of 0 indicates that it should be fully ignored.
rtx.viewDistance.distanceFadeMax	float	500	The view distance based on the result of the view distance function to end view distance noise fading at (and effectively draw nothing past this point), only used for the Coherent Noise view distance mode.
rtx.viewDistance.distanceFadeMin	float	400	The view distance based on the result of the view distance function to start view distance noise fading at, only used for the Coherent Noise view distance mode.
rtx.viewDistance.distanceFunction	int	0	The view distance function, Euclidean is a simple distance from the camera, whereas Planar Euclidean will ignore distance across the world's "up" direction.
rtx.viewDistance.distanceMode	int	0	The view distance mode, None disables view distance, Hard Cutoff will cut off geometry past a point, and Coherent Noise will feather geometry out using a stable worldspace noise pattern (experimental).
rtx.viewDistance.distanceThreshold	float	500	The view distance to draw out to based on the result of the view distance function, only used for the Hard Cutoff view distance mode.
rtx.viewDistance.noiseScale	float	3	The scale per meter value applied to ther world space position fed into the noise generation function for generating the fade in Coherent Noise view distance mode.
rtx.viewModel.enable	bool	False	If true, try to resolve view models (e.g. first-person weapons). World geometry doesn't have shadows / reflections / etc from the view models.
rtx.viewModel.enableVirtualInstances	bool	True	If true, virtual instances are created to render the view models behind a portal.
rtx.viewModel.perspectiveCorrection	bool	True	If true, apply correction to view models (e.g. different FOV is used for view models).
rtx.viewModel.rangeMeters	float	1	[meters] Max distance at which to find a portal for view model virtual instances. If rtx.viewModel.separateRays is true, this is also max length of view model rays.
rtx.viewModel.scale	float	1	Scale for view models. Minimize to prevent clipping.
rtx.viewModel.separateRays	bool	False	If true, launch additional primary rays to render view models on top of everything.
rtx.volumetricAnisotropy	float	0	The anisotropy of the scattering phase function (-1 being backscattering, 0 being isotropic, 1 being forward scattering).
rtx.volumetricClampedReprojectionConfidencePenalty	float	0.5	The penalty from [0, 1] to apply to the sample count of temporally reprojected reservoirs when reprojection is clamped to the fustrum (indicating lower quality reprojection).
rtx.volumetricEnableInitialVisibility	bool	True	Determines whether to trace a visibility ray for Reservoir samples. Results in slightly higher quality froxel grid light samples at the cost of a ray per froxel cell each frame and should generally be enabled.
rtx.volumetricEnableTemporalResampling	bool	True	Indicates if temporal resampling should be used for volume integration. Temporal resampling allows for reuse of temporal information when picking froxel grid light samples similar to how ReSTIR works, providing higher quality light samples. This should generally be enabled but currently due to the lack of temporal bias correction this option will slightly bias the lighting result.
rtx.volumetricInitialRISSampleCount	int	8	The number of RIS samples to select from the global pool of lights when constructing a Reservoir sample. Higher values generally increases the quality of the selected light sample, though similar to the general RIS light sample count has diminishing returns.
rtx.volumetricSingleScatteringAlbedo	float3	0.9, 0.9, 0.9	The single scattering albedo (otherwise known as the particle albedo) representing the ratio of scattering to absorption. While color-like in many ways this value is assumed to be more of a mathematical albedo (unlike material albedo which is treated more as a color), and is therefore treated as linearly encoded data (not gamma).
rtx.volumetricTemporalReuseMaxSampleCount	int	200	The number of samples to clamp temporal reservoirs to, should usually be around the value: desired_max_history_frames * average_reservoir_samples.
rtx.volumetricTransmittanceColor	float3	0.953237, 0.92879, 0.903545	The color to use for calculating transmittance measured at a specific distance. Note that this color is assumed to be in sRGB space and gamma encoded as it will be converted to linear for use in volumetrics.
rtx.volumetricTransmittanceMeasurementDistance	float	10000	The distance the specified transmittance color was measured at. Lower distances indicate a denser medium.
rtx.worldSpaceUiBackgroundOffset	float	-0.01	Distance along normal to offset objects rendered as worldspace UI, specifically for the background of screens.
rtx.zUp	bool	False	Indicates that the Z axis is the "upward" axis in the world when true, otherwise the Y axis when false.

Complex Types

RTX Option	Type	Default Value	Description
rtx.animatedWaterTextures	hash set		Textures on draw calls to be treated as "animated water". Objects with this flag applied will animate their normals to fake a basic water effect based on the layered water material parameters, and only when rtx.opaqueMaterial.layeredWaterNormalEnable is set to true. Should typically be used on static water planes that the original application may have relied on shaders to animate water on.
rtx.antiCulling.antiCullingTextures	hash set		[Experimental] Textures that are forced to extend life length when anti-culling is enabled. Some games use different culling methods we can't fully match, use this option to manually add textures to force extend their life when anti-culling fails.
rtx.baseGameModPathRegex	string		Regex used to redirect RTX Remix Runtime to another path for replacements and rtx.conf.
rtx.baseGameModRegex	string		Regex used to determine if the base game is running a mod, like a sourcemod.
rtx.beamTextures	hash set		Textures on draw calls that are already particles or emissively blended and have beam-like geometry. Typically objects marked as particles or objects using emissive blending will be rendered with a special method which allows re-orientation of the billboard geometry assumed to make up the draw call in indirect rays (reflections for example). This method works fine for typical particles, but some (e.g. a laser beam) may not be well-represented with the typical billboard assumption of simply needing to rotate around its centroid to face the view direction. To handle such cases a different beam mode is used to treat objects as more of a cylindrical beam and re-orient around its main spanning axis, allowing for better rendering of these beam-like effect objects.
rtx.captureInstanceStageName	string
rtx.cutoutTextures	hash set
rtx.decalTextures	hash set		Textures on draw calls used for static geometric decals or decals with complex topology. These materials will be blended over the materials underneath them when decal material blending is enabled. A small configurable offset is applied to each flat part of these decals to prevent coplanar geometric cases (which poses problems for ray tracing).
rtx.dynamicDecalTextures	hash set		Textures on draw calls used for dynamically spawned geometric decals, such as bullet holes. These materials will be blended over the materials underneath them when decal material blending is enabled. A small configurable offset is applied to each flat part of these decals to prevent coplanar geometric cases (which poses problems for ray tracing).
rtx.geometryAssetHashRuleString	string	positions,indices,geometrydescriptor	Defines which hashes we need to include when sampling from replacements and doing USD capture.
rtx.geometryGenerationHashRuleString	string	positions,indices,texcoords,geometrydescriptor,vertexlayout	Defines which asset hashes we need to generate via the geometry processing engine.
rtx.hideInstanceTextures	hash set		Textures on draw calls that should be hidden from rendering, but not totally ignored. This is similar to rtx.ignoreTextures but instead of completely ignoring such draw calls they are only hidden from rendering, allowing for the hidden objects to still appear in captures. As such, this is mostly only a development tool to hide objects during development until they are properly replaced, otherwise the objects should be ignored with rtx.ignoreTextures instead for better performance.
rtx.ignoreLights	hash set		Lights that should be ignored. Any matching light will be skipped and not added to be ray traced.
rtx.ignoreTextures	hash set		Textures on draw calls that should be ignored. Any draw call using an ignore texture will be skipped and not ray traced, useful for removing undesirable rasterized effects or geometry not suitable for ray tracing.
rtx.lightConverter	hash set
rtx.lightmapTextures	hash set		Textures used for lightmapping (baked static lighting on surfaces) in older games. These textures will be ignored when attempting to determine the desired textures from a draw to use for ray tracing.
rtx.nonOffsetDecalTextures	hash set		Textures on draw calls used for geometric decals with arbitrary topology that are already offset from the base geometry. These materials will be blended over the materials underneath them when decal material blending is enabled. Unlike typical decals however these decals have no offset applied to them due assuming the offset is already being done by whatever is passing data to Remix.
rtx.opacityMicromapIgnoreTextures	hash set
rtx.particleTextures	hash set		Textures on draw calls that should be treated as particles. When objects are marked as particles more approximate rendering methods are leveraged allowing for more effecient and typically better looking particle rendering. Generally any billboard-like blended particle objects in the original application should be classified this way.
rtx.playerModelBodyTextures	hash set
rtx.playerModelTextures	hash set
rtx.rayPortalModelTextureHashes	hash vector		Texture hashes identifying ray portals. Allowed number of hashes: {0, 2}.
rtx.skyBoxTextures	hash set		Textures on draw calls used for the sky or are otherwise intended to be very far away from the camera at all times (no parallax). Any draw calls using a texture in this list will be treated as sky and rendered as such in a manner different from typical geometry.
rtx.sourceRootPath	string		A path pointing at the root folder of the project, used to override the path to the root of the project generated at build-time (as this path is only valid for the machine the project was originally compiled on). Used primarily for locating shader source files for runtime shader recompilation.
rtx.terrainTextures	hash set
rtx.uiTextures	hash set		Textures on draw calls that should be treated as screenspace UI elements. All exclusively UI-related textures should be classified this way and doing so allows the UI to be rasterized on top of the ray traced scene like usual. Note that currently the first UI texture encountered triggers RTX injection (though this may change in the future as this does cause issues with games that draw UI mid-frame).
rtx.worldSpaceUiBackgroundTextures	hash set
rtx.worldSpaceUiTextures	hash set		Textures on draw calls that should be treated as worldspace UI elements. Unlike typical UI textures this option is useful for improved rendering of UI elements which appear as part of the scene (moving around in 3D space rather than as a screenspace element).