@ringozz/godot 0.1.0

package/gen/classes/CollisionPolygon3D.ts

@@ -0,0 +1,54 @@
+// 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';
+import type { PackedVector2Array } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+
+/**
+ * A node that provides a thickened polygon shape (a prism) to a {@link CollisionObject3D} parent and allows it to be edited. The polygon can be concave or convex. This can give a detection shape to an {@link Area3D} or turn a {@link PhysicsBody3D} into a solid object.
+ * **Warning:** A non-uniformly scaled {@link CollisionShape3D} will likely not behave as expected. Make sure to keep its scale the same on all axes and adjust its shape resource instead.
+ */
+export class CollisionPolygon3D extends Node3D {
+    constructor(name = 205) { super(name); }
+
+    /**
+     * Length that the resulting collision extends in either direction perpendicular to its 2D polygon.
+     */
+    get depth(): number { return _C(this, 4468) as number; }
+    set depth(v: number) { _C(this, 11083, v); }
+
+    /**
+     * If `true`, no collision will be produced. This property should be changed with {@link Object.setDeferred}.
+     */
+    get disabled(): boolean { return _C(this, 7883) as boolean; }
+    set disabled(v: boolean) { _C(this, 11122, v); }
+
+    /**
+     * Array of vertices which define the 2D polygon in the local XY plane.
+     */
+    get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
+    set polygon(v: PackedVector2Array) { _C(this, 12373, v); }
+
+    /**
+     * The collision margin for the generated {@link Shape3D}. See {@link Shape3D.margin} for more details.
+     */
+    get margin(): number { return _C(this, 5441) as number; }
+    set margin(v: number) { _C(this, 11969, v); }
+
+    /**
+     * The collision shape color that is displayed in the editor, or in the running project if **Debug > Visible Collision Shapes** is checked at the top of the editor.
+     * **Note:** The default value is {@link ProjectSettings.debug/shapes/collision/shapeColor}. The `Color(0, 0, 0, 0)` value documented here is a placeholder, and not the actual default debug color.
+     */
+    get debugColor(): Color { return _C(this, 4429) as Color; }
+    set debugColor(v: Color) { _C(this, 11040, v); }
+
+    /**
+     * If `true`, when the shape is displayed, it will show a solid fill color in addition to its wireframe.
+     */
+    get debugFill(): boolean { return _C(this, 4644) as boolean; }
+    set debugFill(v: boolean) { _C(this, 11269, v); }
+
+    static readonly name = _R(205, CollisionPolygon3D);
+}

package/gen/classes/CollisionShape2D.ts

@@ -0,0 +1,55 @@
+// 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, Vector2 } from '../value-types/index.ts';
+import type { Shape2D } from './Shape2D.ts';
+
+/**
+ * A node that provides a {@link Shape2D} to a {@link CollisionObject2D} parent and allows it to be edited. This can give a detection shape to an {@link Area2D} or turn a {@link PhysicsBody2D} into a solid object.
+ */
+export class CollisionShape2D extends Node2D {
+    constructor(name = 206) { super(name); }
+
+    /**
+     * The actual shape owned by this collision shape.
+     */
+    get shape(): Shape2D { return _C(this, 6370) as Shape2D; }
+    set shape(v: Shape2D) { _C(this, 12717, v); }
+
+    /**
+     * A disabled collision shape has no effect in the world. This property should be changed with {@link Object.setDeferred}.
+     */
+    get disabled(): boolean { return _C(this, 7883) as boolean; }
+    set disabled(v: boolean) { _C(this, 11122, v); }
+
+    /**
+     * Sets whether this collision shape should only detect collision on one side (top or bottom).
+     * **Note:** This property has no effect if this {@link CollisionShape2D} is a child of an {@link Area2D} node.
+     * **Note:** The one way collision direction can be configured by setting {@link oneWayCollisionDirection}.
+     */
+    get oneWayCollision(): boolean { return _C(this, 8153) as boolean; }
+    set oneWayCollision(v: boolean) { _C(this, 12186, v); }
+
+    /**
+     * The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the shape at a high velocity.
+     */
+    get oneWayCollisionMargin(): number { return _C(this, 5720) as number; }
+    set oneWayCollisionMargin(v: number) { _C(this, 12188, v); }
+
+    /**
+     * The direction used for one-way collision.
+     */
+    get oneWayCollisionDirection(): Vector2 { return _C(this, 5719) as Vector2; }
+    set oneWayCollisionDirection(v: Vector2) { _C(this, 12187, v); }
+
+    /**
+     * The collision shape color that is displayed in the editor, or in the running project if **Debug > Visible Collision Shapes** is checked at the top of the editor.
+     * **Note:** The default value is {@link ProjectSettings.debug/shapes/collision/shapeColor}. The `Color(0, 0, 0, 0)` value documented here is a placeholder, and not the actual default debug color.
+     */
+    get debugColor(): Color { return _C(this, 4429) as Color; }
+    set debugColor(v: Color) { _C(this, 11040, v); }
+
+    static readonly name = _R(206, CollisionShape2D);
+}

