Environment

public float AdjustmentBrightness { get; set; }

Applies a simple brightness adjustment to the rendered image after tonemaping. To adjust scene brightness use Environment.TonemapExposure instead, which is applied before tonemapping and thus less prone to issues with bright colors. Effective only if Environment.AdjustmentEnabled is true.

public Texture AdjustmentColorCorrection { get; set; }

The Texture2D or Texture3D lookup table (LUT) to use for the built-in post-process color grading. Can use a GradientTexture1D for a 1-dimensional LUT, or a Texture3D for a more complex LUT. Effective only if Environment.AdjustmentEnabled is true. Note: Color correction does not currently support HDR output due to only supporting values in the SDR (0.0 to 1.0) range.

public float AdjustmentContrast { get; set; }

Increasing Environment.AdjustmentContrast will make dark values darker and bright values brighter. This simple adjustment is applied to the rendered image after tonemaping. When set to a value greater than 1.0, Environment.AdjustmentContrast is prone to clipping colors that become too bright or too dark. Effective only if Environment.AdjustmentEnabled is true.

public bool AdjustmentEnabled { get; set; }

If true, enables the adjustment_* properties provided by this resource. If false, modifications to the adjustment_* properties will have no effect on the rendered scene.

public float AdjustmentSaturation { get; set; }

Applies a simple saturation adjustment to the rendered image after tonemaping. When Environment.AdjustmentSaturation is set to 0.0, the rendered image will be fully converted to a grayscale image. Effective only if Environment.AdjustmentEnabled is true.

public Color AmbientLightColor { get; set; }

The ambient light's Color. Only effective if Environment.AmbientLightSkyContribution is lower than 1.0 (exclusive).

public float AmbientLightEnergy { get; set; }

Ambient illumination multiplier for the selected source. Color at 1 lights the example geometry without Key. Does not produce directional shadows or GI color transfer between objects.

public float AmbientLightSkyContribution { get; set; }

Defines the amount of light that the sky brings on the scene. A value of 0.0 means that the sky's light emission has no effect on the scene illumination, thus all ambient illumination is provided by the ambient light. On the contrary, a value of 1.0 means that all the light that affects the scene is provided by the sky, thus the ambient light parameter has no effect on the scene. Note: Environment.AmbientLightSkyContribution is internally clamped between 0.0 and 1.0 (inclusive).

public Environment.AmbientSource AmbientLightSource { get; set; }

Ambient illumination source. Color uses AmbientLightColor and AmbientLightEnergy; Disabled removes ambient. Explicit selection separates illumination from BackgroundMode. Color without direct lights is verified.

public int BackgroundCameraFeedId { get; set; }

The ID of the camera feed to show in the background.

public int BackgroundCanvasMaxLayer { get; set; }

The maximum layer ID to display. Only effective when using the Environment.BGMode.Canvas background mode.

public Color BackgroundColor { get; set; }

Background color for the selected BackgroundMode. Does not by itself enable ambient lighting or assign the resource to a camera/world. Use BGMode.Color and explicitly select AmbientLightSource for a predictable setup.

public float BackgroundEnergyMultiplier { get; set; }

Multiplier for background energy. Increase to make background brighter, decrease to make background dimmer.

public float BackgroundIntensity { get; set; }

Luminance of background measured in nits (candela per square meter). Only used when ProjectSettings.rendering/lights_and_shadows/use_physical_light_units is enabled. The default value is roughly equivalent to the sky at midday.

public Environment.BGMode BackgroundMode { get; set; }

Background source: for example Color uses BackgroundColor, while Sky requires a configured Sky. Separate from ambient/reflection sources; an attractive background does not guarantee illuminated geometry.

public float FogAerialPerspective { get; set; }

