LightmapGI

public float Bias { get; set; }

The bias to use when computing shadows. Increasing LightmapGI.Bias can fix shadow acne on the resulting baked lightmap, but can introduce peter-panning (shadows not connecting to their casters). Real-time Light3D shadows are not affected by this LightmapGI.Bias property.

public float BounceIndirectEnergy { get; set; }

The energy multiplier for each bounce. Higher values will make indirect lighting brighter. A value of 1.0 represents physically accurate behavior, but higher values can be used to make indirect lighting propagate more visibly when using a low number of bounces. This can be used to speed up bake times by lowering the number of LightmapGI.Bounces then increasing LightmapGI.BounceIndirectEnergy. Note: LightmapGI.BounceIndirectEnergy only has an effect if LightmapGI.Bounces is set to a value greater than or equal to 1.

public int Bounces { get; set; }

Number of light bounces that are taken into account during baking. Higher values result in brighter, more realistic lighting, at the cost of longer bake times. If set to 0, only environment lighting, direct light and emissive lighting is baked.

public CameraAttributes CameraAttributes { get; set; }

The CameraAttributes resource that specifies exposure levels to bake at. Auto-exposure and non exposure properties will be ignored. Exposure settings should be used to reduce the dynamic range present when baking. If exposure is too high, the LightmapGI will have banding artifacts or may have over-exposure artifacts.

public int DenoiserRange { get; set; }

The distance in pixels from which the denoiser samples. Lower values preserve more details, but may give blotchy results if the lightmap quality is not high enough. Only effective if LightmapGI.UseDenoiser is true and ProjectSettings.rendering/lightmapping/denoising/denoiser is set to JNLM.

public float DenoiserStrength { get; set; }

The strength of denoising step applied to the generated lightmaps. Only effective if LightmapGI.UseDenoiser is true and ProjectSettings.rendering/lightmapping/denoising/denoiser is set to JNLM.

public bool Directional { get; set; }

If true, bakes lightmaps to contain directional information as spherical harmonics. This results in more realistic lighting appearance, especially with normal mapped materials and for lights that have their direct light baked (Light3D.LightBakeMode set to Light3D.BakeMode.Static and with Light3D.EditorOnly set to false). The directional information is also used to provide rough reflections for static and dynamic objects. This has a small run-time performance cost as the shader has to perform more work to interpret the direction information from the lightmap. Directional lightmaps also take longer to bake and result in larger file sizes. Note: The property's name has no relationship with DirectionalLight3D. LightmapGI.Directional works with all light types.

public Color EnvironmentCustomColor { get; set; }

The color to use for environment lighting. Only effective if LightmapGI.EnvironmentMode is LightmapGI.EnvironmentModeEnum.CustomColor.

public float EnvironmentCustomEnergy { get; set; }

The color multiplier to use for environment lighting. Only effective if LightmapGI.EnvironmentMode is LightmapGI.EnvironmentModeEnum.CustomColor.

public Sky EnvironmentCustomSky { get; set; }

The sky to use as a source of environment lighting. Only effective if LightmapGI.EnvironmentMode is LightmapGI.EnvironmentModeEnum.CustomSky.

public LightmapGI.EnvironmentModeEnum EnvironmentMode { get; set; }

The environment mode to use when baking lightmaps.

public LightmapGI.GenerateProbes GenerateProbesSubdiv { get; set; }

The level of subdivision to use when automatically generating LightmapProbes for dynamic object lighting. Higher values result in more accurate indirect lighting on dynamic objects, at the cost of longer bake times and larger file sizes. Note: Automatically generated LightmapProbes are not visible as nodes in the Scene tree dock, and cannot be modified this way after they are generated. Note: Regardless of LightmapGI.GenerateProbesSubdiv, direct lighting on dynamic objects is always applied using Light3D nodes in real-time.

public bool Interior { get; set; }

If true, ignore environment lighting when baking lightmaps.

public LightmapGIData LightData { get; set; }

