@ringozz/godot 0.1.0

package/gen/classes/PrimitiveMesh.ts

@@ -0,0 +1,69 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Mesh } from './Mesh.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { AABB } from '../value-types/index.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * Base class for all primitive meshes. Handles applying a {@link Material} to a primitive mesh. Examples include {@link BoxMesh}, {@link CapsuleMesh}, {@link CylinderMesh}, {@link PlaneMesh}, {@link PrismMesh}, and {@link SphereMesh}.
+ */
+export class PrimitiveMesh extends Mesh {
+    constructor(name = 607) { super(name); }
+
+    /**
+     * Returns the mesh arrays used to make up the surface of this primitive mesh.
+     * **Example:** Pass the result to {@link ArrayMesh.addSurfaceFromArrays} to create a new surface:
+     *
+     *
+     * ```gdscript
+     *
+     * var c = CylinderMesh.new()
+     * var arr_mesh = ArrayMesh.new()
+     * arr_mesh.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, c.get_mesh_arrays())
+     *
+     * ```
+     */
+    getMeshArrays(): GodotArray { return _C(this, 5512) as GodotArray; }
+
+    /**
+     * Request an update of this primitive mesh based on its properties.
+     */
+    requestUpdate(): void { _C(this, 10060); }
+
+    /**
+     * The current {@link Material} of the primitive mesh.
+     */
+    get material(): Material { return _C(this, 5452) as Material; }
+    set material(v: Material) { _C(this, 11978, v); }
+
+    /**
+     * Overrides the {@link AABB} with one defined by user for use with frustum culling. Especially useful to avoid unexpected culling when using a shader to offset vertices.
+     */
+    get customAabb(): AABB { return _C(this, 4375) as AABB; }
+    set customAabb(v: AABB) { _C(this, 10999, v); }
+
+    /**
+     * If `true`, the order of the vertices in each triangle is reversed, resulting in the backside of the mesh being drawn.
+     * This gives the same result as using {@link BaseMaterial3D.CULL_FRONT} in {@link BaseMaterial3D.cullMode}.
+     */
+    get flipFaces(): boolean { return _C(this, 4810) as boolean; }
+    set flipFaces(v: boolean) { _C(this, 11416, v); }
+
+    /**
+     * If set, generates UV2 UV coordinates applying a padding using the {@link uv2Padding} setting. UV2 is needed for lightmapping.
+     */
+    get addUv2(): boolean { return _C(this, 3693) as boolean; }
+    set addUv2(v: boolean) { _C(this, 10427, v); }
+
+    /**
+     * If {@link addUv2} is set, specifies the padding in pixels applied along seams of the mesh. Lower padding values allow making better use of the lightmap texture (resulting in higher texel density), but may introduce visible lightmap bleeding along edges.
+     * If the size of the lightmap texture can't be determined when generating the mesh, UV2 is calculated assuming a texture size of 1024x1024.
+     */
+    get uv2Padding(): number { return _C(this, 7007) as number; }
+    set uv2Padding(v: number) { _C(this, 13257, v); }
+
+    static readonly name = _R(607, PrimitiveMesh);
+}

package/gen/classes/PrismMesh.ts

@@ -0,0 +1,45 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PrimitiveMesh } from './PrimitiveMesh.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * Class representing a prism-shaped {@link PrimitiveMesh}.
+ */
+export class PrismMesh extends PrimitiveMesh {
+    constructor(name = 608) { super(name); }
+
+    /**
+     * Displacement of the upper edge along the X axis. 0.0 positions edge straight above the bottom-left edge.
+     */
+    get leftToRight(): number { return _C(this, 5330) as number; }
+    set leftToRight(v: number) { _C(this, 11890, v); }
+
+    /**
+     * Size of the prism.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    /**
+     * Number of added edge loops along the X axis.
+     */
+    get subdivideWidth(): number { return _C(this, 6600) as number; }
+    set subdivideWidth(v: number) { _C(this, 12926, v); }
+
+    /**
+     * Number of added edge loops along the Y axis.
+     */
+    get subdivideHeight(): number { return _C(this, 6599) as number; }
+    set subdivideHeight(v: number) { _C(this, 12925, v); }
+
+    /**
+     * Number of added edge loops along the Z axis.
+     */
+    get subdivideDepth(): number { return _C(this, 6598) as number; }
+    set subdivideDepth(v: number) { _C(this, 12924, v); }
+
+    static readonly name = _R(608, PrismMesh);
+}

