@ringozz/godot 0.1.0

package/gen/classes/LightmapGI.ts

@@ -0,0 +1,291 @@
+// 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 { CameraAttributes } from './CameraAttributes.ts';
+import type { LightmapGIData, ShadowmaskMode } from './LightmapGIData.ts';
+import type { Sky } from './Sky.ts';
+
+/**
+ * The {@link LightmapGI} node is used to compute and store baked lightmaps. Lightmaps are used to provide high-quality indirect lighting with very little light leaking. {@link LightmapGI} can also provide rough reflections using spherical harmonics if {@link directional} is enabled. Dynamic objects can receive indirect lighting thanks to *light probes*, which can be automatically placed by setting {@link generateProbesSubdiv} to a value other than {@link GENERATE_PROBES_DISABLED}. Additional lightmap probes can also be added by creating {@link LightmapProbe} nodes. The downside is that lightmaps are fully static and cannot be baked in an exported project. Baking a {@link LightmapGI} node is also slower compared to {@link VoxelGI}.
+ * **Procedural generation:** Lightmap baking functionality is only available in the editor. This means {@link LightmapGI} is not suited to procedurally generated or user-built levels. For procedurally generated or user-built levels, use {@link VoxelGI} or SDFGI instead (see {@link Environment.sdfgiEnabled}).
+ * **Performance:** {@link LightmapGI} provides the best possible run-time performance for global illumination. It is suitable for low-end hardware including integrated graphics and mobile devices.
+ * **Note:** Due to how lightmaps work, most properties only have a visible effect once lightmaps are baked again.
+ * **Note:** Lightmap baking on {@link CSGShape3D}s and {@link PrimitiveMesh}es is not supported, as these cannot store UV2 data required for baking.
+ * **Note:** If no custom lightmappers are installed, {@link LightmapGI} can only be baked from devices that support the Forward+ or Mobile renderers.
+ * **Note:** The {@link LightmapGI} node only bakes light data for child nodes of its parent. Nodes further up the hierarchy of the scene will not be baked.
+ */
+export class LightmapGI extends VisualInstance3D {
+    constructor(name = 391) { super(name); }
+
+    /**
+     * 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 useDenoiser} and/or decrease {@link texelScale}.
+     * To further increase quality, enable {@link supersampling} and/or increase {@link texelScale}.
+     */
+    get quality(): BakeQuality { return _C(this, 3880) as BakeQuality; }
+    set quality(v: BakeQuality) { _C(this, 10633, v); }
+
+    /**
+     * If `true`, lightmaps are baked with the texel scale multiplied with {@link 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.
+     */
+    get supersampling(): boolean { return _C(this, 8348) as boolean; }
+    set supersampling(v: boolean) { _C(this, 12935, v); }
+
+    /**
+     * 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.
+     */
+    get supersamplingFactor(): number { return _C(this, 6611) as number; }
+    set supersamplingFactor(v: number) { _C(this, 12936, v); }
+
+    /**
+     * 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.
+     */
+    get bounces(): number { return _C(this, 3993) as number; }
+    set bounces(v: number) { _C(this, 10733, v); }
+
+    /**
+     * 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 bounceIndirectEnergy}.
+     * **Note:** {@link bounceIndirectEnergy} only has an effect if {@link bounces} is set to a value greater than or equal to `1`.
+     */
+    get bounceIndirectEnergy(): number { return _C(this, 3992) as number; }
+    set bounceIndirectEnergy(v: number) { _C(this, 10732, v); }
+
+    /**
+     * 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.lightBakeMode} set to {@link Light3D.BAKE_STATIC} and with {@link 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 {@link DirectionalLight3D}. {@link directional} works with all light types.
+     */
+    get directional(): boolean { return _C(this, 7881) as boolean; }
+    set directional(v: boolean) { _C(this, 11113, v); }
+
+    /**
+     * 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.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 {@link shadowmaskMode} 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.
+     */
+    get shadowmaskMode(): ShadowmaskMode { return _C(this, 6368) as ShadowmaskMode; }
+    set shadowmaskMode(v: ShadowmaskMode) { _C(this, 12715, v); }
+
+    /**
+     * 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 useTextureForBounces} at its default value of `true` if unsure.
+     * **Note:** {@link useTextureForBounces} only has an effect if {@link bounces} is set to a value greater than or equal to `1`.
+     */
+    get useTextureForBounces(): boolean { return _C(this, 8424) as boolean; }
+    set useTextureForBounces(v: boolean) { _C(this, 13241, v); }
+
+    /**
+     * If `true`, ignore environment lighting when baking lightmaps.
+     */
+    get interior(): boolean { return _C(this, 8035) as boolean; }
+    set interior(v: boolean) { _C(this, 11737, v); }
+
+    /**
+     * 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.
+     */
+    get useDenoiser(): boolean { return _C(this, 8402) as boolean; }
+    set useDenoiser(v: boolean) { _C(this, 13210, v); }
+
+    /**
+     * The strength of denoising step applied to the generated lightmaps. Only effective if {@link useDenoiser} is `true` and {@link ProjectSettings.rendering/lightmapping/denoising/denoiser} is set to JNLM.
+     */
+    get denoiserStrength(): number { return _C(this, 4464) as number; }
+    set denoiserStrength(v: number) { _C(this, 11080, v); }
+
+    /**
+     * 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 useDenoiser} is `true` and {@link ProjectSettings.rendering/lightmapping/denoising/denoiser} is set to JNLM.
+     */
+    get denoiserRange(): number { return _C(this, 4463) as number; }
+    set denoiserRange(v: number) { _C(this, 11079, v); }
+
+    /**
+     * 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.
+     */
+    get bias(): number { return _C(this, 3912) as number; }
+    set bias(v: number) { _C(this, 10655, v); }
+
+    /**
+     * 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 texelScale} doubles the lightmap texture resolution for all objects *on each axis*, so it will *quadruple* the texel count.
+     */
+    get texelScale(): number { return _C(this, 6717) as number; }
+    set texelScale(v: number) { _C(this, 13019, v); }
+
+    /**
+     * 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 maxTextureSize} at its default value of `16384` if unsure.
+     */
+    get maxTextureSize(): number { return _C(this, 5493) as number; }
+    set maxTextureSize(v: number) { _C(this, 12015, v); }
+
+    /**
+     * The environment mode to use when baking lightmaps.
+     */
+    get environmentMode(): EnvironmentMode { return _C(this, 4683) as EnvironmentMode; }
+    set environmentMode(v: EnvironmentMode) { _C(this, 11306, v); }
+
+    /**
+     * The sky to use as a source of environment lighting. Only effective if {@link environmentMode} is {@link ENVIRONMENT_MODE_CUSTOM_SKY}.
+     */
+    get environmentCustomSky(): Sky { return _C(this, 4682) as Sky; }
+    set environmentCustomSky(v: Sky) { _C(this, 11305, v); }
+
+    /**
+     * The color to use for environment lighting. Only effective if {@link environmentMode} is {@link ENVIRONMENT_MODE_CUSTOM_COLOR}.
+     */
+    get environmentCustomColor(): Color { return _C(this, 4680) as Color; }
+    set environmentCustomColor(v: Color) { _C(this, 11303, v); }
+
+    /**
+     * The color multiplier to use for environment lighting. Only effective if {@link environmentMode} is {@link ENVIRONMENT_MODE_CUSTOM_COLOR}.
+     */
+    get environmentCustomEnergy(): number { return _C(this, 4681) as number; }
+    set environmentCustomEnergy(v: number) { _C(this, 11304, v); }
+
+    /**
+     * 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.
+     */
+    get cameraAttributes(): CameraAttributes { return _C(this, 4063) as CameraAttributes; }
+    set cameraAttributes(v: CameraAttributes) { _C(this, 10785, v); }
+
+    /**
+     * 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 generateProbesSubdiv}, direct lighting on dynamic objects is always applied using {@link Light3D} nodes in real-time.
+     */
+    get generateProbesSubdiv(): GenerateProbes { return _C(this, 4918) as GenerateProbes; }
+    set generateProbesSubdiv(v: GenerateProbes) { _C(this, 11508, v); }
+
+    /**
+     * The {@link LightmapGIData} associated to this {@link LightmapGI} node. This resource is automatically created after baking, and is not meant to be created manually.
+     */
+    get lightData(): LightmapGIData { return _C(this, 5338) as LightmapGIData; }
+    set lightData(v: LightmapGIData) { _C(this, 11895, v); }
+
+    static readonly name = _R(391, LightmapGI);
+}
+
+export const BakeQuality = {
+    /**
+     * Low bake quality (fastest bake times). The quality of this preset can be adjusted by changing {@link ProjectSettings.rendering/lightmapping/bakeQuality/lowQualityRayCount} and {@link ProjectSettings.rendering/lightmapping/bakeQuality/lowQualityProbeRayCount}.
+     */
+    BAKE_QUALITY_LOW: 0,
+    /**
+     * Medium bake quality (fast bake times). The quality of this preset can be adjusted by changing {@link ProjectSettings.rendering/lightmapping/bakeQuality/mediumQualityRayCount} and {@link ProjectSettings.rendering/lightmapping/bakeQuality/mediumQualityProbeRayCount}.
+     */
+    BAKE_QUALITY_MEDIUM: 1,
+    /**
+     * High bake quality (slow bake times). The quality of this preset can be adjusted by changing {@link ProjectSettings.rendering/lightmapping/bakeQuality/highQualityRayCount} and {@link ProjectSettings.rendering/lightmapping/bakeQuality/highQualityProbeRayCount}.
+     */
+    BAKE_QUALITY_HIGH: 2,
+    /**
+     * Highest bake quality (slowest bake times). The quality of this preset can be adjusted by changing {@link ProjectSettings.rendering/lightmapping/bakeQuality/ultraQualityRayCount} and {@link ProjectSettings.rendering/lightmapping/bakeQuality/ultraQualityProbeRayCount}.
+     */
+    BAKE_QUALITY_ULTRA: 3,
+} as const;
+
+export type BakeQuality = (typeof BakeQuality)[keyof typeof BakeQuality];
+
+export const GenerateProbes = {
+    /**
+     * Don't generate lightmap probes for lighting dynamic objects.
+     */
+    GENERATE_PROBES_DISABLED: 0,
+    /**
+     * Lowest level of subdivision (fastest bake times, smallest file sizes).
+     */
+    GENERATE_PROBES_SUBDIV_4: 1,
+    /**
+     * Low level of subdivision (fast bake times, small file sizes).
+     */
+    GENERATE_PROBES_SUBDIV_8: 2,
+    /**
+     * High level of subdivision (slow bake times, large file sizes).
+     */
+    GENERATE_PROBES_SUBDIV_16: 3,
+    /**
+     * Highest level of subdivision (slowest bake times, largest file sizes).
+     */
+    GENERATE_PROBES_SUBDIV_32: 4,
+} as const;
+
+export type GenerateProbes = (typeof GenerateProbes)[keyof typeof GenerateProbes];
+
+export const BakeError = {
+    /**
+     * Lightmap baking was successful.
+     */
+    BAKE_ERROR_OK: 0,
+    /**
+     * Lightmap baking failed because the root node for the edited scene could not be accessed.
+     */
+    BAKE_ERROR_NO_SCENE_ROOT: 1,
+    /**
+     * Lightmap baking failed as the lightmap data resource is embedded in a foreign resource.
+     */
+    BAKE_ERROR_FOREIGN_DATA: 2,
+    /**
+     * Lightmap baking failed as there is no lightmapper available in this Godot build.
+     */
+    BAKE_ERROR_NO_LIGHTMAPPER: 3,
+    /**
+     * Lightmap baking failed as the {@link LightmapGIData} save path isn't configured in the resource.
+     */
+    BAKE_ERROR_NO_SAVE_PATH: 4,
+    /**
+     * Lightmap baking failed as there are no meshes whose {@link GeometryInstance3D.giMode} 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.
+     */
+    BAKE_ERROR_NO_MESHES: 5,
+    /**
+     * Lightmap baking failed as the lightmapper failed to analyze some of the meshes marked as static for baking.
+     */
+    BAKE_ERROR_MESHES_INVALID: 6,
+    /**
+     * Lightmap baking failed as the resulting image couldn't be saved or imported by Godot after it was saved.
+     */
+    BAKE_ERROR_CANT_CREATE_IMAGE: 7,
+    /**
+     * The user aborted the lightmap baking operation (typically by clicking the **Cancel** button in the progress dialog).
+     */
+    BAKE_ERROR_USER_ABORTED: 8,
+    /**
+     * Lightmap baking failed as the maximum texture size is too small to fit some of the meshes marked for baking.
+     */
+    BAKE_ERROR_TEXTURE_SIZE_TOO_SMALL: 9,
+    /**
+     * Lightmap baking failed as the lightmap is too small.
+     */
+    BAKE_ERROR_LIGHTMAP_TOO_SMALL: 10,
+    /**
+     * Lightmap baking failed as the lightmap was unable to fit into an atlas.
+     */
+    BAKE_ERROR_ATLAS_TOO_SMALL: 11,
+} as const;
+
+export type BakeError = (typeof BakeError)[keyof typeof BakeError];
+
+export const EnvironmentMode = {
+    /**
+     * Ignore environment lighting when baking lightmaps.
+     */
+    ENVIRONMENT_MODE_DISABLED: 0,
+    /**
+     * 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.
+     */
+    ENVIRONMENT_MODE_SCENE: 1,
+    /**
+     * Use {@link environmentCustomSky} as a source of environment lighting when baking lightmaps.
+     */
+    ENVIRONMENT_MODE_CUSTOM_SKY: 2,
+    /**
+     * Use {@link environmentCustomColor} multiplied by {@link environmentCustomEnergy} as a constant source of environment lighting when baking lightmaps.
+     */
+    ENVIRONMENT_MODE_CUSTOM_COLOR: 3,
+} as const;
+
+export type EnvironmentMode = (typeof EnvironmentMode)[keyof typeof EnvironmentMode];
+

