@ringozz/godot 0.1.0

package/gen/classes/LabelSettings.ts

@@ -0,0 +1,168 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { Color, Vector2 } from '../value-types/index.ts';
+import type { Font } from './Font.ts';
+
+/**
+ * {@link LabelSettings} is a resource that provides common settings to customize the text in a {@link Label}. It will take priority over the properties defined in {@link Control.theme}. The resource can be shared between multiple labels and changed on the fly, so it's convenient and flexible way to setup text style.
+ */
+export class LabelSettings extends Resource {
+    constructor(name = 387) { super(name); }
+
+    /**
+     * Adds a new stacked outline to the label at the given `index`. If `index` is `-1`, the new stacked outline will be added at the end of the list.
+     */
+    addStackedOutline(index?: number /* = -1 */): void { _C(this, 1294, index); }
+
+    /**
+     * Moves the stacked outline at index `fromIndex` to the given position `toPosition` in the array.
+     */
+    moveStackedOutline(fromIndex: number, toPosition: number): void { _C(this, 8993, fromIndex, toPosition); }
+
+    /**
+     * Removes the stacked outline at index `index`.
+     */
+    removeStackedOutline(index: number): void { _C(this, 9961, index); }
+
+    /**
+     * Sets the size of the stacked outline identified by the given `index` to `size`.
+     */
+    setStackedOutlineSize(index: number, size: number): void { _C(this, 12871, index, size); }
+
+    /**
+     * Returns the size of the stacked outline at `index`.
+     */
+    getStackedOutlineSize(index: number): number { return _C(this, 6525, index) as number; }
+
+    /**
+     * Sets the color of the stacked outline identified by the given `index` to `color`.
+     */
+    setStackedOutlineColor(index: number, color: Color): void { _C(this, 12869, index, color); }
+
+    /**
+     * Returns the color of the stacked outline at `index`.
+     */
+    getStackedOutlineColor(index: number): Color { return _C(this, 6523, index) as Color; }
+
+    /**
+     * Adds a new stacked shadow to the label at the given `index`. If `index` is `-1`, the new stacked shadow will be added at the end of the list.
+     */
+    addStackedShadow(index?: number /* = -1 */): void { _C(this, 1295, index); }
+
+    /**
+     * Moves the stacked shadow at index `fromIndex` to the given position `toPosition` in the array.
+     */
+    moveStackedShadow(fromIndex: number, toPosition: number): void { _C(this, 8994, fromIndex, toPosition); }
+
+    /**
+     * Removes the stacked shadow at index `index`.
+     */
+    removeStackedShadow(index: number): void { _C(this, 9962, index); }
+
+    /**
+     * Sets the offset of the stacked shadow identified by the given `index` to `offset`.
+     */
+    setStackedShadowOffset(index: number, offset: Vector2): void { _C(this, 12874, index, offset); }
+
+    /**
+     * Returns the offset of the stacked shadow at `index`.
+     */
+    getStackedShadowOffset(index: number): Vector2 { return _C(this, 6528, index) as Vector2; }
+
+    /**
+     * Sets the color of the stacked shadow identified by the given `index` to `color`.
+     */
+    setStackedShadowColor(index: number, color: Color): void { _C(this, 12872, index, color); }
+
+    /**
+     * Returns the color of the stacked shadow at `index`.
+     */
+    getStackedShadowColor(index: number): Color { return _C(this, 6526, index) as Color; }
+
+    /**
+     * Sets the outline size of the stacked shadow identified by the given `index` to `size`.
+     */
+    setStackedShadowOutlineSize(index: number, size: number): void { _C(this, 12875, index, size); }
+
+    /**
+     * Returns the outline size of the stacked shadow at `index`.
+     */
+    getStackedShadowOutlineSize(index: number): number { return _C(this, 6529, index) as number; }
+
+    /**
+     * Additional vertical spacing between lines (in pixels), spacing is added to line descent. This value can be negative.
+     */
+    get lineSpacing(): number { return _C(this, 5372) as number; }
+    set lineSpacing(v: number) { _C(this, 11928, v); }
+
+    /**
+     * Vertical space between paragraphs. Added on top of {@link lineSpacing}.
+     */
+    get paragraphSpacing(): number { return _C(this, 5808) as number; }
+    set paragraphSpacing(v: number) { _C(this, 12246, v); }
+
+    /**
+     * {@link Font} used for the text.
+     */
+    get font(): Font { return _C(this, 4846) as Font; }
+    set font(v: Font) { _C(this, 11452, v); }
+
+    /**
+     * Size of the text.
+     */
+    get fontSize(): number { return _C(this, 4852) as number; }
+    set fontSize(v: number) { _C(this, 11457, v); }
+
+    /**
+     * Color of the text.
+     */
+    get fontColor(): Color { return _C(this, 4847) as Color; }
+    set fontColor(v: Color) { _C(this, 11453, v); }
+
+    /**
+     * Text outline size.
+     */
+    get outlineSize(): number { return _C(this, 5760) as number; }
+    set outlineSize(v: number) { _C(this, 12218, v); }
+
+    /**
+     * The color of the outline.
+     */
+    get outlineColor(): Color { return _C(this, 5756) as Color; }
+    set outlineColor(v: Color) { _C(this, 12215, v); }
+
+    /**
+     * Size of the shadow effect.
+     */
+    get shadowSize(): number { return _C(this, 6366) as number; }
+    set shadowSize(v: number) { _C(this, 12713, v); }
+
+    /**
+     * Color of the shadow effect. If alpha is `0`, no shadow will be drawn.
+     */
+    get shadowColor(): Color { return _C(this, 6360) as Color; }
+    set shadowColor(v: Color) { _C(this, 12706, v); }
+
+    /**
+     * Offset of the shadow effect, in pixels.
+     */
+    get shadowOffset(): Vector2 { return _C(this, 6364) as Vector2; }
+    set shadowOffset(v: Vector2) { _C(this, 12711, v); }
+
+    /**
+     * The number of stacked outlines.
+     */
+    get stackedOutlineCount(): number { return _C(this, 6524) as number; }
+    set stackedOutlineCount(v: number) { _C(this, 12870, v); }
+
+    /**
+     * The number of stacked shadows.
+     */
+    get stackedShadowCount(): number { return _C(this, 6527) as number; }
+    set stackedShadowCount(v: number) { _C(this, 12873, v); }
+
+    static readonly name = _R(387, LabelSettings);
+}