package/gen/classes/ProceduralSkyMaterial.ts

@@ -0,0 +1,102 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Material } from './Material.ts';
+import type { Color } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * {@link ProceduralSkyMaterial} provides a way to create an effective background quickly by defining procedural parameters for the sun, the sky and the ground. The sky and ground are defined by a main color, a color at the horizon, and an easing curve to interpolate between them. Suns are described by a position in the sky, a color, and a max angle from the sun at which the easing curve ends. The max angle therefore defines the size of the sun in the sky.
+ * {@link ProceduralSkyMaterial} supports up to 4 suns, using the color, and energy, direction, and angular distance of the first four {@link DirectionalLight3D} nodes in the scene. This means that the suns are defined individually by the properties of their corresponding {@link DirectionalLight3D}s and globally by {@link sunAngleMax} and {@link sunCurve}.
+ * {@link ProceduralSkyMaterial} uses a lightweight shader to draw the sky and is therefore suited for real-time updates. This makes it a great option for a sky that is simple and computationally cheap, but unrealistic. If you need a more realistic procedural option, use {@link PhysicalSkyMaterial}.
+ */
+export class ProceduralSkyMaterial extends Material {
+    constructor(name = 609) { super(name); }
+
+    /**
+     * Color of the sky at the top. Blends with {@link skyHorizonColor}.
+     */
+    get skyTopColor(): Color { return _C(this, 6428) as Color; }
+    set skyTopColor(v: Color) { _C(this, 12776, v); }
+
+    /**
+     * Color of the sky at the horizon. Blends with {@link skyTopColor}.
+     */
+    get skyHorizonColor(): Color { return _C(this, 6425) as Color; }
+    set skyHorizonColor(v: Color) { _C(this, 12773, v); }
+
+    /**
+     * How quickly the {@link skyHorizonColor} fades into the {@link skyTopColor}.
+     */
+    get skyCurve(): number { return _C(this, 6422) as number; }
+    set skyCurve(v: number) { _C(this, 12770, v); }
+
+    /**
+     * Multiplier for sky color. A higher value will make the sky brighter.
+     */
+    get skyEnergyMultiplier(): number { return _C(this, 6424) as number; }
+    set skyEnergyMultiplier(v: number) { _C(this, 12772, v); }
+
+    /**
+     * The sky cover texture to use. This texture must use an equirectangular projection (similar to {@link PanoramaSkyMaterial}). The texture's colors will be *added* to the existing sky color, and will be multiplied by {@link skyEnergyMultiplier} and {@link skyCoverModulate}. This is mainly suited to displaying stars at night, but it can also be used to display clouds at day or night (with a non-physically-accurate look).
+     */
+    get skyCover(): Texture2D { return _C(this, 6420) as Texture2D; }
+    set skyCover(v: Texture2D) { _C(this, 12768, v); }
+
+    /**
+     * The tint to apply to the {@link skyCover} texture. This can be used to change the sky cover's colors or opacity independently of the sky energy, which is useful for day/night or weather transitions. Only effective if a texture is defined in {@link skyCover}.
+     */
+    get skyCoverModulate(): Color { return _C(this, 6421) as Color; }
+    set skyCoverModulate(v: Color) { _C(this, 12769, v); }
+
+    /**
+     * Color of the ground at the bottom. Blends with {@link groundHorizonColor}.
+     */
+    get groundBottomColor(): Color { return _C(this, 4980) as Color; }
+    set groundBottomColor(v: Color) { _C(this, 11563, v); }
+
+    /**
+     * Color of the ground at the horizon. Blends with {@link groundBottomColor}.
+     */
+    get groundHorizonColor(): Color { return _C(this, 4984) as Color; }
+    set groundHorizonColor(v: Color) { _C(this, 11567, v); }
+
+    /**
+     * How quickly the {@link groundHorizonColor} fades into the {@link groundBottomColor}.
+     */
+    get groundCurve(): number { return _C(this, 4982) as number; }
+    set groundCurve(v: number) { _C(this, 11565, v); }
+
+    /**
+     * Multiplier for ground color. A higher value will make the ground brighter.
+     */
+    get groundEnergyMultiplier(): number { return _C(this, 4983) as number; }
+    set groundEnergyMultiplier(v: number) { _C(this, 11566, v); }
+
+    /**
+     * Distance from center of sun where it fades out completely.
+     */
+    get sunAngleMax(): number { return _C(this, 6608) as number; }
+    set sunAngleMax(v: number) { _C(this, 12932, v); }
+
+    /**
+     * How quickly the sun fades away between the edge of the sun disk and {@link sunAngleMax}.
+     */
+    get sunCurve(): number { return _C(this, 6609) as number; }
+    set sunCurve(v: number) { _C(this, 12933, v); }
+
+    /**
+     * If `true`, enables debanding. Debanding adds a small amount of noise which helps reduce banding that appears from the smooth changes in color in the sky.
+     */
+    get useDebanding(): boolean { return _C(this, 6974) as boolean; }
+    set useDebanding(v: boolean) { _C(this, 13208, v); }
+
+    /**
+     * The sky's overall brightness multiplier. Higher values result in a brighter sky.
+     */
+    get energyMultiplier(): number { return _C(this, 4669) as number; }
+    set energyMultiplier(v: number) { _C(this, 11296, v); }
+
+    static readonly name = _R(609, ProceduralSkyMaterial);
+}

