Table of Contents

Class Environment

Namespace
Godot
Assembly
GodotSharp.dll

Resource for environment nodes (like WorldEnvironment) that define multiple environment operations (such as background Sky or Color, ambient light, fog, depth-of-field...). These parameters affect the final render of the scene. The order of these operations is:

- Depth of Field Blur

- Glow

- Tonemap (Auto Exposure)

- Adjustments

public class Environment : Resource, IDisposable
Inheritance
Environment
Implements
Inherited Members

Constructors

Environment() 

public Environment()

Properties

AdjustmentBrightness

The global brightness value of the rendered scene. Effective only if AdjustmentEnabled is true.

public float AdjustmentBrightness { get; set; }

Property Value

float

AdjustmentColorCorrection

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 AdjustmentEnabled is true.

public Texture AdjustmentColorCorrection { get; set; }

Property Value

Texture

AdjustmentContrast

The global contrast value of the rendered scene (default value is 1). Effective only if AdjustmentEnabled is true.

public float AdjustmentContrast { get; set; }

Property Value

float

AdjustmentEnabled

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.

Note: Adjustments are only supported in the Forward+ and Mobile rendering methods, not Compatibility.

public bool AdjustmentEnabled { get; set; }

Property Value

bool

AdjustmentSaturation

The global color saturation value of the rendered scene (default value is 1). Effective only if AdjustmentEnabled is true.

public float AdjustmentSaturation { get; set; }

Property Value

float

AmbientLightColor

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

public Color AmbientLightColor { get; set; }

Property Value

Color

AmbientLightEnergy

The ambient light's energy. The higher the value, the stronger the light. Only effective if AmbientLightSkyContribution is lower than 1.0 (exclusive).

public float AmbientLightEnergy { get; set; }

Property Value

float

AmbientLightSkyContribution

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: AmbientLightSkyContribution is internally clamped between 0.0 and 1.0 (inclusive).

public float AmbientLightSkyContribution { get; set; }

Property Value

float

AmbientLightSource

The ambient light source to use for rendering materials and global illumination.

public Environment.AmbientSource AmbientLightSource { get; set; }

Property Value

Environment.AmbientSource

BackgroundCameraFeedId

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

public int BackgroundCameraFeedId { get; set; }

Property Value

int

BackgroundCanvasMaxLayer

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

public int BackgroundCanvasMaxLayer { get; set; }

Property Value

int

BackgroundColor

The Color displayed for clear areas of the scene. Only effective when using the Color background mode.

public Color BackgroundColor { get; set; }

Property Value

Color

BackgroundEnergyMultiplier

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

public float BackgroundEnergyMultiplier { get; set; }

Property Value

float

BackgroundIntensity

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 float BackgroundIntensity { get; set; }

Property Value

float

BackgroundMode

The background mode. See Environment.BGMode for possible values.

public Environment.BGMode BackgroundMode { get; set; }

Property Value

Environment.BGMode

FogAerialPerspective

If set above 0.0 (exclusive), blends between the fog's color and the color of the background Sky. This has a small performance cost when set above 0.0. Must have BackgroundMode set to 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.

public float FogAerialPerspective { get; set; }

Property Value

float

FogDensity

The exponential fog density to use. Higher values result in a more dense fog. Fog rendering is exponential as in real life.

public float FogDensity { get; set; }

Property Value

float

FogEnabled

If true, fog effects are enabled.

public bool FogEnabled { get; set; }

Property Value

bool

FogHeight

The height at which the height fog effect begins.

public float FogHeight { get; set; }

Property Value

float

FogHeightDensity

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

public float FogHeightDensity { get; set; }

Property Value

float

FogLightColor

The fog's color.

public Color FogLightColor { get; set; }

Property Value

Color

FogLightEnergy

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

public float FogLightEnergy { get; set; }

Property Value

float

FogSkyAffect

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: FogSkyAffect has no visual effect if FogAerialPerspective is 1.0.