If set above 0.0 (exclusive), blends between the fog's color and the color of the background Sky, as read from the radiance cubemap. This has a small performance cost when set above 0.0. Must have Environment.BackgroundMode set to Environment.BGMode.Sky. This is useful to simulate aerial perspective in large scenes with low density fog. However, it is not very useful for high-density fog, as the sky will shine through. When set to 1.0, the fog color comes completely from the Sky. If set to 0.0, aerial perspective is disabled. Notice that this does not sample the Sky directly, but rather the radiance cubemap. The cubemap is sampled at a mipmap level depending on the depth of the rendered pixel; the farther away, the higher the resolution of the sampled mipmap. This results in the actual color being a blurred version of the sky, with more blur closer to the camera. The highest mipmap resolution is used at a depth of Camera3D.Far.

public float FogDensity { get; set; }

The fog density to be used. This is demonstrated in different ways depending on the Environment.FogMode mode chosen: Exponential Fog Mode: Higher values result in denser fog. The fog rendering is exponential like in real life. Depth Fog mode: The maximum intensity of the deep fog, effect will appear in the distance (relative to the camera). At 1.0 the fog will fully obscure the scene, at 0.0 the fog will not be visible.

public float FogDepthBegin { get; set; }

The fog's depth starting distance from the camera. Only available when Environment.FogMode is set to Environment.FogModeEnum.Depth.

public float FogDepthCurve { get; set; }

The fog depth's intensity curve. A number of presets are available in the Inspector by right-clicking the curve. Only available when Environment.FogMode is set to Environment.FogModeEnum.Depth.

public float FogDepthEnd { get; set; }

The fog's depth end distance from the camera. If this value is set to 0, it will be equal to the current camera's Camera3D.Far value. Only available when Environment.FogMode is set to Environment.FogModeEnum.Depth.

public bool FogEnabled { get; set; }

Enables regular environment fog. Frame changes are verified for FogDensity 0 versus 0.15 within the same active mode. Separate from VolumetricFogEnabled; not evidence of volumetric light shafts in Compatibility.

public float FogHeight { get; set; }

The height at which the height fog effect begins.

public float FogHeightDensity { get; set; }

The density used to increase fog as height decreases. To make fog increase as height increases, use a negative value.

public Color FogLightColor { get; set; }

The fog's color.

public float FogLightEnergy { get; set; }

The fog's brightness. Higher values result in brighter fog.

public Environment.FogModeEnum FogMode { get; set; }

The fog mode.

public float FogSkyAffect { get; set; }

The factor to use when affecting the sky with non-volumetric fog. 1.0 means that fog can fully obscure the sky. Lower values reduce the impact of fog on sky rendering, with 0.0 not affecting sky rendering at all. Note: Environment.FogSkyAffect has no visual effect if Environment.FogAerialPerspective is 1.0.

public float FogSunScatter { get; set; }

If set above 0.0, renders the scene's directional light(s) in the fog color depending on the view angle. This can be used to give the impression that the sun is "piercing" through the fog.

public Environment.GlowBlendModeEnum GlowBlendMode { get; set; }

The glow blending mode. Note: The Compatibility renderer always uses GLOW_BLEND_MODE_SCREEN and Environment.GlowBlendMode will have no effect.

public float GlowBloom { get; set; }

Additional bloom contribution allowing less-bright regions into glow. The isolated verified example uses 0.1; large values can wash out image contrast.

public bool GlowEnabled { get; set; }

Enables bright-pixel halo processing. Actual glow around an emissive mesh is verified in current Compatibility/OpenGL. Level, blend/map and quality support differs across renderers; glow does not light neighboring objects.

public float GlowHdrLuminanceCap { get; set; }

The higher threshold of the HDR glow. Areas brighter than this threshold will be clamped for the purposes of the glow effect.

public float GlowHdrScale { get; set; }

Smooths the transition between values that are below and above Environment.GlowHdrThreshold by reducing the amount of glow generated by values that are close to Environment.GlowHdrThreshold. Values above glow_hdr_threshold + glow_hdr_scale will not have glow reduced in this way.

public float GlowHdrThreshold { get; set; }

Brightness threshold for HDR glow contribution. Consider with Emission, exposure and GlowBloom; it is not a material alpha threshold. The native example uses 0.8 with emission multiplier 8.