package/gen/classes/LightmapGIData.ts

@@ -0,0 +1,85 @@
+// 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 { GodotArray, GodotDictionary, NodePath } from '../heap-types/index.ts';
+import type { Rect2 } from '../value-types/index.ts';
+import type { TextureLayered } from './TextureLayered.ts';
+
+/**
+ * {@link LightmapGIData} contains baked lightmap and dynamic object probe data for {@link LightmapGI}. It is replaced every time lightmaps are baked in {@link LightmapGI}.
+ */
+export class LightmapGIData extends Resource {
+    constructor(name = 392) { super(name); }
+
+    /**
+     * Adds an object that is considered baked within this {@link LightmapGIData}.
+     */
+    addUser(path: NodePath, uvScale: Rect2, sliceIndex: number, subInstance: number): void { _C(this, 1328, path, uvScale, sliceIndex, subInstance); }
+
+    /**
+     * Returns the number of objects that are considered baked within this {@link LightmapGIData}.
+     */
+    getUserCount(): number { return _C(this, 6997) as number; }
+
+    /**
+     * Returns the {@link NodePath} of the baked object at index `userIdx`.
+     */
+    getUserPath(userIdx: number): NodePath { return _C(this, 6999, userIdx) as NodePath; }
+
+    /**
+     * Clear all objects that are considered baked within this {@link LightmapGIData}.
+     */
+    clearUsers(): void { _C(this, 2309); }
+
+    /**
+     * The lightmap atlas textures generated by the lightmapper.
+     */
+    get lightmapTextures(): GodotArray<TextureLayered> { return _C(this, 5346) as GodotArray<TextureLayered>; }
+    set lightmapTextures(v: GodotArray<TextureLayered>) { _C(this, 11903, v); }
+
+    /**
+     * The shadowmask atlas textures generated by the lightmapper.
+     */
+    get shadowmaskTextures(): GodotArray<TextureLayered> { return _C(this, 6369) as GodotArray<TextureLayered>; }
+    set shadowmaskTextures(v: GodotArray<TextureLayered>) { _C(this, 12716, v); }
+
+    get usesSphericalHarmonics(): boolean { return _C(this, 8421) as boolean; }
+    set usesSphericalHarmonics(v: boolean) { _C(this, 13248, v); }
+
+    get userData(): GodotArray { return _C(this, 1016) as GodotArray; }
+    set userData(v: GodotArray) { _C(this, 1047, v); }
+
+    get probeData(): GodotDictionary { return _C(this, 1010) as GodotDictionary; }
+    set probeData(v: GodotDictionary) { _C(this, 1040, v); }
+
+    /**
+     * The lightmap atlas texture generated by the lightmapper.
+     */
+    get lightTexture(): TextureLayered { return _C(this, 5341) as TextureLayered; }
+    set lightTexture(v: TextureLayered) { _C(this, 11898, v); }
+
+    get lightTextures(): GodotArray { return _C(this, 1004) as GodotArray; }
+    set lightTextures(v: GodotArray) { _C(this, 1032, v); }
+
+    static readonly name = _R(392, LightmapGIData);
+}
+
+export const ShadowmaskMode = {
+    /**
+     * Shadowmasking is disabled. No shadowmask texture will be created when baking lightmaps. Existing shadowmask textures will be removed during baking.
+     */
+    SHADOWMASK_MODE_NONE: 0,
+    /**
+     * Shadowmasking is enabled. Directional shadows that are outside the {@link DirectionalLight3D.directionalShadowMaxDistance} 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.
+     */
+    SHADOWMASK_MODE_REPLACE: 1,
+    /**
+     * 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.
+     */
+    SHADOWMASK_MODE_OVERLAY: 2,
+} as const;
+
+export type ShadowmaskMode = (typeof ShadowmaskMode)[keyof typeof ShadowmaskMode];
+