package/gen/classes/Light2D.ts

@@ -0,0 +1,150 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { Color } from '../value-types/index.ts';
+
+/**
+ * Casts light in a 2D environment. A light is defined as a color, an energy value, a mode (see constants), and various other parameters (range and shadows-related).
+ */
+export class Light2D extends Node2D {
+
+    /**
+     * Sets the light's height, which is used in 2D normal mapping. See {@link PointLight2D.height} and {@link DirectionalLight2D.height}.
+     */
+    setHeight(height: number): void { _C(this, 11609, height); }
+
+    /**
+     * Returns the light's height, which is used in 2D normal mapping. See {@link PointLight2D.height} and {@link DirectionalLight2D.height}.
+     */
+    getHeight(): number { return _C(this, 5024) as number; }
+
+    /**
+     * If `true`, Light2D will emit light.
+     */
+    get enabled(): boolean { return _C(this, 7935) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * If `true`, Light2D will only appear when editing the scene.
+     */
+    get editorOnly(): boolean { return _C(this, 7923) as boolean; }
+    set editorOnly(v: boolean) { _C(this, 11221, v); }
+
+    /**
+     * The Light2D's {@link Color}.
+     */
+    get color(): Color { return _C(this, 4219) as Color; }
+    set color(v: Color) { _C(this, 10905, v); }
+
+    /**
+     * The Light2D's energy value. The larger the value, the stronger the light.
+     */
+    get energy(): number { return _C(this, 4668) as number; }
+    set energy(v: number) { _C(this, 11295, v); }
+
+    /**
+     * The Light2D's blend mode.
+     */
+    get blendMode(): BlendMode { return _C(this, 3932) as BlendMode; }
+    set blendMode(v: BlendMode) { _C(this, 10677, v); }
+
+    /**
+     * Minimum `z` value of objects that are affected by the Light2D.
+     */
+    get rangeZMin(): number { return _C(this, 7183) as number; }
+    set rangeZMin(v: number) { _C(this, 13407, v); }
+
+    /**
+     * Maximum `z` value of objects that are affected by the Light2D.
+     */
+    get rangeZMax(): number { return _C(this, 7182) as number; }
+    set rangeZMax(v: number) { _C(this, 13406, v); }
+
+    /**
+     * Minimum layer value of objects that are affected by the Light2D.
+     */
+    get rangeLayerMin(): number { return _C(this, 5322) as number; }
+    set rangeLayerMin(v: number) { _C(this, 11883, v); }
+
+    /**
+     * Maximum layer value of objects that are affected by the Light2D.
+     */
+    get rangeLayerMax(): number { return _C(this, 5321) as number; }
+    set rangeLayerMax(v: number) { _C(this, 11882, v); }
+
+    /**
+     * The layer mask. Only objects with a matching {@link CanvasItem.lightMask} will be affected by the Light2D. See also {@link shadowItemCullMask}, which affects which objects can cast shadows.
+     * **Note:** {@link rangeItemCullMask} is ignored by {@link DirectionalLight2D}, which will always light a 2D node regardless of the 2D node's {@link CanvasItem.lightMask}.
+     */
+    get rangeItemCullMask(): number { return _C(this, 5182) as number; }
+    set rangeItemCullMask(v: number) { _C(this, 11767, v); }
+
+    /**
+     * If `true`, the Light2D will cast shadows.
+     */
+    get shadowEnabled(): boolean { return _C(this, 8297) as boolean; }
+    set shadowEnabled(v: boolean) { _C(this, 12707, v); }
+
+    /**
+     * {@link Color} of shadows cast by the Light2D.
+     */
+    get shadowColor(): Color { return _C(this, 6360) as Color; }
+    set shadowColor(v: Color) { _C(this, 12706, v); }
+
+    /**
+     * Shadow filter type.
+     */
+    get shadowFilter(): ShadowFilter { return _C(this, 6361) as ShadowFilter; }
+    set shadowFilter(v: ShadowFilter) { _C(this, 12708, v); }
+
+    /**
+     * Smoothing value for shadows. Higher values will result in softer shadows, at the cost of visible streaks that can appear in shadow rendering. {@link shadowFilterSmooth} only has an effect if {@link shadowFilter} is {@link SHADOW_FILTER_PCF5} or {@link SHADOW_FILTER_PCF13}.
+     */
+    get shadowFilterSmooth(): number { return _C(this, 6367) as number; }
+    set shadowFilterSmooth(v: number) { _C(this, 12714, v); }
+
+    /**
+     * The shadow mask. Used with {@link LightOccluder2D} to cast shadows. Only occluders with a matching {@link CanvasItem.lightMask} will cast shadows. See also {@link rangeItemCullMask}, which affects which objects can *receive* the light.
+     */
+    get shadowItemCullMask(): number { return _C(this, 5209) as number; }
+    set shadowItemCullMask(v: number) { _C(this, 11798, v); }
+
+    static readonly name = _R(388, Light2D);
+}
+
+export const ShadowFilter = {
+    /**
+     * No filter applies to the shadow map. This provides hard shadow edges and is the fastest to render. See {@link shadowFilter}.
+     */
+    SHADOW_FILTER_NONE: 0,
+    /**
+     * Percentage closer filtering (5 samples) applies to the shadow map. This is slower compared to hard shadow rendering. See {@link shadowFilter}.
+     */
+    SHADOW_FILTER_PCF5: 1,
+    /**
+     * Percentage closer filtering (13 samples) applies to the shadow map. This is the slowest shadow filtering mode, and should be used sparingly. See {@link shadowFilter}.
+     */
+    SHADOW_FILTER_PCF13: 2,
+} as const;
+
+export type ShadowFilter = (typeof ShadowFilter)[keyof typeof ShadowFilter];
+
+export const 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.
+     */
+    BLEND_MODE_ADD: 0,
+    /**
+     * Subtracts the value of pixels corresponding to the Light2D to the values of pixels under it, resulting in inversed light effect.
+     */
+    BLEND_MODE_SUB: 1,
+    /**
+     * Mix the value of pixels corresponding to the Light2D to the values of pixels under it by linear interpolation.
+     */
+    BLEND_MODE_MIX: 2,
+} as const;
+
+export type BlendMode = (typeof BlendMode)[keyof typeof BlendMode];
+