The LightmapGIData associated to this LightmapGI node. This resource is automatically created after baking, and is not meant to be created manually.

public int MaxTextureSize { get; set; }

The maximum texture size for the generated texture atlas. Higher values will result in fewer slices being generated, but may not work on all hardware as a result of hardware limitations on texture sizes. Leave LightmapGI.MaxTextureSize at its default value of 16384 if unsure.

public LightmapGI.BakeQuality Quality { get; set; }

The quality preset to use when baking lightmaps. This affects bake times, but output file sizes remain mostly identical across quality levels. To further speed up bake times, decrease LightmapGI.Bounces, disable LightmapGI.UseDenoiser and/or decrease LightmapGI.TexelScale. To further increase quality, enable LightmapGI.Supersampling and/or increase LightmapGI.TexelScale.

public LightmapGIData.ShadowmaskMode ShadowmaskMode { get; set; }

The shadowmasking policy to use for directional shadows on static objects that are baked with this LightmapGI instance. Shadowmasking allows DirectionalLight3D nodes to cast shadows even outside the range defined by their DirectionalLight3D.DirectionalShadowMaxDistance property. This is done by baking a texture that contains a shadowmap for the directional light, then using this texture according to the current shadowmask mode. Note: The shadowmask texture is only created if LightmapGI.ShadowmaskMode is not LightmapGIData.ShadowmaskMode.None. To see a difference, you need to bake lightmaps again after switching from LightmapGIData.ShadowmaskMode.None to any other mode.

public float SpecularIntensity { get; set; }

The strength of the lightmap's approximated specular lobe. This helps make lightmapped scenes look closer to real-time lighting, which is particularly noticeable for lights that use the Light3D.BakeMode.Static bake mode. Only effective if LightmapGI.Directional is true. Note: The lightmap is only able to represent one light direction per texel, which means that the specular direction may appear to be incorrect in certain cases. This can manifest as specular lobes appearing to warp around as the camera moves.

public bool Supersampling { get; set; }

If true, lightmaps are baked with the texel scale multiplied with LightmapGI.SupersamplingFactor and downsampled before saving the lightmap (so the effective texel density is identical to having supersampling disabled). Supersampling provides increased lightmap quality with less noise, smoother shadows and better shadowing of small-scale features in objects. However, it may result in significantly increased bake times and memory usage while baking lightmaps. Padding is automatically adjusted to avoid increasing light leaking.

public float SupersamplingFactor { get; set; }

The factor by which the texel density is multiplied for supersampling. For best results, use an integer value. While fractional values are allowed, they can result in increased light leaking and a blurry lightmap. Higher values may result in better quality, but also increase bake times and memory usage while baking. See LightmapGI.Supersampling for more information.

public float TexelScale { get; set; }

Scales the lightmap texel density of all meshes for the current bake. This is a multiplier that builds upon the existing lightmap texel size defined in each imported 3D scene, along with the per-mesh density multiplier (which is designed to be used when the same mesh is used at different scales). Lower values will result in faster bake times. For example, doubling LightmapGI.TexelScale doubles the lightmap texture resolution for all objects on each axis, so it will quadruple the texel count.

public bool UseDenoiser { get; set; }

If true, uses a GPU-based denoising algorithm on the generated lightmap. This eliminates most noise within the generated lightmap at the cost of longer bake times. File sizes are generally not impacted significantly by the use of a denoiser, although lossless compression may do a better job at compressing a denoised image.

public bool UseTextureForBounces { get; set; }

If true, a texture with the lighting information will be generated to speed up the generation of indirect lighting at the cost of some accuracy. The geometry might exhibit extra light leak artifacts when using low resolution lightmaps or UVs that stretch the lightmap significantly across surfaces. Leave LightmapGI.UseTextureForBounces at its default value of true if unsure. Note: LightmapGI.UseTextureForBounces only has an effect if LightmapGI.Bounces is set to a value greater than or equal to 1.