typescript-to-gdscript 0.1.0

package/typings/classes/Light2D.d.ts

@@ -0,0 +1,109 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Casts light in a 2D environment. */
+declare class Light2D extends Node2D {
+  /** The Light2D's blend mode. */
+  blend_mode: int;
+  /** The Light2D's {@link Color}. */
+  color: Color;
+  /** If `true`, Light2D will only appear when editing the scene. */
+  editor_only: boolean;
+  /** If `true`, Light2D will emit light. */
+  enabled: boolean;
+  /** The Light2D's energy value. The larger the value, the stronger the light. */
+  energy: float;
+  /**
+   * The layer mask. Only objects with a matching {@link CanvasItem.light_mask} will be affected by the Light2D. See also {@link shadow_item_cull_mask}, which affects which objects can cast shadows.
+   * **Note:** {@link range_item_cull_mask} is ignored by {@link DirectionalLight2D}, which will always light a 2D node regardless of the 2D node's {@link CanvasItem.light_mask}.
+   */
+  range_item_cull_mask: int;
+  /** Maximum layer value of objects that are affected by the Light2D. */
+  range_layer_max: int;
+  /** Minimum layer value of objects that are affected by the Light2D. */
+  range_layer_min: int;
+  /** Maximum `z` value of objects that are affected by the Light2D. */
+  range_z_max: int;
+  /** Minimum `z` value of objects that are affected by the Light2D. */
+  range_z_min: int;
+  /** {@link Color} of shadows cast by the Light2D. */
+  shadow_color: Color;
+  /** If `true`, the Light2D will cast shadows. */
+  shadow_enabled: boolean;
+  /** Shadow filter type. */
+  shadow_filter: int;
+  /**
+   * Smoothing value for shadows. Higher values will result in softer shadows, at the cost of visible streaks that can appear in shadow rendering. {@link shadow_filter_smooth} only has an effect if {@link shadow_filter} is {@link SHADOW_FILTER_PCF5} or {@link SHADOW_FILTER_PCF13}.
+   */
+  shadow_filter_smooth: float;
+  /**
+   * The shadow mask. Used with {@link LightOccluder2D} to cast shadows. Only occluders with a matching {@link CanvasItem.light_mask} will cast shadows. See also {@link range_item_cull_mask}, which affects which objects can *receive* the light.
+   */
+  shadow_item_cull_mask: int;
+  set_blend_mode(value: int): void;
+  get_blend_mode(): int;
+  set_color(value: Color): void;
+  get_color(): Color;
+  set_editor_only(value: boolean): void;
+  is_editor_only(): boolean;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_energy(value: float): void;
+  get_energy(): float;
+  set_item_cull_mask(value: int): void;
+  get_item_cull_mask(): int;
+  set_layer_range_max(value: int): void;
+  get_layer_range_max(): int;
+  set_layer_range_min(value: int): void;
+  get_layer_range_min(): int;
+  set_z_range_max(value: int): void;
+  get_z_range_max(): int;
+  set_z_range_min(value: int): void;
+  get_z_range_min(): int;
+  set_shadow_color(value: Color): void;
+  get_shadow_color(): Color;
+  set_shadow_enabled(value: boolean): void;
+  is_shadow_enabled(): boolean;
+  set_shadow_filter(value: int): void;
+  get_shadow_filter(): int;
+  set_shadow_smooth(value: float): void;
+  get_shadow_smooth(): float;
+  set_item_shadow_cull_mask(value: int): void;
+  get_item_shadow_cull_mask(): int;
+
+  /**
+   * Returns the light's height, which is used in 2D normal mapping. See {@link PointLight2D.height} and {@link DirectionalLight2D.height}.
+   */
+  get_height(): float;
+  /**
+   * Sets the light's height, which is used in 2D normal mapping. See {@link PointLight2D.height} and {@link DirectionalLight2D.height}.
+   */
+  set_height(height: float): void;
+
+  // enum ShadowFilter
+  /**
+   * No filter applies to the shadow map. This provides hard shadow edges and is the fastest to render. See {@link shadow_filter}.
+   */
+  static readonly SHADOW_FILTER_NONE: int;
+  /**
+   * Percentage closer filtering (5 samples) applies to the shadow map. This is slower compared to hard shadow rendering. See {@link shadow_filter}.
+   */
+  static readonly SHADOW_FILTER_PCF5: int;
+  /**
+   * Percentage closer filtering (13 samples) applies to the shadow map. This is the slowest shadow filtering mode, and should be used sparingly. See {@link shadow_filter}.
+   */
+  static readonly SHADOW_FILTER_PCF13: int;
+  // enum BlendMode
+  /**
+   * Adds the value of pixels corresponding to the Light2D to the values of pixels under it. This is the common behavior of a light.
+   */
+  static readonly BLEND_MODE_ADD: int;
+  /**
+   * Subtracts the value of pixels corresponding to the Light2D to the values of pixels under it, resulting in inversed light effect.
+   */
+  static readonly BLEND_MODE_SUB: int;
+  /**
+   * Mix the value of pixels corresponding to the Light2D to the values of pixels under it by linear interpolation.
+   */
+  static readonly BLEND_MODE_MIX: int;
+}