public float GlowIntensity { get; set; }

Added glow intensity. Output also depends on frame brightness, threshold and bloom. The example uses 1.5 for a clear halo, not as a universal quality setting.

public Texture GlowMap { get; set; }

The texture that should be used as a glow map to multiply the resulting glow color according to Environment.GlowMapStrength. This can be used to create a "lens dirt" effect. The texture's RGB color channels are used for modulation, but the alpha channel is ignored. Note: The texture will be stretched to fit the screen. Therefore, it's recommended to use a texture with an aspect ratio that matches your project's base aspect ratio (typically 16:9). Note: Environment.GlowMap has no effect when using the Compatibility rendering method, due to this rendering method using a simpler glow implementation optimized for low-end devices.

public float GlowMapStrength { get; set; }

How strong of an influence the Environment.GlowMap should have on the overall glow effect. A strength of 0.0 means the glow map has no influence, while a strength of 1.0 means the glow map has full influence. Note: If the glow map has black areas, a value of 1.0 can also turn off the glow effect entirely in specific areas of the screen. Note: Environment.GlowMapStrength has no effect when using the Compatibility rendering method, due to this rendering method using a simpler glow implementation optimized for low-end devices.

public float GlowMix { get; set; }

When using the GLOW_BLEND_MODE_MIX Environment.GlowBlendMode, this controls how much the source image is blended with the glow layer. A value of 0.0 makes the glow rendering invisible, while a value of 1.0 is equivalent to GLOW_BLEND_MODE_REPLACE. Note: Environment.GlowMix has no effect when using the Compatibility rendering method, due to this rendering method using a simpler glow implementation optimized for low-end devices.

public bool GlowNormalized { get; set; }

If true, glow levels will be normalized so that summed together their intensities equal 1.0. Note: Environment.GlowNormalized has no effect when using the Compatibility rendering method, due to this rendering method using a simpler glow implementation optimized for low-end devices.

public float GlowStrength { get; set; }

The strength that is used when blurring across the screen to generate the glow effect. This affects the distance and intensity of the blur. When using the Mobile rendering method, this should be increased to compensate for the lower dynamic range. Note: Environment.GlowStrength has no effect when using the Compatibility rendering method, due to this rendering method using a simpler glow implementation optimized for low-end devices.

public Environment.ReflectionSource ReflectedLightSource { get; set; }

Environment reflection source, separate from BackgroundMode and ambient. Disabled intentionally removes sky reflections in the example; the metal sphere is therefore not a complete environment-lit PBR demonstration.

public float SdfgiBounceFeedback { get; set; }

Feedback coefficient for repeated indirect-light propagation, default 0.5. Start at 0 when diagnosing growing overexposure. The inspector hint 0…1.99 does not clamp the setter; retaining a higher value does not mean the resulting image is stable or correct. Do not mask energy buildup with camera exposure alone.

public float SdfgiCascade0Distance { get; set; }

Derived nearest-cascade distance: 64 * SdfgiMinCellSize. Setting D assigns MinCellSize = D / 64, also changing MaxDistance. Not an independent stored setting; recomputed from cell size on load. Use a finite positive distance and do not assign the three linked quantities as independent values.

public int SdfgiCascades { get; set; }

Number of cascades around the camera, default 4. Valid integers are 1…8; invalid values are rejected with an error and must not be used. With MinCellSize unchanged, cascade count changes MaxDistance: 64 * MinCellSize * 2^Cascades. Cell size does not adjust to preserve the previous distance. More cascades require more resources.

public bool SdfgiEnabled { get; set; }

Enables SDFGI for this Environment; defaults to false. Visible only when this resource is actually selected by the current WorldEnvironment/Camera3D and Forward+ is used. Does not create dynamic occluders or replace static-geometry preparation. Enabling the flag does not mean lighting has already converged.

public float SdfgiEnergy { get; set; }