package/gen/classes/CollisionShape3D.ts

@@ -0,0 +1,53 @@
+// 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';
+import type { Color } from '../value-types/index.ts';
+import type { Resource } from './Resource.ts';
+import type { Shape3D } from './Shape3D.ts';
+
+/**
+ * A node that provides a {@link Shape3D} to a {@link CollisionObject3D} parent and allows it to be edited. This can give a detection shape to an {@link Area3D} or turn a {@link PhysicsBody3D} into a solid object.
+ * **Warning:** A non-uniformly scaled {@link CollisionShape3D} will likely not behave as expected. Make sure to keep its scale the same on all axes and adjust its {@link shape} resource instead.
+ */
+export class CollisionShape3D extends Node3D {
+    constructor(name = 207) { super(name); }
+
+    /**
+     * This method does nothing.
+     */
+    resourceChanged(resource: Resource): void { _C(this, 10089, resource); }
+
+    /**
+     * Sets the collision shape's shape to the addition of all its convexed {@link MeshInstance3D} siblings geometry.
+     */
+    makeConvexFromSiblings(): void { _C(this, 8728); }
+
+    /**
+     * The actual shape owned by this collision shape.
+     */
+    get shape(): Shape3D { return _C(this, 6370) as Shape3D; }
+    set shape(v: Shape3D) { _C(this, 12717, v); }
+
+    /**
+     * A disabled collision shape has no effect in the world. This property should be changed with {@link Object.setDeferred}.
+     */
+    get disabled(): boolean { return _C(this, 7883) as boolean; }
+    set disabled(v: boolean) { _C(this, 11122, v); }
+
+    /**
+     * The collision shape color that is displayed in the editor, or in the running project if **Debug > Visible Collision Shapes** is checked at the top of the editor.
+     * **Note:** The default value is {@link ProjectSettings.debug/shapes/collision/shapeColor}. The `Color(0, 0, 0, 0)` value documented here is a placeholder, and not the actual default debug color.
+     */
+    get debugColor(): Color { return _C(this, 4429) as Color; }
+    set debugColor(v: Color) { _C(this, 11040, v); }
+
+    /**
+     * If `true`, when the shape is displayed, it will show a solid fill color in addition to its wireframe.
+     */
+    get debugFill(): boolean { return _C(this, 4644) as boolean; }
+    set debugFill(v: boolean) { _C(this, 11269, v); }
+
+    static readonly name = _R(207, CollisionShape3D);
+}

package/gen/classes/ColorPalette.ts

@@ -0,0 +1,21 @@
+// 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 { PackedColorArray } from '../heap-types/index.ts';
+
+/**
+ * The {@link ColorPalette} resource is designed to store and manage a collection of colors. This resource is useful in scenarios where a predefined set of colors is required, such as for creating themes, designing user interfaces, or managing game assets. The built-in {@link ColorPicker} control can also make use of {@link ColorPalette} without additional code.
+ */
+export class ColorPalette extends Resource {
+    constructor(name = 208) { super(name); }
+
+    /**
+     * A {@link PackedColorArray} containing the colors in the palette.
+     */
+    get colors(): PackedColorArray { return _C(this, 4232) as PackedColorArray; }
+    set colors(v: PackedColorArray) { _C(this, 10914, v); }
+
+    static readonly name = _R(208, ColorPalette);
+}