package/typings/classes/Light3D.d.ts

@@ -0,0 +1,227 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides a base class for different kinds of light nodes. */
+declare class Light3D extends VisualInstance3D {
+  /**
+   * The distance from the camera at which the light begins to fade away (in 3D units).
+   * **Note:** Only effective for {@link OmniLight3D} and {@link SpotLight3D}.
+   */
+  distance_fade_begin: float;
+  /**
+   * If `true`, the light will smoothly fade away when far from the active {@link Camera3D} starting at {@link distance_fade_begin}. This acts as a form of level of detail (LOD). The light will fade out over {@link distance_fade_begin} + {@link distance_fade_length}, after which it will be culled and not sent to the shader at all. Use this to reduce the number of active lights in a scene and thus improve performance.
+   * **Note:** Only effective for {@link OmniLight3D} and {@link SpotLight3D}.
+   */
+  distance_fade_enabled: boolean;
+  /**
+   * Distance over which the light and its shadow fades. The light's energy and shadow's opacity is progressively reduced over this distance and is completely invisible at the end.
+   * **Note:** Only effective for {@link OmniLight3D} and {@link SpotLight3D}.
+   */
+  distance_fade_length: float;
+  /**
+   * The distance from the camera at which the light's shadow cuts off (in 3D units). Set this to a value lower than {@link distance_fade_begin} + {@link distance_fade_length} to further improve performance, as shadow rendering is often more expensive than light rendering itself.
+   * **Note:** Only effective for {@link OmniLight3D} and {@link SpotLight3D}, and only when {@link shadow_enabled} is `true`.
+   */
+  distance_fade_shadow: float;
+  /**
+   * If `true`, the light only appears in the editor and will not be visible at runtime. If `true`, the light will never be baked in {@link LightmapGI} regardless of its {@link light_bake_mode}.
+   */
+  editor_only: boolean;
+  /**
+   * The light's angular size in degrees. Increasing this will make shadows softer at greater distances (also called percentage-closer soft shadows, or PCSS). Only available for {@link DirectionalLight3D}s. For reference, the Sun from the Earth is approximately `0.5`. Increasing this value above `0.0` for lights with shadows enabled will have a noticeable performance cost due to PCSS.
+   * **Note:** {@link light_angular_distance} is not affected by {@link Node3D.scale} (the light's scale or its parent's scale).
+   * **Note:** PCSS for directional lights is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+   */
+  light_angular_distance: float;
+  /**
+   * The light's bake mode. This will affect the global illumination techniques that have an effect on the light's rendering.
+   * **Note:** Meshes' global illumination mode will also affect the global illumination rendering. See {@link GeometryInstance3D.gi_mode}.
+   */
+  light_bake_mode: int;
+  /**
+   * The light's color in nonlinear sRGB encoding. An *overbright* color can be used to achieve a result equivalent to increasing the light's {@link light_energy}.
+   */
+  light_color: Color;
+  /**
+   * The light will affect objects in the selected layers.
+   * **Note:** The light cull mask is ignored by {@link VoxelGI}, SDFGI, {@link LightmapGI}, and volumetric fog. These will always render lights in a way that ignores the cull mask. See also {@link VisualInstance3D.layers}.
+   */
+  light_cull_mask: int;
+  /**
+   * The light's strength multiplier (this is not a physical unit). For {@link OmniLight3D} and {@link SpotLight3D}, changing this value will only change the light color's intensity, not the light's radius.
+   */
+  light_energy: float;
+  /**
+   * Secondary multiplier used with indirect light (light bounces). Used with {@link VoxelGI} and SDFGI (see {@link Environment.sdfgi_enabled}).
+   * **Note:** This property is ignored if {@link light_energy} is equal to `0.0`, as the light won't be present at all in the GI shader.
+   */
+  light_indirect_energy: float;
+  /**
+   * Used by positional lights ({@link OmniLight3D} and {@link SpotLight3D}) when {@link ProjectSettings.rendering/lights_and_shadows/use_physical_light_units} is `true`. Sets the intensity of the light source measured in Lumens. Lumens are a measure of luminous flux, which is the total amount of visible light emitted by a light source per unit of time.
+   * For {@link SpotLight3D}s, we assume that the area outside the visible cone is surrounded by a perfect light absorbing material. Accordingly, the apparent brightness of the cone area does not change as the cone increases and decreases in size.
+   * A typical household lightbulb can range from around 600 lumens to 1,200 lumens, a candle is about 13 lumens, while a streetlight can be approximately 60,000 lumens.
+   */
+  light_intensity_lumens: float;
+  /**
+   * Used by {@link DirectionalLight3D}s when {@link ProjectSettings.rendering/lights_and_shadows/use_physical_light_units} is `true`. Sets the intensity of the light source measured in Lux. Lux is a measure of luminous flux per unit area, it is equal to one lumen per square meter. Lux is the measure of how much light hits a surface at a given time.
+   * On a clear sunny day a surface in direct sunlight may be approximately 100,000 lux, a typical room in a home may be approximately 50 lux, while the moonlit ground may be approximately 0.1 lux.
+   */
+  light_intensity_lux: float;
+  /** If `true`, the light's effect is reversed, darkening areas and casting bright shadows. */
+  light_negative: boolean;
+  /**
+   * {@link Texture2D} projected by light. {@link shadow_enabled} must be on for the projector to work. Light projectors make the light appear as if it is shining through a colored but transparent object, almost like light shining through stained-glass.
+   * **Note:** Unlike {@link BaseMaterial3D} whose filter mode can be adjusted on a per-material basis, the filter mode for light projector textures is set globally with {@link ProjectSettings.rendering/textures/light_projectors/filter}.
+   * **Note:** Light projector textures are only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+   */
+  light_projector: Texture2D | null;
+  /**
+   * The size of the light in Godot units. Only available for {@link OmniLight3D}s and {@link SpotLight3D}s. Increasing this value will make the light fade out slower and shadows appear blurrier (also called percentage-closer soft shadows, or PCSS). This can be used to simulate area lights to an extent. Increasing this value above `0.0` for lights with shadows enabled will have a noticeable performance cost due to PCSS.
+   * **Note:** {@link light_size} is not affected by {@link Node3D.scale} (the light's scale or its parent's scale).
+   * **Note:** PCSS for positional lights is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+   */
+  light_size: float;
+  /**
+   * The intensity of the specular blob in objects affected by the light. At `0`, the light becomes a pure diffuse light. When not baking emission, this can be used to avoid unrealistic reflections when placing lights above an emissive surface.
+   */
+  light_specular: float;
+  /**
+   * Sets the color temperature of the light source, measured in Kelvin. This is used to calculate a correlated color temperature which tints the {@link light_color}.
+   * The sun on a cloudy day is approximately 6500 Kelvin, on a clear day it is between 5500 to 6000 Kelvin, and on a clear day at sunrise or sunset it ranges to around 1850 Kelvin.
+   */
+  light_temperature: float;
+  /**
+   * Secondary multiplier multiplied with {@link light_energy} then used with the {@link Environment}'s volumetric fog (if enabled). If set to `0.0`, computing volumetric fog will be skipped for this light, which can improve performance for large amounts of lights when volumetric fog is enabled.
+   * **Note:** To prevent short-lived dynamic light effects from poorly interacting with volumetric fog, lights used in those effects should have {@link light_volumetric_fog_energy} set to `0.0` unless {@link Environment.volumetric_fog_temporal_reprojection_enabled} is disabled (or unless the reprojection amount is significantly lowered).
+   */
+  light_volumetric_fog_energy: float;
+  /**
+   * Used to adjust shadow appearance. Too small a value results in self-shadowing ("shadow acne"), while too large a value causes shadows to separate from casters ("peter-panning"). Adjust as needed.
+   */
+  shadow_bias: float;
+  /**
+   * Blurs the edges of the shadow. Can be used to hide pixel artifacts in low-resolution shadow maps. A high value can impact performance, make shadows appear grainy and can cause other unwanted artifacts. Try to keep as near default as possible.
+   */
+  shadow_blur: float;
+  /** The light will only cast shadows using objects in the selected layers. */
+  shadow_caster_mask: int;
+  /**
+   * If `true`, the light will cast real-time shadows. This has a significant performance cost. Only enable shadow rendering when it makes a noticeable difference in the scene's appearance, and consider using {@link distance_fade_enabled} to hide the light when far away from the {@link Camera3D}.
+   */
+  shadow_enabled: boolean;
+  /**
+   * Offsets the lookup into the shadow map by the object's normal. This can be used to reduce self-shadowing artifacts without using {@link shadow_bias}. In practice, this value should be tweaked along with {@link shadow_bias} to reduce artifacts as much as possible.
+   */
+  shadow_normal_bias: float;
+  /**
+   * The opacity to use when rendering the light's shadow map. Values lower than `1.0` make the light appear through shadows. This can be used to fake global illumination at a low performance cost.
+   */
+  shadow_opacity: float;
+  /**
+   * If `true`, reverses the backface culling of the mesh. This can be useful when you have a flat mesh that has a light behind it. If you need to cast a shadow on both sides of the mesh, set the mesh to use double-sided shadows with {@link GeometryInstance3D.SHADOW_CASTING_SETTING_DOUBLE_SIDED}.
+   */
+  shadow_reverse_cull_face: boolean;
+  shadow_transmittance_bias: float;
+  set_distance_fade_begin(value: float): void;
+  get_distance_fade_begin(): float;
+  set_enable_distance_fade(value: boolean): void;
+  is_distance_fade_enabled(): boolean;
+  set_distance_fade_length(value: float): void;
+  get_distance_fade_length(): float;
+  set_distance_fade_shadow(value: float): void;
+  get_distance_fade_shadow(): float;
+  set_editor_only(value: boolean): void;
+  is_editor_only(): boolean;
+  set_bake_mode(value: int): void;
+  get_bake_mode(): int;
+  set_color(value: Color): void;
+  get_color(): Color;
+  set_cull_mask(value: int): void;
+  get_cull_mask(): int;
+  set_negative(value: boolean): void;
+  is_negative(): boolean;
+  set_projector(value: Texture2D | null): void;
+  get_projector(): Texture2D | null;
+  set_temperature(value: float): void;
+  get_temperature(): float;
+  set_shadow_caster_mask(value: int): void;
+  get_shadow_caster_mask(): int;
+  set_shadow(value: boolean): void;
+  has_shadow(): boolean;
+  set_shadow_reverse_cull_face(value: boolean): void;
+  get_shadow_reverse_cull_face(): boolean;
+
+  /**
+   * Returns the {@link Color} of an idealized blackbody at the given {@link light_temperature}. This value is calculated internally based on the {@link light_temperature}. This {@link Color} is multiplied by {@link light_color} before being sent to the {@link RenderingServer}.
+   */
+  get_correlated_color(): Color;
+  /** Returns the value of the specified {@link Light3D.Param} parameter. */
+  get_param(param: int): float;
+  /** Sets the value of the specified {@link Light3D.Param} parameter. */
+  set_param(param: int, value: float): void;
+
+  // enum Param
+  /** Constant for accessing {@link light_energy}. */
+  static readonly PARAM_ENERGY: int;
+  /** Constant for accessing {@link light_indirect_energy}. */
+  static readonly PARAM_INDIRECT_ENERGY: int;
+  /** Constant for accessing {@link light_volumetric_fog_energy}. */
+  static readonly PARAM_VOLUMETRIC_FOG_ENERGY: int;
+  /** Constant for accessing {@link light_specular}. */
+  static readonly PARAM_SPECULAR: int;
+  /** Constant for accessing {@link OmniLight3D.omni_range} or {@link SpotLight3D.spot_range}. */
+  static readonly PARAM_RANGE: int;
+  /** Constant for accessing {@link light_size}. */
+  static readonly PARAM_SIZE: int;
+  /**
+   * Constant for accessing {@link OmniLight3D.omni_attenuation} or {@link SpotLight3D.spot_attenuation}.
+   */
+  static readonly PARAM_ATTENUATION: int;
+  /** Constant for accessing {@link SpotLight3D.spot_angle}. */
+  static readonly PARAM_SPOT_ANGLE: int;
+  /** Constant for accessing {@link SpotLight3D.spot_angle_attenuation}. */
+  static readonly PARAM_SPOT_ATTENUATION: int;
+  /** Constant for accessing {@link DirectionalLight3D.directional_shadow_max_distance}. */
+  static readonly PARAM_SHADOW_MAX_DISTANCE: int;
+  /** Constant for accessing {@link DirectionalLight3D.directional_shadow_split_1}. */
+  static readonly PARAM_SHADOW_SPLIT_1_OFFSET: int;
+  /** Constant for accessing {@link DirectionalLight3D.directional_shadow_split_2}. */
+  static readonly PARAM_SHADOW_SPLIT_2_OFFSET: int;
+  /** Constant for accessing {@link DirectionalLight3D.directional_shadow_split_3}. */
+  static readonly PARAM_SHADOW_SPLIT_3_OFFSET: int;
+  /** Constant for accessing {@link DirectionalLight3D.directional_shadow_fade_start}. */
+  static readonly PARAM_SHADOW_FADE_START: int;
+  /** Constant for accessing {@link shadow_normal_bias}. */
+  static readonly PARAM_SHADOW_NORMAL_BIAS: int;
+  /** Constant for accessing {@link shadow_bias}. */
+  static readonly PARAM_SHADOW_BIAS: int;
+  /** Constant for accessing {@link DirectionalLight3D.directional_shadow_pancake_size}. */
+  static readonly PARAM_SHADOW_PANCAKE_SIZE: int;
+  /** Constant for accessing {@link shadow_opacity}. */
+  static readonly PARAM_SHADOW_OPACITY: int;
+  /** Constant for accessing {@link shadow_blur}. */
+  static readonly PARAM_SHADOW_BLUR: int;
+  /** Constant for accessing {@link shadow_transmittance_bias}. */
+  static readonly PARAM_TRANSMITTANCE_BIAS: int;
+  /**
+   * Constant for accessing {@link light_intensity_lumens} and {@link light_intensity_lux}. Only used when {@link ProjectSettings.rendering/lights_and_shadows/use_physical_light_units} is `true`.
+   */
+  static readonly PARAM_INTENSITY: int;
+  /** Represents the size of the {@link Param} enum. */
+  static readonly PARAM_MAX: int;
+  // enum BakeMode
+  /**
+   * Light is ignored when baking. This is the fastest mode, but the light will not be taken into account when baking global illumination. This mode should generally be used for dynamic lights that change quickly, as the effect of global illumination is less noticeable on those lights.
+   * **Note:** Hiding a light does *not* affect baking {@link LightmapGI}. Hiding a light will still affect baking {@link VoxelGI} and SDFGI (see {@link Environment.sdfgi_enabled}).
+   */
+  static readonly BAKE_DISABLED: int;
+  /**
+   * Light is taken into account in static baking ({@link VoxelGI}, {@link LightmapGI}, SDFGI ({@link Environment.sdfgi_enabled})). The light can be moved around or modified, but its global illumination will not update in real-time. This is suitable for subtle changes (such as flickering torches), but generally not large changes such as toggling a light on and off.
+   * **Note:** The light is not baked in {@link LightmapGI} if {@link editor_only} is `true`.
+   */
+  static readonly BAKE_STATIC: int;
+  /**
+   * Light is taken into account in dynamic baking ({@link VoxelGI} and SDFGI ({@link Environment.sdfgi_enabled}) only). The light can be moved around or modified with global illumination updating in real-time. The light's global illumination appearance will be slightly different compared to {@link BAKE_STATIC}. This has a greater performance cost compared to {@link BAKE_STATIC}. When using SDFGI, the update speed of dynamic lights is affected by {@link ProjectSettings.rendering/global_illumination/sdfgi/frames_to_update_lights}.
+   */
+  static readonly BAKE_DYNAMIC: int;
+}