SDFGI indirect-light multiplier, default 1. Not camera exposure and does not change direct-light energy. The setter does not clamp; use a finite nonnegative value. High energy does not repair missing static geometry, incorrect Environment selection or leaks.

public float SdfgiMaxDistance { get; set; }

Derived coverage distance: 64 * SdfgiMinCellSize * 2^SdfgiCascades. Setting D changes MinCellSize to D / (64 * 2^Cascades), also changing Cascade0Distance. Not stored independently in the resource. Choose cascade count first, then set either cell size or one distance. This is finite camera-centered coverage, not infinite GI throughout the world.

public float SdfgiMinCellSize { get; set; }

Nearest-cascade cell size in world units, default 0.2. Use a finite positive value. The inspector hint 0.01…64 does not clamp the setter. Changes both derived distances: Cascade0Distance = 64 * MinCellSize, MaxDistance = Cascade0Distance * 2^Cascades. Smaller cells increase spatial detail without promising free quality improvement.

public float SdfgiNormalBias { get; set; }

Normal-directed position offset when applying SDFGI, default 1.1. Distinct from ProbeBias used during probe tracing. Adjust gradually while comparing self-occlusion and leaks; larger values do not guarantee a better frame. The setter forwards the value without automatic correction.

public float SdfgiProbeBias { get; set; }

Ray bias used while updating SDFGI probes, default 1.1. Does not replace NormalBias for surface sampling. May help tracing artifacts, but excessive bias can skip nearby occluders. The setter does not clamp; inspect the result on level geometry.

public bool SdfgiReadSkyLight { get; set; }

Include sky lighting in SDFGI; defaults to true. Can be disabled for a closed room after checking other sources. false does not disable the Environment background, a direct DirectionalLight3D or other ambient-light paths.

public bool SdfgiUseOcclusion { get; set; }

Additional SDFGI sampling occlusion, default false. May reduce leaks but adds work and does not repair open or excessively thin geometry. Check image quality and GPU time separately. A stored true value does not prove the effect operates in an unsupported renderer.

public Environment.SdfgiyScale SdfgiYScale { get; set; }

Vertical SDFGI distribution mode: Scale50Percent, Scale75Percent or Scale100Percent; defaults to Scale75Percent. More compact modes change vertical coverage/density, not level geometry scale. Choose for scene height and inspect ceilings, floors and leaks; do not supply an arbitrary enum value.

public Sky Sky { get; set; }

Sky resource for this environment. Displaying it as the background requires BackgroundMode = Sky; ambient/reflected light sources are separate settings. The camera must use the World3D containing this environment.

public float SkyCustomFov { get; set; }

Custom sky FOV in degrees; 0 retains the camera projection. Current RD applies it to the background with a single view. It neither changes Camera3D geometry FOV nor guarantees the same behavior in multiview XR.

public Vector3 SkyRotation { get; set; }

Sky orientation as Euler angles in radians. This is neither Camera3D rotation nor inspector degrees. Current RD applies orientation during sky lookup; separate radiance generation does not rotate the same data a second time.

public float SsaoAOChannelAffect { get; set; }

The screen-space ambient occlusion intensity on materials that have an AO texture defined. Values higher than 0 will make the SSAO effect visible in areas darkened by AO textures.

public float SsaoDetail { get; set; }

Sets the strength of the additional level of detail for the screen-space ambient occlusion effect. A high value makes the detail pass more prominent, but it may contribute to aliasing in your final image.

public bool SsaoEnabled { get; set; }

Enables screen-space ambient occlusion. Current Compatibility has a basic Radius/Intensity implementation: intensity 0 versus 3 in the same active post-processing path produces local pixel changes. This does not establish algorithm or full-setting parity with Forward+.

public float SsaoHorizon { get; set; }

The threshold for considering whether a given point on a surface is occluded or not represented as an angle from the horizon mapped into the 0.0-1.0 range. A value of 1.0 results in no occlusion.

public float SsaoIntensity { get; set; }