package/gen/classes/ColorPicker.ts

@@ -0,0 +1,197 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { VBoxContainer } from './VBoxContainer.ts';
+import type { PackedColorArray, Signal } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+
+/**
+ * A widget that provides an interface for selecting or modifying a color. It can optionally provide functionalities like a color sampler (eyedropper), color modes, and presets.
+ * **Note:** This control is the color picker widget itself. You can use a {@link ColorPickerButton} instead if you need a button that brings up a {@link ColorPicker} in a popup.
+ */
+export class ColorPicker extends VBoxContainer {
+    constructor(name = 209) { super(name); }
+
+    /**
+     * Adds the given color to a list of color presets. The presets are displayed in the color picker and the user will be able to select them.
+     * **Note:** The presets list is only for *this* color picker.
+     */
+    addPreset(color: Color): void { _C(this, 1275, color); }
+
+    /**
+     * Removes the given color from the list of color presets of this color picker.
+     */
+    erasePreset(color: Color): void { _C(this, 3160, color); }
+
+    /**
+     * Returns the list of colors in the presets of the color picker.
+     */
+    getPresets(): PackedColorArray { return _C(this, 5994) as PackedColorArray; }
+
+    /**
+     * Adds the given color to a list of color recent presets so that it can be picked later. Recent presets are the colors that were picked recently, a new preset is automatically created and added to recent presets when you pick a new color.
+     * **Note:** The recent presets list is only for *this* color picker.
+     */
+    addRecentPreset(color: Color): void { _C(this, 1281, color); }
+
+    /**
+     * Removes the given color from the list of color recent presets of this color picker.
+     */
+    eraseRecentPreset(color: Color): void { _C(this, 3161, color); }
+
+    /**
+     * Returns the list of colors in the recent presets of the color picker.
+     */
+    getRecentPresets(): PackedColorArray { return _C(this, 6088) as PackedColorArray; }
+
+    /**
+     * The currently selected color.
+     */
+    get color(): Color { return _C(this, 5906) as Color; }
+    set color(v: Color) { _C(this, 12326, v); }
+
+    /**
+     * If `true`, shows an alpha channel slider (opacity).
+     */
+    get editAlpha(): boolean { return _C(this, 7919) as boolean; }
+    set editAlpha(v: boolean) { _C(this, 11213, v); }
+
+    /**
+     * If `true`, shows an intensity slider. The intensity is applied as follows: convert the color to linear encoding, multiply it by `2 ** intensity`, and then convert it back to nonlinear sRGB encoding.
+     */
+    get editIntensity(): boolean { return _C(this, 7920) as boolean; }
+    set editIntensity(v: boolean) { _C(this, 11214, v); }
+
+    /**
+     * The currently selected color mode.
+     */
+    get colorMode(): ColorModeType { return _C(this, 4227) as ColorModeType; }
+    set colorMode(v: ColorModeType) { _C(this, 10911, v); }
+
+    /**
+     * If `true`, the color will apply only after the user releases the mouse button, otherwise it will apply immediately even in mouse motion event (which can cause performance issues).
+     */
+    get deferredMode(): boolean { return _C(this, 7876) as boolean; }
+    set deferredMode(v: boolean) { _C(this, 11072, v); }
+
+    /**
+     * The shape of the color space view.
+     */
+    get pickerShape(): PickerShapeType { return _C(this, 5908) as PickerShapeType; }
+    set pickerShape(v: PickerShapeType) { _C(this, 12328, v); }
+
+    /**
+     * If `true`, it's possible to add presets under Swatches. If `false`, the button to add presets is disabled.
+     */
+    get canAddSwatches(): boolean { return _C(this, 1549) as boolean; }
+    set canAddSwatches(v: boolean) { _C(this, 10789, v); }
+
+    /**
+     * If `true`, the color sampler and color preview are visible.
+     */
+    get samplerVisible(): boolean { return _C(this, 8264) as boolean; }
+    set samplerVisible(v: boolean) { _C(this, 12604, v); }
+
+    /**
+     * If `true`, the color mode buttons are visible.
+     */
+    get colorModesVisible(): boolean { return _C(this, 1544) as boolean; }
+    set colorModesVisible(v: boolean) { _C(this, 12076, v); }
+
+    /**
+     * If `true`, the color sliders are visible.
+     */
+    get slidersVisible(): boolean { return _C(this, 1548) as boolean; }
+    set slidersVisible(v: boolean) { _C(this, 12781, v); }
+
+    /**
+     * If `true`, the hex color code input field is visible.
+     */
+    get hexVisible(): boolean { return _C(this, 7991) as boolean; }
+    set hexVisible(v: boolean) { _C(this, 11620, v); }
+
+    /**
+     * If `true`, the Swatches and Recent Colors presets are visible.
+     */
+    get presetsVisible(): boolean { return _C(this, 1546) as boolean; }
+    set presetsVisible(v: boolean) { _C(this, 12403, v); }
+
+    /**
+     * Emitted when the color is changed.
+     */
+    get colorChanged(): Signal<(color: Color) => void> { return _G(this, 2368) as Signal<(color: Color) => void>; }
+    set colorChanged(v: ((color: Color) => void) | null) { _G(this, 2368, v); }
+
+    /**
+     * Emitted when a preset is added.
+     */
+    get presetAdded(): Signal<(color: Color) => void> { return _G(this, 9539) as Signal<(color: Color) => void>; }
+    set presetAdded(v: ((color: Color) => void) | null) { _G(this, 9539, v); }
+
+    /**
+     * Emitted when a preset is removed.
+     */
+    get presetRemoved(): Signal<(color: Color) => void> { return _G(this, 9540) as Signal<(color: Color) => void>; }
+    set presetRemoved(v: ((color: Color) => void) | null) { _G(this, 9540, v); }
+
+    static readonly name = _R(209, ColorPicker);
+}
+
+export const ColorModeType = {
+    /**
+     * Allows editing the color with Red/Green/Blue sliders in sRGB color space.
+     */
+    MODE_RGB: 0,
+    /**
+     * Allows editing the color with Hue/Saturation/Value sliders.
+     */
+    MODE_HSV: 1,
+    MODE_RAW: 2,
+    /**
+     * Allows editing the color with Red/Green/Blue sliders in linear color space.
+     */
+    MODE_LINEAR: 2,
+    /**
+     * Allows editing the color with Hue/Saturation/Lightness sliders.
+     * OKHSL is a new color space similar to HSL but that better match perception by leveraging the Oklab color space which is designed to be simple to use, while doing a good job at predicting perceived lightness, chroma and hue.
+     * [Okhsv and Okhsl color spaces](https://bottosson.github.io/posts/colorpicker/)
+     */
+    MODE_OKHSL: 3,
+} as const;
+
+export type ColorModeType = (typeof ColorModeType)[keyof typeof ColorModeType];
+
+export const PickerShapeType = {
+    /**
+     * HSV Color Model rectangle color space.
+     */
+    SHAPE_HSV_RECTANGLE: 0,
+    /**
+     * HSV Color Model rectangle color space with a wheel.
+     */
+    SHAPE_HSV_WHEEL: 1,
+    /**
+     * HSV Color Model circle color space. Use Saturation as a radius.
+     */
+    SHAPE_VHS_CIRCLE: 2,
+    /**
+     * HSL OK Color Model circle color space.
+     */
+    SHAPE_OKHSL_CIRCLE: 3,
+    /**
+     * The color space shape and the shape select button are hidden. Can't be selected from the shapes popup.
+     */
+    SHAPE_NONE: 4,
+    /**
+     * OKHSL Color Model rectangle with constant lightness.
+     */
+    SHAPE_OK_HS_RECTANGLE: 5,
+    /**
+     * OKHSL Color Model rectangle with constant saturation.
+     */
+    SHAPE_OK_HL_RECTANGLE: 6,
+} as const;
+
+export type PickerShapeType = (typeof PickerShapeType)[keyof typeof PickerShapeType];
+