package/gen/classes/LightmapProbe.ts

@@ -0,0 +1,16 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+
+/**
+ * {@link LightmapProbe} represents the position of a single manually placed probe for dynamic object lighting with {@link LightmapGI}. Lightmap probes affect the lighting of {@link GeometryInstance3D}-derived nodes that have their {@link GeometryInstance3D.giMode} set to {@link GeometryInstance3D.GI_MODE_DYNAMIC}.
+ * Typically, {@link LightmapGI} probes are placed automatically by setting {@link LightmapGI.generateProbesSubdiv} to a value other than {@link LightmapGI.GENERATE_PROBES_DISABLED}. By creating {@link LightmapProbe} nodes before baking lightmaps, you can add more probes in specific areas for greater detail, or disable automatic generation and rely only on manually placed probes instead.
+ * **Note:** {@link LightmapProbe} nodes that are placed after baking lightmaps are ignored by dynamic objects. You must bake lightmaps again after creating or modifying {@link LightmapProbe}s for the probes to be effective.
+ */
+export class LightmapProbe extends Node3D {
+    constructor(name = 393) { super(name); }
+
+    static readonly name = _R(393, LightmapProbe);
+}

package/gen/classes/Lightmapper.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+
+/**
+ * This class should be extended by custom lightmapper classes. Lightmappers can then be used with {@link LightmapGI} to provide fast baked global illumination in 3D.
+ * Godot contains a built-in GPU-based lightmapper {@link LightmapperRD} that uses compute shaders, but custom lightmappers can be implemented by C++ modules.
+ */
+export class Lightmapper extends RefCounted {
+
+    static readonly name = _R(394, Lightmapper);
+}