SSAO darkening strength when SsaoEnabled. The controlled example keeps SSAO enabled and changes only 0/3 to avoid confusing occlusion with a post-processing-path change. Not direct-light or physical-shadow strength.

public float SsaoLightAffect { get; set; }

The screen-space ambient occlusion intensity in direct light. In real life, ambient occlusion only applies to indirect light, which means its effects can't be seen in direct light. Values higher than 0 will make the SSAO effect visible in direct light.

public float SsaoPower { get; set; }

The distribution of occlusion. A higher value results in darker occlusion, similar to Environment.SsaoIntensity, but with a sharper falloff.

public float SsaoRadius { get; set; }

SSAO radius scale around visible geometry. Compatibility source applies its own parameter scaling; equal numbers across renderers do not guarantee equal output. The example uses 2.

public float SsaoSharpness { get; set; }

The amount that the screen-space ambient occlusion effect is allowed to blur over the edges of objects. Setting too high will result in aliasing around the edges of objects. Setting too low will make object edges appear blurry.

public bool SsilEnabled { get; set; }

If true, the screen-space indirect lighting effect is enabled. Screen space indirect lighting is a form of indirect lighting that allows diffuse light to bounce between nearby objects. Screen-space indirect lighting works very similarly to screen-space ambient occlusion, in that it only affects a limited range. It is intended to be used along with a form of proper global illumination like SDFGI or VoxelGI. Screen-space indirect lighting is not affected by individual light's Light3D.LightIndirectEnergy. Note: SSIL is only supported in the Forward+ rendering method, not Mobile or Compatibility.

public float SsilIntensity { get; set; }

The brightness multiplier for the screen-space indirect lighting effect. A higher value will result in brighter light.

public float SsilNormalRejection { get; set; }

Amount of normal rejection used when calculating screen-space indirect lighting. Normal rejection uses the normal of a given sample point to reject samples that are facing away from the current pixel. Normal rejection is necessary to avoid light leaking when only one side of an object is illuminated. However, normal rejection can be disabled if light leaking is desirable, such as when the scene mostly contains emissive objects that emit light from faces that cannot be seen from the camera.

public float SsilRadius { get; set; }

The distance that bounced lighting can travel when using the screen space indirect lighting effect. A larger value will result in light bouncing further in a scene, but may result in under-sampling artifacts which look like long spikes surrounding light sources.

public float SsilSharpness { get; set; }

The amount that the screen-space indirect lighting effect is allowed to blur over the edges of objects. Setting too high will result in aliasing around the edges of objects. Setting too low will make object edges appear blurry.

public float SsrDepthTolerance { get; set; }

The depth tolerance for screen-space reflections.

public bool SsrEnabled { get; set; }

If true, screen-space reflections are enabled. Screen-space reflections are more accurate than reflections from VoxelGIs or ReflectionProbes, but are slower and can't reflect surfaces occluded by others. Note: SSR is only supported in the Forward+ rendering method, not Mobile or Compatibility. Note: SSR is not supported on viewports that have a transparent background (where Viewport.TransparentBg is true).

public float SsrFadeIn { get; set; }

The fade-in distance for screen-space reflections. Affects the area from the reflected material to the screen-space reflection. Only positive values are valid (negative values will be clamped to 0.0).

public float SsrFadeOut { get; set; }

The fade-out distance for screen-space reflections. Affects the area from the screen-space reflection to the "global" reflection. Only positive values are valid (negative values will be clamped to 0.0).

public int SsrMaxSteps { get; set; }

The maximum number of steps for screen-space reflections. Higher values are slower.

public float TonemapAgxContrast { get; set; }

Increasing Environment.TonemapAgxContrast will make dark values darker and bright values brighter. Produces a higher quality result than Environment.AdjustmentContrast without any additional performance cost, but is only available when using the TONE_MAPPER_AGX tonemapper.

public float TonemapAgxWhite { get; set; }