public float FogSkyAffect { get; set; }

Property Value

float

FogSunScatter

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 float FogSunScatter { get; set; }

Property Value

float

GlowBlendMode

The glow blending mode.

public Environment.GlowBlendModeEnum GlowBlendMode { get; set; }

Property Value

Environment.GlowBlendModeEnum

GlowBloom

The bloom's intensity. If set to a value higher than 0, this will make glow visible in areas darker than the GlowHdrThreshold.

public float GlowBloom { get; set; }

Property Value

float

GlowEnabled

If true, the glow effect is enabled.

Note: Glow is only supported in the Forward+ and Mobile rendering methods, not Compatibility. When using the Mobile rendering method, glow will look different due to the lower dynamic range available in the Mobile rendering method.

public bool GlowEnabled { get; set; }

Property Value

bool

GlowHdrLuminanceCap

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

public float GlowHdrLuminanceCap { get; set; }

Property Value

float

GlowHdrScale

The bleed scale of the HDR glow.

public float GlowHdrScale { get; set; }

Property Value

float

GlowHdrThreshold

The lower threshold of the HDR glow. When using the Mobile rendering method (which only supports a lower dynamic range up to 2.0), this may need to be below 1.0 for glow to be visible. A value of 0.9 works well in this case. This value also needs to be decreased below 1.0 when using glow in 2D, as 2D rendering is performed in SDR.

public float GlowHdrThreshold { get; set; }

Property Value

float

GlowIntensity

The overall brightness multiplier of the glow effect. When using the Mobile rendering method (which only supports a lower dynamic range up to 2.0), this should be increased to 1.5 to compensate.

public float GlowIntensity { get; set; }

Property Value

float

GlowMap

The texture that should be used as a glow map to multiply the resulting glow color according to 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).

public Texture GlowMap { get; set; }

Property Value

Texture

GlowMapStrength

How strong of an impact the GlowMap should have on the overall glow effect. A strength of 0.0 means the glow map has no effect on the overall glow effect. A strength of 1.0 means the glow has a full effect on the overall glow effect (and can turn off glow entirely in specific areas of the screen if the glow map has black areas).

public float GlowMapStrength { get; set; }

Property Value

float

GlowMix

When using the MixGlowBlendMode, 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 Replace.

public float GlowMix { get; set; }

Property Value

float

GlowNormalized

If true, glow levels will be normalized so that summed together their intensities equal 1.0.

public bool GlowNormalized { get; set; }

Property Value

bool

GlowStrength

The strength of the glow effect. This applies as the glow is blurred across the screen and increases the distance and intensity of the blur. When using the Mobile rendering method, this should be increased to compensate for the lower dynamic range.

public float GlowStrength { get; set; }

Property Value

float

ReflectedLightSource

The reflected (specular) light source.

public Environment.ReflectionSource ReflectedLightSource { get; set; }

Property Value

Environment.ReflectionSource

SdfgiBounceFeedback

The energy multiplier applied to light every time it bounces from a surface when using SDFGI. Values greater than 0.0 will simulate multiple bounces, resulting in a more realistic appearance. Increasing SdfgiBounceFeedback generally has no performance impact. See also SdfgiEnergy.

Note: Values greater than 0.5 can cause infinite feedback loops and should be avoided in scenes with bright materials.

Note: If SdfgiBounceFeedback is 0.0, indirect lighting will not be represented in reflections as light will only bounce one time.

public float SdfgiBounceFeedback { get; set; }

Property Value

float

SdfgiCascade0Distance

Note: This property is linked to SdfgiMinCellSize and SdfgiMaxDistance. Changing its value will automatically change those properties as well.

public float SdfgiCascade0Distance { get; set; }

Property Value

float

SdfgiCascades

The number of cascades to use for SDFGI (between 1 and 8). A higher number of cascades allows displaying SDFGI further away while preserving detail up close, at the cost of performance. When using SDFGI on small-scale levels, SdfgiCascades can often be decreased between 1 and 4 to improve performance.