package/gen/classes/ProgressBar.ts

@@ -0,0 +1,60 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Range } from './Range.ts';
+
+/**
+ * A control used for visual representation of a percentage. Shows the fill percentage in the center. Can also be used to show indeterminate progress. For more fill modes, use {@link TextureProgressBar} instead.
+ */
+export class ProgressBar extends Range {
+    constructor(name = 610) { super(name); }
+
+    /**
+     * The fill direction. See {@link FillMode} for possible values.
+     */
+    get fillMode(): number { return _C(this, 4782) as number; }
+    set fillMode(v: number) { _C(this, 11385, v); }
+
+    /**
+     * If `true`, the fill percentage is displayed on the bar.
+     */
+    get showPercentage(): boolean { return _C(this, 8173) as boolean; }
+    set showPercentage(v: boolean) { _C(this, 12735, v); }
+
+    /**
+     * When set to `true`, the progress bar indicates that something is happening with an animation, but does not show the fill percentage or value.
+     */
+    get indeterminate(): boolean { return _C(this, 8022) as boolean; }
+    set indeterminate(v: boolean) { _C(this, 11686, v); }
+
+    /**
+     * If `false`, the {@link indeterminate} animation will be paused in the editor.
+     */
+    get editorPreviewIndeterminate(): boolean { return _C(this, 7924) as boolean; }
+    set editorPreviewIndeterminate(v: boolean) { _C(this, 11222, v); }
+
+    static readonly name = _R(610, ProgressBar);
+}
+
+export const FillMode = {
+    /**
+     * The progress bar fills from begin to end horizontally, according to the language direction. If {@link Control.isLayoutRtl} returns `false`, it fills from left to right, and if it returns `true`, it fills from right to left.
+     */
+    FILL_BEGIN_TO_END: 0,
+    /**
+     * The progress bar fills from end to begin horizontally, according to the language direction. If {@link Control.isLayoutRtl} returns `false`, it fills from right to left, and if it returns `true`, it fills from left to right.
+     */
+    FILL_END_TO_BEGIN: 1,
+    /**
+     * The progress fills from top to bottom.
+     */
+    FILL_TOP_TO_BOTTOM: 2,
+    /**
+     * The progress fills from bottom to top.
+     */
+    FILL_BOTTOM_TO_TOP: 3,
+} as const;
+
+export type FillMode = (typeof FillMode)[keyof typeof FillMode];
+

package/gen/classes/ProjectSettings.ts