package/typings/classes/LightOccluder2D.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Occludes light cast by a Light2D, casting shadows. */
+declare class LightOccluder2D extends Node2D {
+  /** The {@link OccluderPolygon2D} used to compute the shadow. */
+  occluder: OccluderPolygon2D | null;
+  /**
+   * The LightOccluder2D's occluder light mask. The LightOccluder2D will cast shadows only from Light2D(s) that have the same light mask(s).
+   */
+  occluder_light_mask: int;
+  /**
+   * If enabled, the occluder will be part of a real-time generated signed distance field that can be used in custom shaders.
+   */
+  sdf_collision: boolean;
+  set_occluder_polygon(value: OccluderPolygon2D | null): void;
+  get_occluder_polygon(): OccluderPolygon2D | null;
+  set_occluder_light_mask(value: int): void;
+  get_occluder_light_mask(): int;
+  set_as_sdf_collision(value: boolean): void;
+  is_set_as_sdf_collision(): boolean;
+}

package/typings/classes/LightmapGI.d.ts

@@ -0,0 +1,225 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Computes and stores baked lightmaps for fast global illumination. */
+declare class LightmapGI extends VisualInstance3D {
+  /**
+   * The bias to use when computing shadows. Increasing {@link bias} can fix shadow acne on the resulting baked lightmap, but can introduce peter-panning (shadows not connecting to their casters). Real-time {@link Light3D} shadows are not affected by this {@link bias} property.
+   */
+  bias: float;
+  /**
+   * 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 {@link bounces} then increasing {@link bounce_indirect_energy}.
+   * **Note:** {@link bounce_indirect_energy} only has an effect if {@link bounces} is set to a value greater than or equal to `1`.
+   */
+  bounce_indirect_energy: float;
+  /**
+   * 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.
+   */
+  bounces: int;
+  /**
+   * The {@link 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 {@link LightmapGI} will have banding artifacts or may have over-exposure artifacts.
+   */
+  camera_attributes: CameraAttributes | null;
+  /**
+   * 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 {@link use_denoiser} is `true` and {@link ProjectSettings.rendering/lightmapping/denoising/denoiser} is set to JNLM.
+   */
+  denoiser_range: int;
+  /**
+   * The strength of denoising step applied to the generated lightmaps. Only effective if {@link use_denoiser} is `true` and {@link ProjectSettings.rendering/lightmapping/denoising/denoiser} is set to JNLM.
+   */
+  denoiser_strength: float;
+  /**
+   * 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 ({@link Light3D.light_bake_mode} set to {@link Light3D.BAKE_STATIC} and with {@link Light3D.editor_only} 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 {@link DirectionalLight3D}. {@link directional} works with all light types.
+   */
+  directional: boolean;
+  /**
+   * The color to use for environment lighting. Only effective if {@link environment_mode} is {@link ENVIRONMENT_MODE_CUSTOM_COLOR}.
+   */
+  environment_custom_color: Color;
+  /**
+   * The color multiplier to use for environment lighting. Only effective if {@link environment_mode} is {@link ENVIRONMENT_MODE_CUSTOM_COLOR}.
+   */
+  environment_custom_energy: float;
+  /**
+   * The sky to use as a source of environment lighting. Only effective if {@link environment_mode} is {@link ENVIRONMENT_MODE_CUSTOM_SKY}.
+   */
+  environment_custom_sky: Sky | null;
+  /** The environment mode to use when baking lightmaps. */
+  environment_mode: int;
+  /**
+   * The level of subdivision to use when automatically generating {@link LightmapProbe}s 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 {@link LightmapProbe}s are not visible as nodes in the Scene tree dock, and cannot be modified this way after they are generated.
+   * **Note:** Regardless of {@link generate_probes_subdiv}, direct lighting on dynamic objects is always applied using {@link Light3D} nodes in real-time.
+   */
+  generate_probes_subdiv: int;
+  /** If `true`, ignore environment lighting when baking lightmaps. */
+  interior: boolean;
+  /**
+   * The {@link LightmapGIData} associated to this {@link LightmapGI} node. This resource is automatically created after baking, and is not meant to be created manually.
+   */
+  light_data: LightmapGIData | null;
+  /**
+   * 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 {@link max_texture_size} at its default value of `16384` if unsure.
+   */
+  max_texture_size: int;
+  /**
+   * 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 {@link bounces}, disable {@link use_denoiser} and/or decrease {@link texel_scale}.
+   * To further increase quality, enable {@link supersampling} and/or increase {@link texel_scale}.
+   */
+  quality: int;
+  /**
+   * The shadowmasking policy to use for directional shadows on static objects that are baked with this {@link LightmapGI} instance.
+   * Shadowmasking allows {@link DirectionalLight3D} nodes to cast shadows even outside the range defined by their {@link DirectionalLight3D.directional_shadow_max_distance} 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 {@link shadowmask_mode} is not {@link LightmapGIData.SHADOWMASK_MODE_NONE}. To see a difference, you need to bake lightmaps again after switching from {@link LightmapGIData.SHADOWMASK_MODE_NONE} to any other mode.
+   */
+  shadowmask_mode: int;
+  /**
+   * If `true`, lightmaps are baked with the texel scale multiplied with {@link supersampling_factor} 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.
+   */
+  supersampling: boolean;
+  /**
+   * 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 {@link supersampling} for more information.
+   */
+  supersampling_factor: float;
+  /**
+   * 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 {@link texel_scale} doubles the lightmap texture resolution for all objects *on each axis*, so it will *quadruple* the texel count.
+   */
+  texel_scale: float;
+  /**
+   * 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.
+   */
+  use_denoiser: boolean;
+  /**
+   * 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 {@link use_texture_for_bounces} at its default value of `true` if unsure.
+   * **Note:** {@link use_texture_for_bounces} only has an effect if {@link bounces} is set to a value greater than or equal to `1`.
+   */
+  use_texture_for_bounces: boolean;
+  set_bias(value: float): void;
+  get_bias(): float;
+  set_bounce_indirect_energy(value: float): void;
+  get_bounce_indirect_energy(): float;
+  set_bounces(value: int): void;
+  get_bounces(): int;
+  set_camera_attributes(value: CameraAttributes | null): void;
+  get_camera_attributes(): CameraAttributes | null;
+  set_denoiser_range(value: int): void;
+  get_denoiser_range(): int;
+  set_denoiser_strength(value: float): void;
+  get_denoiser_strength(): float;
+  set_directional(value: boolean): void;
+  is_directional(): boolean;
+  set_environment_custom_color(value: Color): void;
+  get_environment_custom_color(): Color;
+  set_environment_custom_energy(value: float): void;
+  get_environment_custom_energy(): float;
+  set_environment_custom_sky(value: Sky | null): void;
+  get_environment_custom_sky(): Sky | null;
+  set_environment_mode(value: int): void;
+  get_environment_mode(): int;
+  set_generate_probes(value: int): void;
+  get_generate_probes(): int;
+  set_interior(value: boolean): void;
+  is_interior(): boolean;
+  set_light_data(value: LightmapGIData | null): void;
+  get_light_data(): LightmapGIData | null;
+  set_max_texture_size(value: int): void;
+  get_max_texture_size(): int;
+  set_bake_quality(value: int): void;
+  get_bake_quality(): int;
+  set_shadowmask_mode(value: int): void;
+  get_shadowmask_mode(): int;
+  set_supersampling_enabled(value: boolean): void;
+  is_supersampling_enabled(): boolean;
+  set_supersampling_factor(value: float): void;
+  get_supersampling_factor(): float;
+  set_texel_scale(value: float): void;
+  get_texel_scale(): float;
+  set_use_denoiser(value: boolean): void;
+  is_using_denoiser(): boolean;
+  set_use_texture_for_bounces(value: boolean): void;
+  is_using_texture_for_bounces(): boolean;
+
+  // enum BakeQuality
+  /**
+   * Low bake quality (fastest bake times). The quality of this preset can be adjusted by changing {@link ProjectSettings.rendering/lightmapping/bake_quality/low_quality_ray_count} and {@link ProjectSettings.rendering/lightmapping/bake_quality/low_quality_probe_ray_count}.
+   */
+  static readonly BAKE_QUALITY_LOW: int;
+  /**
+   * Medium bake quality (fast bake times). The quality of this preset can be adjusted by changing {@link ProjectSettings.rendering/lightmapping/bake_quality/medium_quality_ray_count} and {@link ProjectSettings.rendering/lightmapping/bake_quality/medium_quality_probe_ray_count}.
+   */
+  static readonly BAKE_QUALITY_MEDIUM: int;
+  /**
+   * High bake quality (slow bake times). The quality of this preset can be adjusted by changing {@link ProjectSettings.rendering/lightmapping/bake_quality/high_quality_ray_count} and {@link ProjectSettings.rendering/lightmapping/bake_quality/high_quality_probe_ray_count}.
+   */
+  static readonly BAKE_QUALITY_HIGH: int;
+  /**
+   * Highest bake quality (slowest bake times). The quality of this preset can be adjusted by changing {@link ProjectSettings.rendering/lightmapping/bake_quality/ultra_quality_ray_count} and {@link ProjectSettings.rendering/lightmapping/bake_quality/ultra_quality_probe_ray_count}.
+   */
+  static readonly BAKE_QUALITY_ULTRA: int;
+  // enum GenerateProbes
+  /** Don't generate lightmap probes for lighting dynamic objects. */
+  static readonly GENERATE_PROBES_DISABLED: int;
+  /** Lowest level of subdivision (fastest bake times, smallest file sizes). */
+  static readonly GENERATE_PROBES_SUBDIV_4: int;
+  /** Low level of subdivision (fast bake times, small file sizes). */
+  static readonly GENERATE_PROBES_SUBDIV_8: int;
+  /** High level of subdivision (slow bake times, large file sizes). */
+  static readonly GENERATE_PROBES_SUBDIV_16: int;
+  /** Highest level of subdivision (slowest bake times, largest file sizes). */
+  static readonly GENERATE_PROBES_SUBDIV_32: int;
+  // enum BakeError
+  /** Lightmap baking was successful. */
+  static readonly BAKE_ERROR_OK: int;
+  /** Lightmap baking failed because the root node for the edited scene could not be accessed. */
+  static readonly BAKE_ERROR_NO_SCENE_ROOT: int;
+  /** Lightmap baking failed as the lightmap data resource is embedded in a foreign resource. */
+  static readonly BAKE_ERROR_FOREIGN_DATA: int;
+  /** Lightmap baking failed as there is no lightmapper available in this Godot build. */
+  static readonly BAKE_ERROR_NO_LIGHTMAPPER: int;
+  /** Lightmap baking failed as the {@link LightmapGIData} save path isn't configured in the resource. */
+  static readonly BAKE_ERROR_NO_SAVE_PATH: int;
+  /**
+   * Lightmap baking failed as there are no meshes whose {@link GeometryInstance3D.gi_mode} is {@link GeometryInstance3D.GI_MODE_STATIC} and with valid UV2 mapping in the current scene. You may need to select 3D scenes in the Import dock and change their global illumination mode accordingly.
+   */
+  static readonly BAKE_ERROR_NO_MESHES: int;
+  /**
+   * Lightmap baking failed as the lightmapper failed to analyze some of the meshes marked as static for baking.
+   */
+  static readonly BAKE_ERROR_MESHES_INVALID: int;
+  /**
+   * Lightmap baking failed as the resulting image couldn't be saved or imported by Godot after it was saved.
+   */
+  static readonly BAKE_ERROR_CANT_CREATE_IMAGE: int;
+  /**
+   * The user aborted the lightmap baking operation (typically by clicking the **Cancel** button in the progress dialog).
+   */
+  static readonly BAKE_ERROR_USER_ABORTED: int;
+  /**
+   * Lightmap baking failed as the maximum texture size is too small to fit some of the meshes marked for baking.
+   */
+  static readonly BAKE_ERROR_TEXTURE_SIZE_TOO_SMALL: int;
+  /** Lightmap baking failed as the lightmap is too small. */
+  static readonly BAKE_ERROR_LIGHTMAP_TOO_SMALL: int;
+  /** Lightmap baking failed as the lightmap was unable to fit into an atlas. */
+  static readonly BAKE_ERROR_ATLAS_TOO_SMALL: int;
+  // enum EnvironmentMode
+  /** Ignore environment lighting when baking lightmaps. */
+  static readonly ENVIRONMENT_MODE_DISABLED: int;
+  /**
+   * Use the scene's environment lighting when baking lightmaps.
+   * **Note:** If baking lightmaps in a scene with no {@link WorldEnvironment} node, this will act like {@link ENVIRONMENT_MODE_DISABLED}. The editor's preview sky and sun is *not* taken into account by {@link LightmapGI} when baking lightmaps.
+   */
+  static readonly ENVIRONMENT_MODE_SCENE: int;
+  /** Use {@link environment_custom_sky} as a source of environment lighting when baking lightmaps. */
+  static readonly ENVIRONMENT_MODE_CUSTOM_SKY: int;
+  /**
+   * Use {@link environment_custom_color} multiplied by {@link environment_custom_energy} as a constant source of environment lighting when baking lightmaps.
+   */
+  static readonly ENVIRONMENT_MODE_CUSTOM_COLOR: int;
+}