public int SdfgiCascades { get; set; }

Property Value

int

SdfgiEnabled

If true, enables signed distance field global illumination for meshes that have their GIMode set to Static. SDFGI is a real-time global illumination technique that works well with procedurally generated and user-built levels, including in situations where geometry is created during gameplay. The signed distance field is automatically generated around the camera as it moves. Dynamic lights are supported, but dynamic occluders and emissive surfaces are not.

Note: SDFGI is only supported in the Forward+ rendering method, not Mobile or Compatibility.

Performance: SDFGI is relatively demanding on the GPU and is not suited to low-end hardware such as integrated graphics (consider LightmapGI instead). To improve SDFGI performance, enable ProjectSettings.rendering/global_illumination/gi/use_half_resolution in the Project Settings.

Note: Meshes should have sufficiently thick walls to avoid light leaks (avoid one-sided walls). For interior levels, enclose your level geometry in a sufficiently large box and bridge the loops to close the mesh.

public bool SdfgiEnabled { get; set; }

Property Value

bool

SdfgiEnergy

The energy multiplier to use for SDFGI. Higher values will result in brighter indirect lighting and reflections. See also SdfgiBounceFeedback.

public float SdfgiEnergy { get; set; }

Property Value

float

SdfgiMaxDistance

The maximum distance at which SDFGI is visible. Beyond this distance, environment lighting or other sources of GI such as ReflectionProbe will be used as a fallback.

Note: This property is linked to SdfgiMinCellSize and SdfgiCascade0Distance. Changing its value will automatically change those properties as well.

public float SdfgiMaxDistance { get; set; }

Property Value

float

SdfgiMinCellSize

The cell size to use for the closest SDFGI cascade (in 3D units). Lower values allow SDFGI to be more precise up close, at the cost of making SDFGI updates more demanding. This can cause stuttering when the camera moves fast. Higher values allow SDFGI to cover more ground, while also reducing the performance impact of SDFGI updates.

Note: This property is linked to SdfgiMaxDistance and SdfgiCascade0Distance. Changing its value will automatically change those properties as well.

public float SdfgiMinCellSize { get; set; }

Property Value

float

SdfgiNormalBias

The normal bias to use for SDFGI probes. Increasing this value can reduce visible streaking artifacts on sloped surfaces, at the cost of increased light leaking.

public float SdfgiNormalBias { get; set; }

Property Value

float

SdfgiProbeBias

The constant bias to use for SDFGI probes. Increasing this value can reduce visible streaking artifacts on sloped surfaces, at the cost of increased light leaking.

public float SdfgiProbeBias { get; set; }

Property Value

float

SdfgiReadSkyLight

If true, SDFGI takes the environment lighting into account. This should be set to false for interior scenes.

public bool SdfgiReadSkyLight { get; set; }

Property Value

bool

SdfgiUseOcclusion

If true, SDFGI uses an occlusion detection approach to reduce light leaking. Occlusion may however introduce dark blotches in certain spots, which may be undesired in mostly outdoor scenes. SdfgiUseOcclusion has a performance impact and should only be enabled when needed.

public bool SdfgiUseOcclusion { get; set; }

Property Value

bool

SdfgiYScale

The Y scale to use for SDFGI cells. Lower values will result in SDFGI cells being packed together more closely on the Y axis. This is used to balance between quality and covering a lot of vertical ground. SdfgiYScale should be set depending on how vertical your scene is (and how fast your camera may move on the Y axis).

public Environment.SdfgiyScale SdfgiYScale { get; set; }

Property Value

Environment.SdfgiyScale

Sky

The Sky resource used for this Environment.

public Sky Sky { get; set; }

Property Value

Sky

SkyCustomFov

If set to a value greater than 0.0, overrides the field of view to use for sky rendering. If set to 0.0, the same FOV as the current Camera3D is used for sky rendering.