The white reference value for tonemapping, which indicates where bright white is located in the scale of values provided to the tonemapper. For photorealistic lighting, it is recommended to set Environment.TonemapAgxWhite to at least 6.0. Higher values result in less blown out highlights, but may make the scene appear lower contrast. Environment.TonemapAgxWhite is the same as Environment.TonemapWhite, but is only effective with the TONE_MAPPER_AGX tonemapper. See also Environment.TonemapExposure. Note: When using the Mobile renderer with Viewport.UseHdr2D disabled, Environment.TonemapAgxWhite is ignored and a white value of 2.0 will always be used instead. Otherwise, Environment.TonemapAgxWhite will be dynamically adjusted at runtime by multiplying it by the parent window's Window.GetOutputMaxLinearValue when using Viewport.UseHdr2D to ensure good behavior with both SDR and HDR output.

public float TonemapExposure { get; set; }

Adjusts the brightness of values before they are provided to the tonemapper. Higher Environment.TonemapExposure values result in a brighter image. See also Environment.TonemapWhite. Note: Values provided to the tonemapper will also be multiplied by 2.0 and 1.8 for TONE_MAPPER_FILMIC and TONE_MAPPER_ACES respectively to produce a similar apparent brightness as TONE_MAPPER_LINEAR.

public Environment.ToneMapper TonemapMode { get; set; }

Output tone-mapping method. The verified example holds Linear constant across comparisons. Reassess lights and glow when changing tone mapping, exposure or renderer; one preset does not guarantee identical output everywhere.

public float TonemapWhite { get; set; }

The white reference value for tonemapping, which indicates where bright white is located in the scale of values provided to the tonemapper. For photorealistic lighting, it is recommended to set Environment.TonemapWhite to at least 6.0. Higher values result in less blown out highlights, but may make the scene appear lower contrast. Environment.TonemapAgxWhite will be used instead when using the TONE_MAPPER_AGX tonemapper. See also Environment.TonemapExposure. Note: Environment.TonemapWhite must be set to 2.0 or lower on the Mobile renderer to produce bright images. Note: Environment.TonemapWhite is ignored when using TONE_MAPPER_LINEAR and will be dynamically adjusted at runtime to never be less than the parent window's Window.GetOutputMaxLinearValue when using TONE_MAPPER_REINHARDT with Viewport.UseHdr2D.

public Color VolumetricFogAlbedo { get; set; }

The Color of the volumetric fog when interacting with lights. Mist and fog have an albedo close to Color(1, 1, 1, 1) while smoke has a darker albedo.

public float VolumetricFogAmbientInject { get; set; }

Scales the strength of ambient light used in the volumetric fog. A value of 0.0 means that ambient light will not impact the volumetric fog. Environment.VolumetricFogAmbientInject has a small performance cost when set above 0.0. Note: This has no visible effect if Environment.VolumetricFogDensity is 0.0 or if Environment.VolumetricFogAlbedo is a fully black color.

public float VolumetricFogAnisotropy { get; set; }

The direction of scattered light as it goes through the volumetric fog. A value close to 1.0 means almost all light is scattered forward. A value close to 0.0 means light is scattered equally in all directions. A value close to -1.0 means light is scattered mostly backward. Fog and mist scatter light slightly forward, while smoke scatters light equally in all directions.

public float VolumetricFogDensity { get; set; }

The base exponential density of the volumetric fog. Set this to the lowest density you want to have globally. FogVolumes can be used to add to or subtract from this density in specific areas. Fog rendering is exponential as in real life. A value of 0.0 disables global volumetric fog while allowing FogVolumes to display volumetric fog in specific areas. To make volumetric fog work as a volumetric lighting solution, set Environment.VolumetricFogDensity to the lowest non-zero value (0.0001) then increase lights' Light3D.LightVolumetricFogEnergy to values between 10000 and 100000 to compensate for the very low density.

public float VolumetricFogDetailSpread { get; set; }

The distribution of size down the length of the froxel buffer. A higher value compresses the froxels closer to the camera and places more detail closer to the camera.

public Color VolumetricFogEmission { get; set; }