package/gen/classes/Light3D.ts

@@ -0,0 +1,310 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualInstance3D } from './VisualInstance3D.ts';
+import type { Color } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * Light3D is the *abstract* base class for light nodes. As it can't be instantiated, it shouldn't be used directly. Other types of light nodes inherit from it. Light3D contains the common variables and parameters used for lighting.
+ */
+export class Light3D extends VisualInstance3D {
+
+    /**
+     * Returns the {@link Color} of an idealized blackbody at the given {@link lightTemperature}. This value is calculated internally based on the {@link lightTemperature}. This {@link Color} is multiplied by {@link lightColor} before being sent to the {@link RenderingServer}.
+     */
+    getCorrelatedColor(): Color { return _C(this, 4332) as Color; }
+
+    /**
+     * Used by positional lights ({@link OmniLight3D} and {@link SpotLight3D}) when {@link ProjectSettings.rendering/lightsAndShadows/usePhysicalLightUnits} 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.
+     */
+    get lightIntensityLumens(): number { return _C(this, 5809, 20) as number; }
+    set lightIntensityLumens(v: number) { _C(this, 12248, 20, v); }
+
+    /**
+     * Used by {@link DirectionalLight3D}s when {@link ProjectSettings.rendering/lightsAndShadows/usePhysicalLightUnits} 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.
+     */
+    get lightIntensityLux(): number { return _C(this, 5809, 20) as number; }
+    set lightIntensityLux(v: number) { _C(this, 12248, 20, v); }
+
+    /**
+     * Sets the color temperature of the light source, measured in Kelvin. This is used to calculate a correlated color temperature which tints the {@link lightColor}.
+     * 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.
+     */
+    get lightTemperature(): number { return _C(this, 6706) as number; }
+    set lightTemperature(v: number) { _C(this, 13012, v); }
+
+    /**
+     * 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 lightEnergy}.
+     */
+    get lightColor(): Color { return _C(this, 4219) as Color; }
+    set lightColor(v: Color) { _C(this, 10905, v); }
+
+    /**
+     * 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.
+     */
+    get lightEnergy(): number { return _C(this, 5809, 0) as number; }
+    set lightEnergy(v: number) { _C(this, 12248, 0, v); }
+
+    /**
+     * Secondary multiplier used with indirect light (light bounces). Used with {@link VoxelGI} and SDFGI (see {@link Environment.sdfgiEnabled}).
+     * **Note:** This property is ignored if {@link lightEnergy} is equal to `0.0`, as the light won't be present at all in the GI shader.
+     */
+    get lightIndirectEnergy(): number { return _C(this, 5809, 1) as number; }
+    set lightIndirectEnergy(v: number) { _C(this, 12248, 1, v); }
+
+    /**
+     * Secondary multiplier multiplied with {@link lightEnergy} 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 lightVolumetricFogEnergy} set to `0.0` unless {@link Environment.volumetricFogTemporalReprojectionEnabled} is disabled (or unless the reprojection amount is significantly lowered).
+     */
+    get lightVolumetricFogEnergy(): number { return _C(this, 5809, 2) as number; }
+    set lightVolumetricFogEnergy(v: number) { _C(this, 12248, 2, v); }
+
+    /**
+     * {@link Texture2D} projected by light. {@link shadowEnabled} 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/lightProjectors/filter}.
+     * **Note:** Light projector textures are only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+     */
+    get lightProjector(): Texture2D { return _C(this, 6047) as Texture2D; }
+    set lightProjector(v: Texture2D) { _C(this, 12443, v); }
+
+    /**
+     * The simulated size of the light in Godot units, affecting shading and shadows. For {@link OmniLight3D}s and {@link SpotLight3D}s, increasing this value simulates a spherical area light, expanding the size of specular highlights. If shadows are enabled, a penumbra is rendered, making shadows appear blurrier. For {@link AreaLight3D}s, only the shadows are affected. Penumbras are simulated with percentage-closer soft shadows, or PCSS, which has a noticeable performance cost for values above `0.0`.
+     * **Note:** {@link lightSize} 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.
+     */
+    get lightSize(): number { return _C(this, 5809, 5) as number; }
+    set lightSize(v: number) { _C(this, 12248, 5, v); }
+
+    /**
+     * 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 lightAngularDistance} 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.
+     */
+    get lightAngularDistance(): number { return _C(this, 5809, 5) as number; }
+    set lightAngularDistance(v: number) { _C(this, 12248, 5, v); }
+
+    /**
+     * If `true`, the light's effect is reversed, darkening areas and casting bright shadows.
+     */
+    get lightNegative(): boolean { return _C(this, 8130) as boolean; }
+    set lightNegative(v: boolean) { _C(this, 12128, v); }
+
+    /**
+     * 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.
+     */
+    get lightSpecular(): number { return _C(this, 5809, 3) as number; }
+    set lightSpecular(v: number) { _C(this, 12248, 3, v); }
+
+    /**
+     * 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.giMode}.
+     */
+    get lightBakeMode(): BakeMode { return _C(this, 3879) as BakeMode; }
+    set lightBakeMode(v: BakeMode) { _C(this, 10631, v); }
+
+    /**
+     * 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}.
+     */
+    get lightCullMask(): number { return _C(this, 4339) as number; }
+    set lightCullMask(v: number) { _C(this, 10981, v); }
+
+    /**
+     * 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 distanceFadeEnabled} to hide the light when far away from the {@link Camera3D}.
+     */
+    get shadowEnabled(): boolean { return _C(this, 7446) as boolean; }
+    set shadowEnabled(v: boolean) { _C(this, 12704, v); }
+
+    /**
+     * 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.
+     */
+    get shadowBias(): number { return _C(this, 5809, 15) as number; }
+    set shadowBias(v: number) { _C(this, 12248, 15, v); }
+
+    /**
+     * Offsets the lookup into the shadow map by the object's normal. This can be used to reduce self-shadowing artifacts without using {@link shadowBias}. In practice, this value should be tweaked along with {@link shadowBias} to reduce artifacts as much as possible.
+     */
+    get shadowNormalBias(): number { return _C(this, 5809, 14) as number; }
+    set shadowNormalBias(v: number) { _C(this, 12248, 14, v); }
+
+    /**
+     * 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}.
+     */
+    get shadowReverseCullFace(): boolean { return _C(this, 6365) as boolean; }
+    set shadowReverseCullFace(v: boolean) { _C(this, 12712, v); }
+
+    get shadowTransmittanceBias(): number { return _C(this, 5809, 19) as number; }
+    set shadowTransmittanceBias(v: number) { _C(this, 12248, 19, v); }
+
+    /**
+     * 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.
+     */
+    get shadowOpacity(): number { return _C(this, 5809, 17) as number; }
+    set shadowOpacity(v: number) { _C(this, 12248, 17, v); }
+
+    /**
+     * 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.
+     */
+    get shadowBlur(): number { return _C(this, 5809, 18) as number; }
+    set shadowBlur(v: number) { _C(this, 12248, 18, v); }
+
+    /**
+     * The light will only cast shadows using objects in the selected layers.
+     */
+    get shadowCasterMask(): number { return _C(this, 6359) as number; }
+    set shadowCasterMask(v: number) { _C(this, 12705, v); }
+
+    /**
+     * If `true`, the light will smoothly fade away when far from the active {@link Camera3D} starting at {@link distanceFadeBegin}. This acts as a form of level of detail (LOD). The light will fade out over {@link distanceFadeBegin} + {@link distanceFadeLength}, 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}.
+     */
+    get distanceFadeEnabled(): boolean { return _C(this, 7887) as boolean; }
+    set distanceFadeEnabled(v: boolean) { _C(this, 11274, v); }
+
+    /**
+     * 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}.
+     */
+    get distanceFadeBegin(): number { return _C(this, 4525) as number; }
+    set distanceFadeBegin(v: number) { _C(this, 11135, v); }
+
+    /**
+     * The distance from the camera at which the light's shadow cuts off (in 3D units). Set this to a value lower than {@link distanceFadeBegin} + {@link distanceFadeLength} 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 shadowEnabled} is `true`.
+     */
+    get distanceFadeShadow(): number { return _C(this, 4529) as number; }
+    set distanceFadeShadow(v: number) { _C(this, 11139, v); }
+
+    /**
+     * 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}.
+     */
+    get distanceFadeLength(): number { return _C(this, 4526) as number; }
+    set distanceFadeLength(v: number) { _C(this, 11136, v); }
+
+    /**
+     * 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 lightBakeMode}.
+     */
+    get editorOnly(): boolean { return _C(this, 7923) as boolean; }
+    set editorOnly(v: boolean) { _C(this, 11221, v); }
+
+    static readonly name = _R(389, Light3D);
+}
+
+export const Param = {
+    /**
+     * Constant for accessing {@link lightEnergy}.
+     */
+    PARAM_ENERGY: 0,
+    /**
+     * Constant for accessing {@link lightIndirectEnergy}.
+     */
+    PARAM_INDIRECT_ENERGY: 1,
+    /**
+     * Constant for accessing {@link lightVolumetricFogEnergy}.
+     */
+    PARAM_VOLUMETRIC_FOG_ENERGY: 2,
+    /**
+     * Constant for accessing {@link lightSpecular}.
+     */
+    PARAM_SPECULAR: 3,
+    /**
+     * Constant for accessing {@link OmniLight3D.omniRange} or {@link SpotLight3D.spotRange}.
+     */
+    PARAM_RANGE: 4,
+    /**
+     * Constant for accessing {@link lightSize}.
+     */
+    PARAM_SIZE: 5,
+    /**
+     * Constant for accessing {@link OmniLight3D.omniAttenuation} or {@link SpotLight3D.spotAttenuation}.
+     */
+    PARAM_ATTENUATION: 6,
+    /**
+     * Constant for accessing {@link SpotLight3D.spotAngle}.
+     */
+    PARAM_SPOT_ANGLE: 7,
+    /**
+     * Constant for accessing {@link SpotLight3D.spotAngleAttenuation}.
+     */
+    PARAM_SPOT_ATTENUATION: 8,
+    /**
+     * Constant for accessing {@link DirectionalLight3D.directionalShadowMaxDistance}.
+     */
+    PARAM_SHADOW_MAX_DISTANCE: 9,
+    /**
+     * Constant for accessing {@link DirectionalLight3D.directionalShadowSplit1}.
+     */
+    PARAM_SHADOW_SPLIT_1_OFFSET: 10,
+    /**
+     * Constant for accessing {@link DirectionalLight3D.directionalShadowSplit2}.
+     */
+    PARAM_SHADOW_SPLIT_2_OFFSET: 11,
+    /**
+     * Constant for accessing {@link DirectionalLight3D.directionalShadowSplit3}.
+     */
+    PARAM_SHADOW_SPLIT_3_OFFSET: 12,
+    /**
+     * Constant for accessing {@link DirectionalLight3D.directionalShadowFadeStart}.
+     */
+    PARAM_SHADOW_FADE_START: 13,
+    /**
+     * Constant for accessing {@link shadowNormalBias}.
+     */
+    PARAM_SHADOW_NORMAL_BIAS: 14,
+    /**
+     * Constant for accessing {@link shadowBias}.
+     */
+    PARAM_SHADOW_BIAS: 15,
+    /**
+     * Constant for accessing {@link DirectionalLight3D.directionalShadowPancakeSize}.
+     */
+    PARAM_SHADOW_PANCAKE_SIZE: 16,
+    /**
+     * Constant for accessing {@link shadowOpacity}.
+     */
+    PARAM_SHADOW_OPACITY: 17,
+    /**
+     * Constant for accessing {@link shadowBlur}.
+     */
+    PARAM_SHADOW_BLUR: 18,
+    /**
+     * Constant for accessing {@link shadowTransmittanceBias}.
+     */
+    PARAM_TRANSMITTANCE_BIAS: 19,
+    /**
+     * Constant for accessing {@link lightIntensityLumens} and {@link lightIntensityLux}. Only used when {@link ProjectSettings.rendering/lightsAndShadows/usePhysicalLightUnits} is `true`.
+     */
+    PARAM_INTENSITY: 20,
+    /**
+     * Represents the size of the {@link Param} enum.
+     */
+    PARAM_MAX: 21,
+} as const;
+
+export type Param = (typeof Param)[keyof typeof Param];
+
+export const 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.sdfgiEnabled}).
+     */
+    BAKE_DISABLED: 0,
+    /**
+     * Light is taken into account in static baking ({@link VoxelGI}, {@link LightmapGI}, SDFGI ({@link Environment.sdfgiEnabled})). 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 editorOnly} is `true`.
+     */
+    BAKE_STATIC: 1,
+    /**
+     * Light is taken into account in dynamic baking ({@link VoxelGI} and SDFGI ({@link Environment.sdfgiEnabled}) 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/globalIllumination/sdfgi/framesToUpdateLights}.
+     */
+    BAKE_DYNAMIC: 2,
+} as const;
+
+export type BakeMode = (typeof BakeMode)[keyof typeof BakeMode];
+

