@ringozz/godot 0.1.0

package/gen/classes/Expression.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 { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, PackedStringArray, Variant } from '../heap-types/index.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * An expression can be made of any arithmetic operation, built-in math function call, method call of a passed instance, or built-in type construction call.
+ * An example expression text using the built-in math functions could be `sqrt(pow(3, 2) + pow(4, 2))`.
+ * In the following example we use a {@link LineEdit} node to write our expression and show the result.
+ *
+ *
+ * ```gdscript
+ *
+ * var expression = Expression.new()
+ *
+ * func _ready():
+ * 	$LineEdit.text_submitted.connect(self._on_text_submitted)
+ *
+ * func _on_text_submitted(command):
+ * 	var error = expression.parse(command)
+ * 	if error != OK:
+ * 		print(expression.get_error_text())
+ * 		return
+ * 	var result = expression.execute()
+ * 	if not expression.has_execute_failed():
+ * 		$LineEdit.text = str(result)
+ *
+ * ```
+ */
+export class Expression extends RefCounted {
+    constructor(name = 259) { super(name); }
+
+    /**
+     * Parses the expression and returns an {@link Error} code.
+     * You can optionally specify names of variables that may appear in the expression with `inputNames`, so that you can bind them when it gets executed.
+     */
+    parse(expression: string, inputNames?: PackedStringArray /* = PackedStringArray() */): Error { return _C(this, 9277, expression, inputNames) as Error; }
+
+    /**
+     * Executes the expression that was previously parsed by {@link parse} and returns the result. Before you use the returned object, you should check if the method failed by calling {@link hasExecuteFailed}.
+     * If you defined input variables in {@link parse}, you can specify their values in the inputs array, in the same order.
+     */
+    execute(inputs?: GodotArray /* = [] */, baseInstance?: Object /* = null */, showError?: boolean /* = true */, constCallsOnly?: boolean /* = false */): Variant { return _C(this, 3180, inputs, baseInstance, showError, constCallsOnly) as Variant; }
+
+    /**
+     * Returns `true` if {@link execute} has failed.
+     */
+    hasExecuteFailed(): boolean { return _C(this, 7393) as boolean; }
+
+    /**
+     * Returns the error text if {@link parse} or {@link execute} has failed.
+     */
+    getErrorText(): string { return _C(this, 4688) as string; }
+
+    static readonly name = _R(259, Expression);
+}

package/gen/classes/ExternalTexture.ts

@@ -0,0 +1,35 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * Displays the content of an external buffer provided by the platform.
+ * Requires the [OES_EGL_image_external](https://registry.khronos.org/OpenGL/extensions/OES/OES_EGL_image_external.txt) extension (OpenGL) or [VK_ANDROID_external_memory_android_hardware_buffer](https://registry.khronos.org/vulkan/specs/1.1-extensions/html/vkspec.html#VK_ANDROID_external_memory_android_hardware_buffer) extension (Vulkan).
+ * **Note:** This is currently only supported in Android builds.
+ */
+export class ExternalTexture extends Texture2D {
+    constructor(name = 260) { super(name); }
+
+    /**
+     * Returns the external texture ID.
+     * Depending on your use case, you may need to pass this to platform APIs, for example, when creating an `android.graphics.SurfaceTexture` on Android.
+     */
+    getExternalTextureId(): number { return _C(this, 4718) as number; }
+
+    /**
+     * Sets the external buffer ID.
+     * Depending on your use case, you may need to call this with data received from a platform API, for example, `SurfaceTexture.getHardwareBuffer()` on Android.
+     */
+    setExternalBufferId(externalBufferId: number /* uint64 */): void { _C(this, 11336, externalBufferId); }
+
+    /**
+     * External texture size.
+     */
+    get size(): Vector2 { return _C(this, 6399) as Vector2; }
+    set size(v: Vector2) { _C(this, 12752, v); }
+
+    static readonly name = _R(260, ExternalTexture);
+}

package/gen/classes/FABRIK3D.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 { IterateIK3D } from './IterateIK3D.ts';
+
+/**
+ * {@link FABRIK3D} is position based IK, allowing precise and accurate tracking of targets. It's ideal for simple chains without limitations.
+ * The resulting twist around the forward vector will always be kept from the previous pose.
+ * **Note:** When the target is close to the root, it tends to produce zig-zag patterns, resulting in unnatural visual movement.
+ */
+export class FABRIK3D extends IterateIK3D {
+    constructor(name = 261) { super(name); }
+
+    static readonly name = _R(261, FABRIK3D);
+}

package/gen/classes/FBXDocument.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 { GLTFDocument } from './GLTFDocument.ts';
+
+/**
+ * The FBXDocument handles FBX documents. It provides methods to append data from buffers or files, generate scenes, and register/unregister document extensions.
+ * When exporting FBX from Blender, use the "FBX Units Scale" option. The "FBX Units Scale" option sets the correct scale factor and avoids manual adjustments when re-importing into Blender, such as through glTF export.
+ */
+export class FBXDocument extends GLTFDocument {
+    constructor(name = 262) { super(name); }
+
+    static readonly name = _R(262, FBXDocument);
+}

package/gen/classes/FBXState.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GLTFState } from './GLTFState.ts';
+
+/**
+ * The FBXState handles the state data imported from FBX files.
+ */
+export class FBXState extends GLTFState {
+    constructor(name = 263) { super(name); }
+
+    /**
+     * If `true`, the import process used auxiliary nodes called geometry helper nodes. These nodes help preserve the pivots and transformations of the original 3D model during import.
+     */
+    get allowGeometryHelperNodes(): boolean { return _C(this, 3718) as boolean; }
+    set allowGeometryHelperNodes(v: boolean) { _C(this, 10453, v); }
+
+    static readonly name = _R(263, FBXState);
+}