package/gen/classes/ColorPickerButton.ts

@@ -0,0 +1,68 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Button } from './Button.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+import type { ColorPicker } from './ColorPicker.ts';
+import type { PopupPanel } from './PopupPanel.ts';
+
+/**
+ * Encapsulates a {@link ColorPicker}, making it accessible by pressing a button. Pressing the button will toggle the {@link ColorPicker}'s visibility.
+ * See also {@link BaseButton} which contains common properties and methods associated with this node.
+ * **Note:** By default, the button may not be wide enough for the color preview swatch to be visible. Make sure to set {@link Control.customMinimumSize} to a big enough value to give the button enough space.
+ */
+export class ColorPickerButton extends Button {
+    constructor(name = 210) { super(name); }
+
+    /**
+     * Returns the {@link ColorPicker} that this node toggles.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link CanvasItem.visible} property.
+     */
+    getPicker(): ColorPicker { return _C(this, 5907) as ColorPicker; }
+
+    /**
+     * Returns the control's {@link PopupPanel} which allows you to connect to popup signals. This allows you to handle events when the ColorPicker is shown or hidden.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link Window.visible} property.
+     */
+    getPopup(): PopupPanel { return _C(this, 5966) as PopupPanel; }
+
+    /**
+     * The currently selected color.
+     */
+    get color(): Color { return _C(this, 5906) as Color; }
+    set color(v: Color) { _C(this, 12326, v); }
+
+    /**
+     * If `true`, the alpha channel in the displayed {@link ColorPicker} will be visible.
+     */
+    get editAlpha(): boolean { return _C(this, 7919) as boolean; }
+    set editAlpha(v: boolean) { _C(this, 11213, v); }
+
+    /**
+     * If `true`, the intensity slider in the displayed {@link ColorPicker} will be visible.
+     */
+    get editIntensity(): boolean { return _C(this, 7920) as boolean; }
+    set editIntensity(v: boolean) { _C(this, 11214, v); }
+
+    /**
+     * Emitted when the color changes.
+     */
+    get colorChanged(): Signal<(color: Color) => void> { return _G(this, 2368) as Signal<(color: Color) => void>; }
+    set colorChanged(v: ((color: Color) => void) | null) { _G(this, 2368, v); }
+
+    /**
+     * Emitted when the {@link ColorPicker} is closed.
+     */
+    get popupClosed(): Signal<() => void> { return _G(this, 9486) as Signal<() => void>; }
+    set popupClosed(v: (() => void) | null) { _G(this, 9486, v); }
+
+    /**
+     * Emitted when the {@link ColorPicker} is created (the button is pressed for the first time).
+     */
+    get pickerCreated(): Signal<() => void> { return _G(this, 9418) as Signal<() => void>; }
+    set pickerCreated(v: (() => void) | null) { _G(this, 9418, v); }
+
+    static readonly name = _R(210, ColorPickerButton);
+}