@@ -0,0 +1,233 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, PackedStringArray, Signal, StringName, Variant } from '../heap-types/index.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 611));
+
+/**
+ * Stores variables that can be accessed from everywhere. Use {@link getSetting}, {@link setSetting} or {@link hasSetting} to access them. Variables stored in `project.godot` are also loaded into {@link ProjectSettings}, making this object very useful for reading custom game configuration options.
+ * When naming a Project Settings property, use the full path to the setting including the category. For example, `"application/config/name"` for the project name. Category and property names can be viewed in the Project Settings dialog.
+ * **Feature tags:** Project settings can be overridden for specific platforms and configurations (debug, release, ...) using [feature tags]($DOCS_URL/tutorials/export/feature_tags.html).
+ * **Overriding:** Any project setting can be overridden by creating a file named `override.cfg` in the project's root directory. This file is in the same format as `project.godot`, and can also be written using {@link ConfigFile}. This can also be used in exported projects by placing this file in the same directory as the project binary. Overriding will still take the base project settings' [feature tags]($DOCS_URL/tutorials/export/feature_tags.html) in account. Therefore, make sure to *also* override the setting with the desired feature tags if you want them to override base project settings on all platforms and configurations.
+ */
+export class ProjectSettings extends GodotVar {
+
+    /**
+     * Returns `true` if a configuration value is present.
+     * **Note:** In order to be be detected, custom settings have to be either defined with {@link setSetting}, or exist in the `project.godot` file. This is especially relevant when using {@link setInitialValue}.
+     */
+    static hasSetting(name: string): boolean { return _C($(), 7445, name) as boolean; }
+
+    /**
+     * Sets the value of a setting.
+     *
+     *
+     * ```gdscript
+     *
+     * ProjectSettings.set_setting("application/config/name", "Example")
+     *
+     * ```
+     *
+     *
+     *
+     * This can also be used to erase custom project settings. To do this change the setting value to `null`.
+     */
+    static setSetting(name: string, value: Variant): void { _C($(), 12699, name, value); }
+
+    /**
+     * Returns the value of the setting identified by `name`. If the setting doesn't exist and `defaultValue` is specified, the value of `defaultValue` is returned. Otherwise, `null` is returned.
+     *
+     *
+     * ```gdscript
+     *
+     * print(ProjectSettings.get_setting("application/config/name"))
+     * print(ProjectSettings.get_setting("application/config/custom_description", "No description specified."))
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** This method doesn't take potential feature overrides into account automatically. Use {@link getSettingWithOverride} to handle seamlessly.
+     * See also {@link hasSetting} to check whether a setting exists.
+     */
+    static getSetting(name: string, defaultValue?: Variant /* = null */): Variant { return _C($(), 6349, name, defaultValue) as Variant; }
+
+    /**
+     * Similar to {@link getSetting}, but applies feature tag overrides if any exists and is valid.
+     * **Example:** If the setting override `"application/config/name.windows"` exists, and the following code is executed on a *Windows* operating system, the overridden setting is printed instead:
+     *
+     *
+     * ```gdscript
+     *
+     * print(ProjectSettings.get_setting_with_override("application/config/name"))
+     *
+     * ```
+     */
+    static getSettingWithOverride(name: StringName): Variant { return _C($(), 6351, name) as Variant; }
+
+    /**
+     * Returns an {@link Array} of registered global classes. Each global class is represented as a {@link Dictionary} that contains the following entries:
+     * - `base` is a name of the base class;
+     * - `class` is a name of the registered global class;
+     * - `icon` is a path to a custom icon of the global class, if it has any;
+     * - `language` is a name of a programming language in which the global class is written;
+     * - `path` is a path to a file containing the global class.
+     * **Note:** Both the script and the icon paths are local to the project filesystem, i.e. they start with `res://`.
+     */
+    static getGlobalClassList(): GodotArray<GodotDictionary> { return _C($(), 4925) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Similar to {@link getSettingWithOverride}, but applies feature tag overrides instead of current OS features.
+     */
+    static getSettingWithOverrideAndCustomFeatures(name: StringName, features: PackedStringArray): Variant { return _C($(), 6352, name, features) as Variant; }
+
+    /**
+     * Sets the order of a configuration value (influences when saved to the config file).
+     */
+    static setOrder(name: string, position: number): void { _C($(), 12199, name, position); }
+
+    /**
+     * Returns the order of a configuration value (influences when saved to the config file).
+     */
+    static getOrder(name: string): number { return _C($(), 5737, name) as number; }
+
+    /**
+     * Sets the specified setting's initial value. This is the value the setting reverts to. The setting should already exist before calling this method. Note that project settings equal to their default value are not saved, so your code needs to account for that.
+     *
+     * ```text
+     *
+     * extends EditorPlugin
+     *
+     * const SETTING_NAME = "addons/my_setting"
+     * const SETTING_DEFAULT = 10.0
+     *
+     * func _enter_tree():
+     * 	if not ProjectSettings.has_setting(SETTING_NAME):
+     * 		ProjectSettings.set_setting(SETTING_NAME, SETTING_DEFAULT)
+     *
+     * 	ProjectSettings.set_initial_value(SETTING_NAME, SETTING_DEFAULT)
+     *
+     * ```
+     *
+     * If you have a project setting defined by an {@link EditorPlugin}, but want to use it in a running project, you will need a similar code at runtime.
+     */
+    static setInitialValue(name: string, value: Variant): void { _C($(), 11704, name, value); }
+
+    /**
+     * Defines if the specified setting is considered basic or advanced. Basic settings will always be shown in the project settings. Advanced settings will only be shown if the user enables the "Advanced Settings" option.
+     */
+    static setAsBasic(name: string, basic: boolean): void { _C($(), 10536, name, basic); }
+
+    /**
+     * Defines if the specified setting is considered internal. An internal setting won't show up in the Project Settings dialog. This is mostly useful for addons that need to store their own internal settings without exposing them directly to the user.
+     */
+    static setAsInternal(name: string, internal: boolean): void { _C($(), 10538, name, internal); }
+
+    /**
+     * Adds a custom property info to a property. The dictionary must contain:
+     * - `"name"`: {@link String} (the property's name)
+     * - `"type"`: {@link int} (see {@link Variant.Type})
+     * - optionally `"hint"`: {@link int} (see {@link PropertyHint}) and `"hint_string"`: {@link String}
+     *
+     *
+     * ```gdscript
+     *
+     * ProjectSettings.set("category/property_name", 0)
+     *
+     * var property_info = {
+     * 	"name": "category/property_name",
+     * 	"type": TYPE_INT,
+     * 	"hint": PROPERTY_HINT_ENUM,
+     * 	"hint_string": "one,two,three"
+     * }
+     *
+     * ProjectSettings.add_property_info(property_info)
+     *
+     * ```
+     *
+     *
+     *
+     * **Note:** Setting `"usage"` for the property is not supported. Use {@link setAsBasic}, {@link setRestartIfChanged}, and {@link setAsInternal} to modify usage flags.
+     */
+    static addPropertyInfo(hint: GodotDictionary): void { _C($(), 1278, hint); }
+
+    /**
+     * Sets whether a setting requires restarting the editor to properly take effect.
+     * **Note:** This is just a hint to display to the user that the editor must be restarted for changes to take effect. Enabling {@link setRestartIfChanged} does *not* delay the setting being set when changed.
+     */
+    static setRestartIfChanged(name: string, restart: boolean): void { _C($(), 12546, name, restart); }
+
+    /**
+     * Clears the whole configuration (not recommended, may break things).
+     */
+    static clear(name: string): void { _C($(), 2232, name); }
+
+    /**
+     * Returns the localized path (starting with `res://`) corresponding to the absolute, native OS `path`. See also {@link globalizePath}.
+     */
+    static localizePath(path: string): string { return _C($(), 8697, path) as string; }
+
+    /**
+     * Returns the absolute, native OS path corresponding to the localized `path` (starting with `res://` or `user://`). The returned path will vary depending on the operating system and user preferences. See [File paths in Godot projects]($DOCS_URL/tutorials/io/data_paths.html) to see what those paths convert to. See also {@link localizePath}.
+     * **Note:** {@link globalizePath} with `res://` will not work in an exported project. Instead, prepend the executable's base directory to the path when running from an exported project:
+     *
+     * ```text
+     *
+     * var path = ""
+     * if OS.has_feature("editor"):
+     * 	# Running from an editor binary.
+     * 	# `path` will contain the absolute path to `hello.txt` located in the project root.
+     * 	path = ProjectSettings.globalize_path("res://hello.txt")
+     * else:
+     * 	# Running from an exported project.
+     * 	# `path` will contain the absolute path to `hello.txt` next to the executable.
+     * 	# This is *not* identical to using `ProjectSettings.globalize_path()` with a `res://` path,
+     * 	# but is close enough in spirit.
+     * 	path = OS.get_executable_path().get_base_dir().path_join("hello.txt")
+     *
+     * ```
+     */
+    static globalizePath(path: string): string { return _C($(), 7261, path) as string; }
+
+    /**
+     * Saves the configuration to the `project.godot` file.
+     * **Note:** This method is intended to be used by editor plugins, as modified {@link ProjectSettings} can't be loaded back in the running app. If you want to change project settings in exported projects, use {@link saveCustom} to save an `override.cfg` file.
+     */
+    static save(): Error { return _C($(), 10195) as Error; }
+
+    /**
+     * Loads the contents of the .pck or .zip file specified by `pack` into the resource filesystem (`res://`). Returns `true` on success.
+     * **Note:** If a file from `pack` shares the same path as a file already in the resource filesystem, any attempts to load that file will use the file from `pack` unless `replaceFiles` is set to `false`.
+     * **Note:** The optional `offset` parameter can be used to specify the offset in bytes to the start of the resource pack. This is only supported for .pck files.
+     * **Note:** {@link DirAccess} will not show changes made to the contents of `res://` after calling this function.
+     */
+    static loadResourcePack(pack: string, replaceFiles?: boolean /* = true */, offset?: number /* = 0 */): boolean { return _C($(), 8684, pack, replaceFiles, offset) as boolean; }
+
+    /**
+     * Saves the configuration to a custom file. The file extension must be `.godot` (to save in text-based {@link ConfigFile} format) or `.binary` (to save in binary format). You can also save an `override.cfg` file, which is also text, but can be used in exported projects unlike other formats.
+     */
+    static saveCustom(file: string): Error { return _C($(), 10196, file) as Error; }
+
+    /**
+     * Gets an array of the settings which have been changed since the last save. Note that internally `changed_settings` is cleared after a successful save, so generally the most appropriate place to use this method is when processing {@link settings_changed}.
+     */
+    static getChangedSettings(): PackedStringArray { return _C($(), 4138) as PackedStringArray; }
+
+    /**
+     * Checks if any settings with the prefix `settingPrefix` exist in the set of changed settings. See also {@link getChangedSettings}.
+     */
+    static checkChangedSettingsInGroup(settingPrefix: string): boolean { return _C($(), 2193, settingPrefix) as boolean; }
+
+    /**
+     * Emitted when any setting is changed, up to once per process frame.
+     */
+    static get settingsChanged(): Signal<() => void> { return _G($(), 13414) as Signal<() => void>; }
+    static set settingsChanged(v: (() => void) | null) { _G($(), 13414, v); }
+
+    static readonly name = _R(611, ProjectSettings);
+}

package/gen/classes/PropertyTweener.ts

@@ -0,0 +1,94 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Tweener } from './Tweener.ts';
+import type { Callable, Variant } from '../heap-types/index.ts';
+import type { EaseType, TransitionType } from './Tween.ts';
+
+/**
+ * {@link PropertyTweener} is used to interpolate a property in an object. See {@link Tween.tweenProperty} for more usage information.
+ * The tweener will finish automatically if the target object is freed.
+ * **Note:** {@link Tween.tweenProperty} is the only correct way to create {@link PropertyTweener}. Any {@link PropertyTweener} created manually will not function correctly.
+ */
+export class PropertyTweener extends Tweener {
+    constructor(name = 612) { super(name); }
+
+    /**
+     * Sets a custom initial value to the {@link PropertyTweener}.
+     * **Example:** Move the node from position `(100, 100)` to `(200, 100)`.
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = get_tree().create_tween()
+     * tween.tween_property(self, "position", Vector2(200, 100), 1).from(Vector2(100, 100))
+     *
+     * ```
+     */
+    from(value: Variant): PropertyTweener { return _C(this, 3591, value) as PropertyTweener; }
+
+    /**
+     * Makes the {@link PropertyTweener} use the current property value (i.e. at the time of creating this {@link PropertyTweener}) as a starting point. This is equivalent of using {@link from} with the current value. These two calls will do the same:
+     *
+     *
+     * ```gdscript
+     *
+     * tween.tween_property(self, "position", Vector2(200, 100), 1).from(position)
+     * tween.tween_property(self, "position", Vector2(200, 100), 1).from_current()
+     *
+     * ```
+     */
+    fromCurrent(): PropertyTweener { return _C(this, 3593) as PropertyTweener; }
+
+    /**
+     * When called, the final value will be used as a relative value instead.
+     * **Example:** Move the node by `100` pixels to the right.
+     *
+     *
+     * ```gdscript
+     *
+     * var tween = get_tree().create_tween()
+     * tween.tween_property(self, "position", Vector2.RIGHT * 100, 1).as_relative()
+     *
+     * ```
+     */
+    asRelative(): PropertyTweener { return _C(this, 1594) as PropertyTweener; }
+
+    /**
+     * Sets the type of used transition from {@link Tween.TransitionType}. If not set, the default transition is used from the {@link Tween} that contains this Tweener.
+     */
+    setTrans(trans: TransitionType): PropertyTweener { return _C(this, 13131, trans) as PropertyTweener; }
+
+    /**
+     * Sets the type of used easing from {@link Tween.EaseType}. If not set, the default easing is used from the {@link Tween} that contains this Tweener.
+     */
+    setEase(ease: EaseType): PropertyTweener { return _C(this, 11206, ease) as PropertyTweener; }
+
+    /**
+     * Allows interpolating the value with a custom easing function. The provided `interpolatorMethod` will be called with a value ranging from `0.0` to `1.0` and is expected to return a value within the same range (values outside the range can be used for overshoot). The return value of the method is then used for interpolation between initial and final value. Note that the parameter passed to the method is still subject to the tweener's own easing.
+     *
+     *
+     * ```gdscript
+     *
+     * @export var curve: Curve
+     *
+     * func _ready():
+     * 	var tween = create_tween()
+     * 	# Interpolate the value using a custom curve.
+     * 	tween.tween_property(self, "position:x", 300, 1).as_relative().set_custom_interpolator(tween_curve)
+     *
+     * func tween_curve(v):
+     * 	return curve.sample_baked(v)
+     *
+     * ```
+     */
+    setCustomInterpolator(interpolatorMethod: Callable): PropertyTweener { return _C(this, 11014, interpolatorMethod) as PropertyTweener; }
+
+    /**
+     * Sets the time in seconds after which the {@link PropertyTweener} will start interpolating. By default there's no delay.
+     */
+    setDelay(delay: number /* double */): PropertyTweener { return _C(this, 11075, delay) as PropertyTweener; }
+
+    static readonly name = _R(612, PropertyTweener);
+}