package/gen/classes/LightmapperRD.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Lightmapper } from './Lightmapper.ts';
+
+/**
+ * LightmapperRD ("RD" stands for {@link RenderingDevice}) is the built-in GPU-based lightmapper for use with {@link LightmapGI}. On most dedicated GPUs, it can bake lightmaps much faster than most CPU-based lightmappers. LightmapperRD uses compute shaders to bake lightmaps, so it does not require CUDA or OpenCL libraries to be installed to be usable.
+ * **Note:** This lightmapper requires the GPU to support the {@link RenderingDevice} backend (Forward+ and Mobile renderers). When using the Compatibility renderer, baking will use a temporary {@link RenderingDevice}. Support for {@link RenderingDevice} is not required to *render* lightmaps that were already baked beforehand.
+ */
+export class LightmapperRD extends Lightmapper {
+    constructor(name = 395) { super(name); }
+
+    static readonly name = _R(395, LightmapperRD);
+}

package/gen/classes/LimitAngularVelocityModifier3D.ts

@@ -0,0 +1,91 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModifier3D } from './SkeletonModifier3D.ts';
+
+/**
+ * This modifier limits bone rotation angular velocity by comparing poses between previous and current frame.
+ * You can add bone chains by specifying their root and end bones, then add the bones between them to a list. Modifier processes either that list or the bones excluding those in the list depending on the option {@link exclude}.
+ * **Note:** Most methods in this class take an `index` parameter. This parameter specifies which setting list entry to return if the IK has multiple entries (e.g. `settings/<index>/root_bone_name`).
+ */
+export class LimitAngularVelocityModifier3D extends SkeletonModifier3D {
+    constructor(name = 396) { super(name); }
+
+    /**
+     * Sets the root bone name of the bone chain.
+     */
+    setRootBoneName(index: number, boneName: string): void { _C(this, 12567, index, boneName); }
+
+    /**
+     * Returns the root bone name of the bone chain.
+     */
+    getRootBoneName(index: number): string { return _C(this, 6190, index) as string; }
+
+    /**
+     * Sets the root bone index of the bone chain.
+     */
+    setRootBone(index: number, bone: number): void { _C(this, 12566, index, bone); }
+
+    /**
+     * Returns the root bone index of the bone chain.
+     */
+    getRootBone(index: number): number { return _C(this, 6189, index) as number; }
+
+    /**
+     * Sets the end bone name of the bone chain.
+     * **Note:** End bone must be the root bone or a child of the root bone.
+     */
+    setEndBoneName(index: number, boneName: string): void { _C(this, 11292, index, boneName); }
+
+    /**
+     * Returns the end bone name of the bone chain.
+     */
+    getEndBoneName(index: number): string { return _C(this, 4664, index) as string; }
+
+    /**
+     * Sets the end bone index of the bone chain.
+     */
+    setEndBone(index: number, bone: number): void { _C(this, 11289, index, bone); }
+
+    /**
+     * Returns the end bone index of the bone chain.
+     */
+    getEndBone(index: number): number { return _C(this, 4661, index) as number; }
+
+    /**
+     * Clear all chains.
+     */
+    clearChains(): void { _C(this, 2248); }
+
+    /**
+     * Sets the reference pose for angle comparison to the current pose with the influence of constraints removed. This function is automatically triggered when joints change or upon activation.
+     */
+    reset(): void { _C(this, 10064); }
+
+    /**
+     * The maximum angular velocity per second.
+     */
+    get maxAngularVelocity(): number { return _C(this, 5457) as number; }
+    set maxAngularVelocity(v: number) { _C(this, 11983, v); }
+
+    /**
+     * If `true`, the modifier processes bones not included in the bone list.
+     * If `false`, the bones processed by the modifier are equal to the bone list.
+     */
+    get exclude(): boolean { return _C(this, 7940) as boolean; }
+    set exclude(v: boolean) { _C(this, 11309, v); }
+
+    /**
+     * The number of chains.
+     */
+    get chainCount(): number { return _C(this, 4137) as number; }
+    set chainCount(v: number) { _C(this, 10850, v); }
+
+    /**
+     * The number of joints in the list which created by chains dynamically.
+     */
+    get jointCount(): number { return _C(this, 1002) as number; }
+
+    static readonly name = _R(396, LimitAngularVelocityModifier3D);
+}