package/typings/classes/LightmapGIData.d.ts

@@ -0,0 +1,50 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Contains baked lightmap and dynamic object probe data for {@link LightmapGI}. */
+declare class LightmapGIData extends Resource {
+  /** The lightmap atlas texture generated by the lightmapper. */
+  light_texture: TextureLayered | null;
+  /** The lightmap atlas textures generated by the lightmapper. */
+  lightmap_textures: Array<TextureLayered>;
+  /** The shadowmask atlas textures generated by the lightmapper. */
+  shadowmask_textures: Array<TextureLayered>;
+  set_light_texture(value: TextureLayered | null): void;
+  get_light_texture(): TextureLayered | null;
+  set_lightmap_textures(value: Array<TextureLayered>): void;
+  get_lightmap_textures(): Array<TextureLayered>;
+  set_shadowmask_textures(value: Array<TextureLayered>): void;
+  get_shadowmask_textures(): Array<TextureLayered>;
+
+  /** Adds an object that is considered baked within this {@link LightmapGIData}. */
+  add_user(path: NodePath | string, uv_scale: Rect2 | Rect2i, slice_index: int, sub_instance: int): void;
+  /** Clear all objects that are considered baked within this {@link LightmapGIData}. */
+  clear_users(): void;
+  /** Returns the number of objects that are considered baked within this {@link LightmapGIData}. */
+  get_user_count(): int;
+  /** Returns the {@link NodePath} of the baked object at index `user_idx`. */
+  get_user_path(user_idx: int): NodePath;
+  /**
+   * If `true`, lightmaps were baked with directional information. See also {@link LightmapGI.directional}.
+   */
+  is_using_spherical_harmonics(): boolean;
+  /**
+   * If `uses_spherical_harmonics` is `true`, tells the engine to treat the lightmap data as if it was baked with directional information.
+   * **Note:** Changing this value on already baked lightmaps will not cause them to be baked again. This means the material appearance will look incorrect until lightmaps are baked again, in which case the value set here is discarded as the entire {@link LightmapGIData} resource is replaced by the lightmapper.
+   */
+  set_uses_spherical_harmonics(uses_spherical_harmonics: boolean): void;
+
+  // enum ShadowmaskMode
+  /**
+   * Shadowmasking is disabled. No shadowmask texture will be created when baking lightmaps. Existing shadowmask textures will be removed during baking.
+   */
+  static readonly SHADOWMASK_MODE_NONE: int;
+  /**
+   * Shadowmasking is enabled. Directional shadows that are outside the {@link DirectionalLight3D.directional_shadow_max_distance} will be rendered using the shadowmask texture. Shadows that are inside the range will be rendered using real-time shadows exclusively. This mode allows for more precise real-time shadows up close, without the potential "smearing" effect that can occur when using lightmaps with a high texel size. The downside is that when the camera moves fast, the transition between the real-time light and shadowmask can be obvious. Also, objects that only have shadows baked in the shadowmask (and no real-time shadows) won't display any shadows up close.
+   */
+  static readonly SHADOWMASK_MODE_REPLACE: int;
+  /**
+   * Shadowmasking is enabled. Directional shadows will be rendered with real-time shadows overlaid on top of the shadowmask texture. This mode makes for smoother shadow transitions when the camera moves fast, at the cost of a potential smearing effect for directional shadows that are up close (due to the real-time shadow being mixed with a low-resolution shadowmask). Objects that only have shadows baked in the shadowmask (and no real-time shadows) will keep their shadows up close.
+   */
+  static readonly SHADOWMASK_MODE_OVERLAY: int;
+}

package/typings/classes/LightmapProbe.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Represents a single manually placed probe for dynamic object lighting with {@link LightmapGI}. */
+declare class LightmapProbe extends Node3D {
+}