public float SkyCustomFov { get; set; }

Property Value

float

SkyRotation

The rotation to use for sky rendering.

public Vector3 SkyRotation { get; set; }

Property Value

Vector3

SsaoAOChannelAffect

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 SsaoAOChannelAffect { get; set; }

Property Value

float

SsaoDetail

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 float SsaoDetail { get; set; }

Property Value

float

SsaoEnabled

If true, the screen-space ambient occlusion effect is enabled. This darkens objects' corners and cavities to simulate ambient light not reaching the entire object as in real life. This works well for small, dynamic objects, but baked lighting or ambient occlusion textures will do a better job at displaying ambient occlusion on large static objects. Godot uses a form of SSAO called Adaptive Screen Space Ambient Occlusion which is itself a form of Horizon Based Ambient Occlusion.

Note: SSAO is only supported in the Forward+ rendering method, not Mobile or Compatibility.

public bool SsaoEnabled { get; set; }

Property Value

bool

SsaoHorizon

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 SsaoHorizon { get; set; }

Property Value

float

SsaoIntensity

The primary screen-space ambient occlusion intensity. Acts as a multiplier for the screen-space ambient occlusion effect. A higher value results in darker occlusion.

public float SsaoIntensity { get; set; }

Property Value

float

SsaoLightAffect

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 SsaoLightAffect { get; set; }

Property Value

float

SsaoPower

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

public float SsaoPower { get; set; }

Property Value

float

SsaoRadius

The distance at which objects can occlude each other when calculating screen-space ambient occlusion. Higher values will result in occlusion over a greater distance at the cost of performance and quality.

public float SsaoRadius { get; set; }

Property Value

float

SsaoSharpness

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 float SsaoSharpness { get; set; }

Property Value

float

SsilEnabled

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 LightIndirectEnergy.

Note: SSIL is only supported in the Forward+ rendering method, not Mobile or Compatibility.

public bool SsilEnabled { get; set; }

Property Value

bool

SsilIntensity

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

public float SsilIntensity { get; set; }

Property Value

float

SsilNormalRejection

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 SsilNormalRejection { get; set; }

Property Value

float

SsilRadius

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 SsilRadius { get; set; }

Property Value

float

SsilSharpness

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 SsilSharpness { get; set; }

Property Value

float

SsrDepthTolerance

The depth tolerance for screen-space reflections.

public float SsrDepthTolerance { get; set; }

Property Value

float

SsrEnabled

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.

public bool SsrEnabled { get; set; }

Property Value

bool

SsrFadeIn

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 SsrFadeIn { get; set; }

Property Value

float

SsrFadeOut

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 float SsrFadeOut { get; set; }

Property Value

float

SsrMaxSteps

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

public int SsrMaxSteps { get; set; }

Property Value

int

TonemapExposure

The default exposure used for tonemapping. Higher values result in a brighter image. See also TonemapWhite.

public float TonemapExposure { get; set; }

Property Value

float

TonemapMode