package/gen/classes/FastNoiseLite.ts

@@ -0,0 +1,284 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Noise } from './Noise.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * This class generates noise using the FastNoiseLite library, which is a collection of several noise algorithms including Cellular, Perlin, Value, and more.
+ * Most generated noise values are in the range of `[-1, 1]`, but not always. Some of the cellular noise algorithms return results above `1`.
+ */
+export class FastNoiseLite extends Noise {
+    constructor(name = 264) { super(name); }
+
+    /**
+     * The noise algorithm used.
+     */
+    get noiseType(): NoiseType { return _C(this, 5671) as NoiseType; }
+    set noiseType(v: NoiseType) { _C(this, 12142, v); }
+
+    /**
+     * The random number seed for all noise types.
+     */
+    get seed(): number { return _C(this, 6317) as number; }
+    set seed(v: number) { _C(this, 12682, v); }
+
+    /**
+     * The frequency for all noise types. Low frequency results in smooth noise while high frequency results in rougher, more granular noise.
+     */
+    get frequency(): number { return _C(this, 4896) as number; }
+    set frequency(v: number) { _C(this, 11489, v); }
+
+    /**
+     * Translate the noise input coordinates by the given {@link Vector3}.
+     */
+    get offset(): Vector3 { return _C(this, 5703) as Vector3; }
+    set offset(v: Vector3) { _C(this, 12170, v); }
+
+    /**
+     * The method for combining octaves into a fractal.
+     */
+    get fractalType(): FractalType { return _C(this, 4875) as FractalType; }
+    set fractalType(v: FractalType) { _C(this, 11477, v); }
+
+    /**
+     * The number of noise layers that are sampled to get the final value for fractal noise types.
+     */
+    get fractalOctaves(): number { return _C(this, 4873) as number; }
+    set fractalOctaves(v: number) { _C(this, 11475, v); }
+
+    /**
+     * Frequency multiplier between subsequent octaves. Increasing this value results in higher octaves producing noise with finer details and a rougher appearance.
+     */
+    get fractalLacunarity(): number { return _C(this, 4872) as number; }
+    set fractalLacunarity(v: number) { _C(this, 11474, v); }
+
+    /**
+     * Determines the strength of each subsequent layer of noise in fractal noise.
+     * A low value places more emphasis on the lower frequency base layers, while a high value puts more emphasis on the higher frequency layers.
+     */
+    get fractalGain(): number { return _C(this, 4871) as number; }
+    set fractalGain(v: number) { _C(this, 11473, v); }
+
+    /**
+     * Higher weighting means higher octaves have less impact if lower octaves have a large impact.
+     */
+    get fractalWeightedStrength(): number { return _C(this, 4876) as number; }
+    set fractalWeightedStrength(v: number) { _C(this, 11478, v); }
+
+    /**
+     * Sets the strength of the fractal ping pong type.
+     */
+    get fractalPingPongStrength(): number { return _C(this, 4874) as number; }
+    set fractalPingPongStrength(v: number) { _C(this, 11476, v); }
+
+    /**
+     * Determines how the distance to the nearest/second-nearest point is computed.
+     */
+    get cellularDistanceFunction(): CellularDistanceFunction { return _C(this, 4118) as CellularDistanceFunction; }
+    set cellularDistanceFunction(v: CellularDistanceFunction) { _C(this, 10833, v); }
+
+    /**
+     * Maximum distance a point can move off of its grid position. Set to `0` for an even grid.
+     */
+    get cellularJitter(): number { return _C(this, 4119) as number; }
+    set cellularJitter(v: number) { _C(this, 10834, v); }
+
+    /**
+     * Return type from cellular noise calculations.
+     */
+    get cellularReturnType(): CellularReturnType { return _C(this, 4120) as CellularReturnType; }
+    set cellularReturnType(v: CellularReturnType) { _C(this, 10835, v); }
+
+    /**
+     * If enabled, another FastNoiseLite instance is used to warp the space, resulting in a distortion of the noise.
+     */
+    get domainWarpEnabled(): boolean { return _C(this, 7890) as boolean; }
+    set domainWarpEnabled(v: boolean) { _C(this, 11148, v); }
+
+    /**
+     * The warp algorithm.
+     */
+    get domainWarpType(): DomainWarpType { return _C(this, 4543) as DomainWarpType; }
+    set domainWarpType(v: DomainWarpType) { _C(this, 11154, v); }
+
+    /**
+     * Sets the maximum warp distance from the origin.
+     */
+    get domainWarpAmplitude(): number { return _C(this, 4537) as number; }
+    set domainWarpAmplitude(v: number) { _C(this, 11147, v); }
+
+    /**
+     * Frequency of the noise which warps the space. Low frequency results in smooth noise while high frequency results in rougher, more granular noise.
+     */
+    get domainWarpFrequency(): number { return _C(this, 4542) as number; }
+    set domainWarpFrequency(v: number) { _C(this, 11153, v); }
+
+    /**
+     * The method for combining octaves into a fractal which is used to warp the space.
+     */
+    get domainWarpFractalType(): DomainWarpFractalType { return _C(this, 4541) as DomainWarpFractalType; }
+    set domainWarpFractalType(v: DomainWarpFractalType) { _C(this, 11152, v); }
+
+    /**
+     * The number of noise layers that are sampled to get the final value for the fractal noise which warps the space.
+     */
+    get domainWarpFractalOctaves(): number { return _C(this, 4540) as number; }
+    set domainWarpFractalOctaves(v: number) { _C(this, 11151, v); }
+
+    /**
+     * The change in frequency between octaves, also known as "lacunarity", of the fractal noise which warps the space. Increasing this value results in higher octaves, producing noise with finer details and a rougher appearance.
+     */
+    get domainWarpFractalLacunarity(): number { return _C(this, 4539) as number; }
+    set domainWarpFractalLacunarity(v: number) { _C(this, 11150, v); }
+
+    /**
+     * Determines the strength of each subsequent layer of the noise which is used to warp the space.
+     * A low value places more emphasis on the lower frequency base layers, while a high value puts more emphasis on the higher frequency layers.
+     */
+    get domainWarpFractalGain(): number { return _C(this, 4538) as number; }
+    set domainWarpFractalGain(v: number) { _C(this, 11149, v); }
+
+    static readonly name = _R(264, FastNoiseLite);
+}
+
+export const NoiseType = {
+    /**
+     * A lattice of points are assigned random values then interpolated based on neighboring values.
+     */
+    TYPE_VALUE: 5,
+    /**
+     * Similar to value noise ({@link TYPE_VALUE}), but slower. Has more variance in peaks and valleys.
+     * Cubic noise can be used to avoid certain artifacts when using value noise to create a bumpmap. In general, you should always use this mode if the value noise is being used for a heightmap or bumpmap.
+     */
+    TYPE_VALUE_CUBIC: 4,
+    /**
+     * A lattice of random gradients. Their dot products are interpolated to obtain values in between the lattices.
+     */
+    TYPE_PERLIN: 3,
+    /**
+     * Cellular includes both Worley noise and Voronoi diagrams which creates various regions of the same value.
+     */
+    TYPE_CELLULAR: 2,
+    /**
+     * As opposed to {@link TYPE_PERLIN}, gradients exist in a simplex lattice rather than a grid lattice, avoiding directional artifacts. Internally uses FastNoiseLite's OpenSimplex2 noise type.
+     */
+    TYPE_SIMPLEX: 0,
+    /**
+     * Modified, higher quality version of {@link TYPE_SIMPLEX}, but slower. Internally uses FastNoiseLite's OpenSimplex2S noise type.
+     */
+    TYPE_SIMPLEX_SMOOTH: 1,
+} as const;
+
+export type NoiseType = (typeof NoiseType)[keyof typeof NoiseType];
+
+export const FractalType = {
+    /**
+     * No fractal noise.
+     */
+    FRACTAL_NONE: 0,
+    /**
+     * Method using Fractional Brownian Motion to combine octaves into a fractal.
+     */
+    FRACTAL_FBM: 1,
+    /**
+     * Method of combining octaves into a fractal resulting in a "ridged" look.
+     */
+    FRACTAL_RIDGED: 2,
+    /**
+     * Method of combining octaves into a fractal with a ping pong effect.
+     */
+    FRACTAL_PING_PONG: 3,
+} as const;
+
+export type FractalType = (typeof FractalType)[keyof typeof FractalType];
+
+export const CellularDistanceFunction = {
+    /**
+     * Euclidean distance to the nearest point.
+     */
+    DISTANCE_EUCLIDEAN: 0,
+    /**
+     * Squared Euclidean distance to the nearest point.
+     */
+    DISTANCE_EUCLIDEAN_SQUARED: 1,
+    /**
+     * Manhattan distance (taxicab metric) to the nearest point.
+     */
+    DISTANCE_MANHATTAN: 2,
+    /**
+     * Blend of {@link DISTANCE_EUCLIDEAN} and {@link DISTANCE_MANHATTAN} to give curved cell boundaries.
+     */
+    DISTANCE_HYBRID: 3,
+} as const;
+
+export type CellularDistanceFunction = (typeof CellularDistanceFunction)[keyof typeof CellularDistanceFunction];
+
+export const CellularReturnType = {
+    /**
+     * The cellular distance function will return the same value for all points within a cell.
+     */
+    RETURN_CELL_VALUE: 0,
+    /**
+     * The cellular distance function will return a value determined by the distance to the nearest point.
+     */
+    RETURN_DISTANCE: 1,
+    /**
+     * The cellular distance function returns the distance to the second-nearest point.
+     */
+    RETURN_DISTANCE2: 2,
+    /**
+     * The distance to the nearest point is added to the distance to the second-nearest point.
+     */
+    RETURN_DISTANCE2_ADD: 3,
+    /**
+     * The distance to the nearest point is subtracted from the distance to the second-nearest point.
+     */
+    RETURN_DISTANCE2_SUB: 4,
+    /**
+     * The distance to the nearest point is multiplied with the distance to the second-nearest point.
+     */
+    RETURN_DISTANCE2_MUL: 5,
+    /**
+     * The distance to the nearest point is divided by the distance to the second-nearest point.
+     */
+    RETURN_DISTANCE2_DIV: 6,
+} as const;
+
+export type CellularReturnType = (typeof CellularReturnType)[keyof typeof CellularReturnType];
+
+export const DomainWarpType = {
+    /**
+     * The domain is warped using the simplex noise algorithm.
+     */
+    DOMAIN_WARP_SIMPLEX: 0,
+    /**
+     * The domain is warped using a simplified version of the simplex noise algorithm.
+     */
+    DOMAIN_WARP_SIMPLEX_REDUCED: 1,
+    /**
+     * The domain is warped using a simple noise grid (not as smooth as the other methods, but more performant).
+     */
+    DOMAIN_WARP_BASIC_GRID: 2,
+} as const;
+
+export type DomainWarpType = (typeof DomainWarpType)[keyof typeof DomainWarpType];
+
+export const DomainWarpFractalType = {
+    /**
+     * No fractal noise for warping the space.
+     */
+    DOMAIN_WARP_FRACTAL_NONE: 0,
+    /**
+     * Warping the space progressively, octave for octave, resulting in a more "liquified" distortion.
+     */
+    DOMAIN_WARP_FRACTAL_PROGRESSIVE: 1,
+    /**
+     * Warping the space independently for each octave, resulting in a more chaotic distortion.
+     */
+    DOMAIN_WARP_FRACTAL_INDEPENDENT: 2,
+} as const;
+
+export type DomainWarpFractalType = (typeof DomainWarpFractalType)[keyof typeof DomainWarpFractalType];
+