package/gen/classes/ColorRect.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+import type { Color } from '../value-types/index.ts';
+
+/**
+ * Displays a rectangle filled with a solid {@link color}. If you need to display the border alone, consider using a {@link Panel} instead.
+ */
+export class ColorRect extends Control {
+    constructor(name = 211) { super(name); }
+
+    /**
+     * The fill color of the rectangle.
+     */
+    get color(): Color { return _C(this, 4219) as Color; }
+    set color(v: Color) { _C(this, 10905, v); }
+
+    static readonly name = _R(211, ColorRect);
+}

package/gen/classes/Compositor.ts

@@ -0,0 +1,22 @@
+// 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 } from '../heap-types/index.ts';
+import type { CompositorEffect } from './CompositorEffect.ts';
+
+/**
+ * The compositor resource stores attributes used to customize how a {@link Viewport} is rendered.
+ */
+export class Compositor extends Resource {
+    constructor(name = 212) { super(name); }
+
+    /**
+     * The custom {@link CompositorEffect}s that are applied during rendering of viewports using this compositor.
+     */
+    get compositorEffects(): GodotArray<CompositorEffect> { return _C(this, 4251) as GodotArray<CompositorEffect>; }
+    set compositorEffects(v: GodotArray<CompositorEffect>) { _C(this, 10932, v); }
+
+    static readonly name = _R(212, Compositor);
+}