The emitted light from the volumetric fog. Even with emission, volumetric fog will not cast light onto other surfaces. Emission is useful to establish an ambient color. As the volumetric fog effect uses single-scattering only, fog tends to need a little bit of emission to soften the harsh shadows.

public float VolumetricFogEmissionEnergy { get; set; }

The brightness of the emitted light from the volumetric fog.

public bool VolumetricFogEnabled { get; set; }

Enables the volumetric fog effect. Volumetric fog uses a screen-aligned froxel buffer to calculate accurate volumetric scattering in the short to medium range. Volumetric fog interacts with FogVolumes and lights to calculate localized and global fog. Volumetric fog uses a PBR single-scattering model based on extinction, scattering, and emission which it exposes to users as density, albedo, and emission. Note: Volumetric fog is only supported in the Forward+ rendering method, not Mobile or Compatibility.

public float VolumetricFogGIInject { get; set; }

Scales the strength of Global Illumination used in the volumetric fog's albedo color. A value of 0.0 means that Global Illumination will not impact the volumetric fog. Environment.VolumetricFogGIInject has a small performance cost when set above 0.0. Note: This has no visible effect if Environment.VolumetricFogDensity is 0.0 or if Environment.VolumetricFogAlbedo is a fully black color. Note: Only VoxelGI and SDFGI (Environment.SdfgiEnabled) are taken into account when using Environment.VolumetricFogGIInject. Global illumination from LightmapGI, ReflectionProbe and SSIL (see Environment.SsilEnabled) will be ignored by volumetric fog.

public float VolumetricFogLength { get; set; }

The distance over which the volumetric fog is computed. Increase to compute fog over a greater range, decrease to add more detail when a long range is not needed. For best quality fog, keep this as low as possible. See also ProjectSettings.rendering/environment/volumetric_fog/volume_depth.

public float VolumetricFogSkyAffect { get; set; }

The factor to use when affecting the sky with volumetric fog. 1.0 means that volumetric fog can fully obscure the sky. Lower values reduce the impact of volumetric fog on sky rendering, with 0.0 not affecting sky rendering at all. Note: Environment.VolumetricFogSkyAffect also affects FogVolumes, even if Environment.VolumetricFogDensity is 0.0. If you notice FogVolumes are disappearing when looking towards the sky, set Environment.VolumetricFogSkyAffect to 1.0.

public float VolumetricFogTemporalReprojectionAmount { get; set; }

The amount by which to blend the last frame with the current frame. A higher number results in smoother volumetric fog, but makes "ghosting" much worse. A lower value reduces ghosting but can result in the per-frame temporal jitter becoming visible.

public bool VolumetricFogTemporalReprojectionEnabled { get; set; }

Enables temporal reprojection in the volumetric fog. Temporal reprojection blends the current frame's volumetric fog with the last frame's volumetric fog to smooth out jagged edges. The performance cost is minimal; however, it leads to moving FogVolumes and Light3Ds "ghosting" and leaving a trail behind them. When temporal reprojection is enabled, try to avoid moving FogVolumes or Light3Ds too fast. Short-lived dynamic lighting effects should have Light3D.LightVolumetricFogEnergy set to 0.0 to avoid ghosting.

public float GetGlowLevel(int idx);

Returns the intensity of the glow level idx.

public float GetSdfgiBounceFeedback();

Returns SdfgiBounceFeedback. Feedback coefficient for repeated indirect-light propagation, default 0.5. Start at 0 when diagnosing growing overexposure. The inspector hint 0…1.99 does not clamp the setter; retaining a higher value does not mean the resulting image is stable or correct. Do not mask energy buildup with camera exposure alone.

public float GetSdfgiCascade0Distance();

Returns SdfgiCascade0Distance. Derived nearest-cascade distance: 64 * SdfgiMinCellSize. Setting D assigns MinCellSize = D / 64, also changing MaxDistance. Not an independent stored setting; recomputed from cell size on load. Use a finite positive distance and do not assign the three linked quantities as independent values.