package/gen/classes/QuadMesh.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 { PlaneMesh } from './PlaneMesh.ts';
+
+/**
+ * Class representing a square {@link PrimitiveMesh}. This flat mesh does not have a thickness. By default, this mesh is aligned on the X and Y axes; this rotation is more suited for use with billboarded materials. A {@link QuadMesh} is equivalent to a {@link PlaneMesh} except its default {@link PlaneMesh.orientation} is {@link PlaneMesh.FACE_Z}.
+ */
+export class QuadMesh extends PlaneMesh {
+    constructor(name = 613) { super(name); }
+
+    static readonly name = _R(613, QuadMesh);
+}

package/gen/classes/QuadOccluder3D.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 { Occluder3D } from './Occluder3D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * {@link QuadOccluder3D} stores a flat plane shape that can be used by the engine's occlusion culling system. See also {@link PolygonOccluder3D} if you need to customize the quad's shape.
+ * See {@link OccluderInstance3D}'s documentation for instructions on setting up occlusion culling.
+ */
+export class QuadOccluder3D extends Occluder3D {
+    constructor(name = 614) { super(name); }
+
+    /**
+     * The quad's size in 3D units.
+     */
+    get size(): Vector2 { return _C(this, 6399) as Vector2; }
+    set size(v: Vector2) { _C(this, 12752, v); }
+
+    static readonly name = _R(614, QuadOccluder3D);
+}