package/gen/classes/CompositorEffect.ts

@@ -0,0 +1,134 @@
+// 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 { RenderData } from './RenderData.ts';
+
+/**
+ * This resource defines a custom rendering effect that can be applied to {@link Viewport}s through the viewports' {@link Environment}. You can implement a callback that is called during rendering at a given stage of the rendering pipeline and allows you to insert additional passes. Note that this callback happens on the rendering thread. CompositorEffect is an abstract base class and must be extended to implement specific rendering logic.
+ */
+export class CompositorEffect extends Resource {
+    constructor(name = 213) { super(name); }
+
+    /**
+     * If `true` this rendering effect is applied to any viewport it is added to.
+     */
+    get enabled(): boolean { return _C(this, 4656) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * The type of effect that is implemented, determines at what stage of rendering the callback is called.
+     */
+    get effectCallbackType(): EffectCallbackType { return _C(this, 4606) as EffectCallbackType; }
+    set effectCallbackType(v: EffectCallbackType) { _C(this, 11223, v); }
+
+    /**
+     * If `true` and MSAA is enabled, this will trigger a color buffer resolve before the effect is run.
+     * **Note:** In {@link _renderCallback}, to access the resolved buffer use:
+     *
+     * ```text
+     *
+     * var render_scene_buffers = render_data.get_render_scene_buffers()
+     * var color_buffer = render_scene_buffers.get_texture("render_buffers", "color")
+     *
+     * ```
+     */
+    get accessResolvedColor(): boolean { return _C(this, 3663) as boolean; }
+    set accessResolvedColor(v: boolean) { _C(this, 10403, v); }
+
+    /**
+     * If `true` and MSAA is enabled, this will trigger a depth buffer resolve before the effect is run.
+     * **Note:** In {@link _renderCallback}, to access the resolved buffer use:
+     *
+     * ```text
+     *
+     * var render_scene_buffers = render_data.get_render_scene_buffers()
+     * var depth_buffer = render_scene_buffers.get_texture("render_buffers", "depth")
+     *
+     * ```
+     */
+    get accessResolvedDepth(): boolean { return _C(this, 3664) as boolean; }
+    set accessResolvedDepth(v: boolean) { _C(this, 10404, v); }
+
+    /**
+     * If `true` this triggers motion vectors being calculated during the opaque render state.
+     * **Note:** In {@link _renderCallback}, to access the motion vector buffer use:
+     *
+     * ```text
+     *
+     * var render_scene_buffers = render_data.get_render_scene_buffers()
+     * var motion_buffer = render_scene_buffers.get_velocity_texture()
+     *
+     * ```
+     */
+    get needsMotionVectors(): boolean { return _C(this, 5617) as boolean; }
+    set needsMotionVectors(v: boolean) { _C(this, 12125, v); }
+
+    /**
+     * If `true` this triggers normal and roughness data to be output during our depth pre-pass, only applicable for the Forward+ renderer.
+     * **Note:** In {@link _renderCallback}, to access the roughness buffer use:
+     *
+     * ```text
+     *
+     * var render_scene_buffers = render_data.get_render_scene_buffers()
+     * var roughness_buffer = render_scene_buffers.get_texture("forward_clustered", "normal_roughness")
+     *
+     * ```
+     *
+     * The raw normal and roughness buffer is stored in an optimized format, different than the one available in Spatial shaders. When sampling the buffer, a conversion function must be applied. Use this function, copied from [here](https://github.com/godotengine/godot/blob/da5f39889f155658cef7f7ec3cc1abb94e17d815/servers/rendering/renderer_rd/shaders/forward_clustered/scene_forward_clustered_inc.glsl#L334-L341):
+     *
+     * ```text
+     *
+     * vec4 normal_roughness_compatibility(vec4 p_normal_roughness) {
+     * 	float roughness = p_normal_roughness.w;
+     * 	if (roughness > 0.5) {
+     * 		roughness = 1.0 - roughness;
+     * 	}
+     * 	roughness /= (127.0 / 255.0);
+     * 	return vec4(normalize(p_normal_roughness.xyz * 2.0 - 1.0) * 0.5 + 0.5, roughness);
+     * }
+     *
+     * ```
+     */
+    get needsNormalRoughness(): boolean { return _C(this, 5618) as boolean; }
+    set needsNormalRoughness(v: boolean) { _C(this, 12126, v); }
+
+    /**
+     * If `true` this triggers specular data being rendered to a separate buffer and combined after effects have been applied, only applicable for the Forward+ renderer.
+     */
+    get needsSeparateSpecular(): boolean { return _C(this, 5619) as boolean; }
+    set needsSeparateSpecular(v: boolean) { _C(this, 12127, v); }
+
+    static readonly name = _R(213, CompositorEffect);
+}
+
+export const EffectCallbackType = {
+    /**
+     * The callback is called before our opaque rendering pass, but after depth prepass (if applicable).
+     */
+    EFFECT_CALLBACK_TYPE_PRE_OPAQUE: 0,
+    /**
+     * The callback is called after our opaque rendering pass, but before our sky is rendered.
+     */
+    EFFECT_CALLBACK_TYPE_POST_OPAQUE: 1,
+    /**
+     * The callback is called after our sky is rendered, but before our back buffers are created (and if enabled, before subsurface scattering and/or screen space reflections).
+     */
+    EFFECT_CALLBACK_TYPE_POST_SKY: 2,
+    /**
+     * The callback is called before our transparent rendering pass, but after our sky is rendered and we've created our back buffers.
+     */
+    EFFECT_CALLBACK_TYPE_PRE_TRANSPARENT: 3,
+    /**
+     * The callback is called after our transparent rendering pass, but before any built-in post-processing effects and output to our render target.
+     */
+    EFFECT_CALLBACK_TYPE_POST_TRANSPARENT: 4,
+    /**
+     * Represents the size of the {@link EffectCallbackType} enum.
+     */
+    EFFECT_CALLBACK_TYPE_MAX: 5,
+} as const;
+
+export type EffectCallbackType = (typeof EffectCallbackType)[keyof typeof EffectCallbackType];
+

package/gen/classes/CompressedCubemap.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CompressedTextureLayered } from './CompressedTextureLayered.ts';
+
+/**
+ * A cubemap that is loaded from a `.ccube` file. This file format is internal to Godot; it is created by importing other image formats with the import system. {@link CompressedCubemap} can use one of 4 compression methods:
+ * - Lossless (WebP or PNG, uncompressed on the GPU)
+ * - Lossy (WebP, uncompressed on the GPU)
+ * - VRAM Compressed (compressed on the GPU)
+ * - VRAM Uncompressed (uncompressed on the GPU)
+ * - Basis Universal (compressed on the GPU. Lower file sizes than VRAM Compressed, but slower to compress and lower quality than VRAM Compressed)
+ * Only **VRAM Compressed** actually reduces the memory usage on the GPU. The **Lossless** and **Lossy** compression methods will reduce the required storage on disk, but they will not reduce memory usage on the GPU as the texture is sent to the GPU uncompressed.
+ * Using **VRAM Compressed** also improves loading times, as VRAM-compressed textures are faster to load compared to textures using lossless or lossy compression. VRAM compression can exhibit noticeable artifacts and is intended to be used for 3D rendering, not 2D.
+ * See {@link Cubemap} for a general description of cubemaps.
+ */
+export class CompressedCubemap extends CompressedTextureLayered {
+    constructor(name = 214) { super(name); }
+
+    static readonly name = _R(214, CompressedCubemap);
+}