The tonemapping mode to use. Tonemapping is the process that "converts" HDR values to be suitable for rendering on a LDR display. (Godot doesn't support rendering on HDR displays yet.)

public Environment.ToneMapper TonemapMode { get; set; }

Property Value

Environment.ToneMapper

TonemapWhite

The white reference value for tonemapping (also called "whitepoint"). Higher values can make highlights look less blown out, and will also slightly darken the whole scene as a result. Only effective if the TonemapMode isn't set to Linear. See also TonemapExposure.

public float TonemapWhite { get; set; }

Property Value

float

VolumetricFogAlbedo

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 Color VolumetricFogAlbedo { get; set; }

Property Value

Color

VolumetricFogAmbientInject

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. VolumetricFogAmbientInject has a small performance cost when set above 0.0.

Note: This has no visible effect if VolumetricFogDensity is 0.0 or if VolumetricFogAlbedo is a fully black color.

public float VolumetricFogAmbientInject { get; set; }

Property Value

float

VolumetricFogAnisotropy

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 VolumetricFogAnisotropy { get; set; }

Property Value

float

VolumetricFogDensity

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 VolumetricFogDensity to the lowest non-zero value (0.0001) then increase lights' LightVolumetricFogEnergy to values between 10000 and 100000 to compensate for the very low density.

public float VolumetricFogDensity { get; set; }

Property Value

float

VolumetricFogDetailSpread

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 float VolumetricFogDetailSpread { get; set; }

Property Value

float

VolumetricFogEmission

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 Color VolumetricFogEmission { get; set; }

Property Value

Color

VolumetricFogEmissionEnergy

The brightness of the emitted light from the volumetric fog.

public float VolumetricFogEmissionEnergy { get; set; }

Property Value

float

VolumetricFogEnabled

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 bool VolumetricFogEnabled { get; set; }

Property Value

bool

VolumetricFogGIInject

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. VolumetricFogGIInject has a small performance cost when set above 0.0.

Note: This has no visible effect if VolumetricFogDensity is 0.0 or if VolumetricFogAlbedo is a fully black color.

Note: Only VoxelGI and SDFGI (SdfgiEnabled) are taken into account when using VolumetricFogGIInject. Global illumination from LightmapGI, ReflectionProbe and SSIL (see SsilEnabled) will be ignored by volumetric fog.

public float VolumetricFogGIInject { get; set; }

Property Value

float

VolumetricFogLength

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 VolumetricFogLength { get; set; }

Property Value

float

VolumetricFogSkyAffect

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: VolumetricFogSkyAffect also affects FogVolumes, even if VolumetricFogDensity is 0.0. If you notice FogVolumes are disappearing when looking towards the sky, set VolumetricFogSkyAffect to 1.0.

public float VolumetricFogSkyAffect { get; set; }

Property Value

float

VolumetricFogTemporalReprojectionAmount

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 float VolumetricFogTemporalReprojectionAmount { get; set; }

Property Value

float

VolumetricFogTemporalReprojectionEnabled

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 LightVolumetricFogEnergy set to 0.0 to avoid ghosting.

public bool VolumetricFogTemporalReprojectionEnabled { get; set; }

Property Value

bool

Methods

GetGlowLevel(int)

Returns the intensity of the glow level idx.

public float GetGlowLevel(int idx)

Parameters

idx int

Returns

float

HasGodotClassMethod(in godot_string_name)

Check if the type contains a method with the given name. This method is used by Godot to check if a method exists before invoking it. Do not call or override this method.

protected override bool HasGodotClassMethod(in godot_string_name method)

Parameters

method godot_string_name

Name of the method to check for.

Returns

bool

HasGodotClassSignal(in godot_string_name)

Check if the type contains a signal with the given name. This method is used by Godot to check if a signal exists before raising it. Do not call or override this method.

protected override bool HasGodotClassSignal(in godot_string_name signal)

Parameters

signal godot_string_name

Name of the signal to check for.

Returns

bool

InvokeGodotClassMethod(in godot_string_name, NativeVariantPtrArgs, out godot_variant)

Invokes the method with the given name, using the given arguments. This method is used by Godot to invoke methods from the engine side. Do not call or override this method.

protected override bool InvokeGodotClassMethod(in godot_string_name method, NativeVariantPtrArgs args, out godot_variant ret)

Parameters

method godot_string_name

Name of the method to invoke.

args NativeVariantPtrArgs

Arguments to use with the invoked method.

ret godot_variant

Value returned by the invoked method.

Returns

bool

SetGlowLevel(int, float)

Sets the intensity of the glow level idx. A value above 0.0 enables the level. Each level relies on the previous level. This means that enabling higher glow levels will slow down the glow effect rendering, even if previous levels aren't enabled.

public void SetGlowLevel(int idx, float intensity)

Parameters

idx int
intensity float
Edit this page