package/gen/classes/LightOccluder2D.ts

@@ -0,0 +1,33 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { OccluderPolygon2D } from './OccluderPolygon2D.ts';
+
+/**
+ * Occludes light cast by a Light2D, casting shadows. The LightOccluder2D must be provided with an {@link OccluderPolygon2D} in order for the shadow to be computed.
+ */
+export class LightOccluder2D extends Node2D {
+    constructor(name = 390) { super(name); }
+
+    /**
+     * The {@link OccluderPolygon2D} used to compute the shadow.
+     */
+    get occluder(): OccluderPolygon2D { return _C(this, 5691) as OccluderPolygon2D; }
+    set occluder(v: OccluderPolygon2D) { _C(this, 12162, v); }
+
+    /**
+     * If enabled, the occluder will be part of a real-time generated signed distance field that can be used in custom shaders.
+     */
+    get sdfCollision(): boolean { return _C(this, 8295) as boolean; }
+    set sdfCollision(v: boolean) { _C(this, 10542, v); }
+
+    /**
+     * The LightOccluder2D's occluder light mask. The LightOccluder2D will cast shadows only from Light2D(s) that have the same light mask(s).
+     */
+    get occluderLightMask(): number { return _C(this, 5690) as number; }
+    set occluderLightMask(v: number) { _C(this, 12161, v); }
+
+    static readonly name = _R(390, LightOccluder2D);
+}