public int GetSdfgiCascades();

Returns SdfgiCascades. Number of cascades around the camera, default 4. Valid integers are 1…8; invalid values are rejected with an error and must not be used. With MinCellSize unchanged, cascade count changes MaxDistance: 64 * MinCellSize * 2^Cascades. Cell size does not adjust to preserve the previous distance. More cascades require more resources.

public float GetSdfgiEnergy();

Returns SdfgiEnergy. SDFGI indirect-light multiplier, default 1. Not camera exposure and does not change direct-light energy. The setter does not clamp; use a finite nonnegative value. High energy does not repair missing static geometry, incorrect Environment selection or leaks.

public float GetSdfgiMaxDistance();

Returns SdfgiMaxDistance. Derived coverage distance: 64 * SdfgiMinCellSize * 2^SdfgiCascades. Setting D changes MinCellSize to D / (64 * 2^Cascades), also changing Cascade0Distance. Not stored independently in the resource. Choose cascade count first, then set either cell size or one distance. This is finite camera-centered coverage, not infinite GI throughout the world.

public float GetSdfgiMinCellSize();

Returns SdfgiMinCellSize. Nearest-cascade cell size in world units, default 0.2. Use a finite positive value. The inspector hint 0.01…64 does not clamp the setter. Changes both derived distances: Cascade0Distance = 64 * MinCellSize, MaxDistance = Cascade0Distance * 2^Cascades. Smaller cells increase spatial detail without promising free quality improvement.

public float GetSdfgiNormalBias();

Returns SdfgiNormalBias. Normal-directed position offset when applying SDFGI, default 1.1. Distinct from ProbeBias used during probe tracing. Adjust gradually while comparing self-occlusion and leaks; larger values do not guarantee a better frame. The setter forwards the value without automatic correction.

public float GetSdfgiProbeBias();

Returns SdfgiProbeBias. Ray bias used while updating SDFGI probes, default 1.1. Does not replace NormalBias for surface sampling. May help tracing artifacts, but excessive bias can skip nearby occluders. The setter does not clamp; inspect the result on level geometry.

public Environment.SdfgiyScale GetSdfgiYScale();

Returns SdfgiYScale. Vertical SDFGI distribution mode: Scale50Percent, Scale75Percent or Scale100Percent; defaults to Scale75Percent. More compact modes change vertical coverage/density, not level geometry scale. Choose for scene height and inspect ceilings, floors and leaks; do not supply an arbitrary enum value.

public Sky GetSky();

Sky resource for this environment. Displaying it as the background requires BackgroundMode = Sky; ambient/reflected light sources are separate settings. The camera must use the World3D containing this environment.

public float GetSkyCustomFov();

Custom sky FOV in degrees; 0 retains the camera projection. Current RD applies it to the background with a single view. It neither changes Camera3D geometry FOV nor guarantees the same behavior in multiview XR.

public Vector3 GetSkyRotation();

Sky orientation as Euler angles in radians. This is neither Camera3D rotation nor inspector degrees. Current RD applies orientation during sky lookup; separate radiance generation does not rotate the same data a second time.

public bool IsSdfgiEnabled();

Returns SdfgiEnabled. Enables SDFGI for this Environment; defaults to false. Visible only when this resource is actually selected by the current WorldEnvironment/Camera3D and Forward+ is used. Does not create dynamic occluders or replace static-geometry preparation. Enabling the flag does not mean lighting has already converged.

public bool IsSdfgiReadingSkyLight();

Returns SdfgiReadSkyLight. Include sky lighting in SDFGI; defaults to true. Can be disabled for a closed room after checking other sources. false does not disable the Environment background, a direct DirectionalLight3D or other ambient-light paths.

public bool IsSdfgiUsingOcclusion();

Returns SdfgiUseOcclusion. Additional SDFGI sampling occlusion, default false. May reduce leaks but adds work and does not repair open or excessively thin geometry. Check image quality and GPU time separately. A stored true value does not prove the effect operates in an unsupported renderer.