@ringozz/godot 0.1.0

package/gen/classes/Curve.ts

@@ -0,0 +1,183 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * This resource describes a mathematical curve by defining a set of points and tangents at each point. By default, it ranges between `0` and `1` on the X and Y axes, but these ranges can be changed.
+ * Please note that many resources and nodes assume they are given *unit curves*. A unit curve is a curve whose domain (the X axis) is between `0` and `1`. Some examples of unit curve usage are {@link CPUParticles2D.angleCurve} and {@link Line2D.widthCurve}.
+ */
+export class Curve extends Resource {
+    constructor(name = 235) { super(name); }
+
+    /**
+     * Adds a point to the curve. For each side, if the `*_mode` is {@link TANGENT_LINEAR}, the `*_tangent` angle (in degrees) uses the slope of the curve halfway to the adjacent point. Allows custom assignments to the `*_tangent` angle if `*_mode` is set to {@link TANGENT_FREE}.
+     */
+    addPoint(position: Vector2, leftTangent?: number /* = 0 */, rightTangent?: number /* = 0 */, leftMode?: TangentMode /* = 0 */, rightMode?: TangentMode /* = 0 */): number { return _C(this, 1272, position, leftTangent, rightTangent, leftMode, rightMode) as number; }
+
+    /**
+     * Removes the point at `index` from the curve.
+     */
+    removePoint(index: number): void { _C(this, 9948, index); }
+
+    /**
+     * Removes all points from the curve.
+     */
+    clearPoints(): void { _C(this, 2287); }
+
+    /**
+     * Returns the curve coordinates for the point at `index`.
+     */
+    getPointPosition(index: number): Vector2 { return _C(this, 5951, index) as Vector2; }
+
+    /**
+     * Assigns the vertical position `y` to the point at `index`.
+     */
+    setPointValue(index: number, y: number): void { _C(this, 12367, index, y); }
+
+    /**
+     * Assigns the horizontal position `offset` to the point at `index`.
+     */
+    setPointOffset(index: number, offset: number): number { return _C(this, 12357, index, offset) as number; }
+
+    /**
+     * Returns the Y value for the point that would exist at the X position `offset` along the curve.
+     */
+    sample(offset: number): number { return _C(this, 10180, offset) as number; }
+
+    /**
+     * Returns the Y value for the point that would exist at the X position `offset` along the curve using the baked cache. Bakes the curve's points if not already baked.
+     */
+    sampleBaked(offset: number): number { return _C(this, 10181, offset) as number; }
+
+    /**
+     * Returns the left tangent angle (in degrees) for the point at `index`.
+     */
+    getPointLeftTangent(index: number): number { return _C(this, 5947, index) as number; }
+
+    /**
+     * Returns the right tangent angle (in degrees) for the point at `index`.
+     */
+    getPointRightTangent(index: number): number { return _C(this, 5953, index) as number; }
+
+    /**
+     * Returns the left {@link TangentMode} for the point at `index`.
+     */
+    getPointLeftMode(index: number): TangentMode { return _C(this, 5946, index) as TangentMode; }
+
+    /**
+     * Returns the right {@link TangentMode} for the point at `index`.
+     */
+    getPointRightMode(index: number): TangentMode { return _C(this, 5952, index) as TangentMode; }
+
+    /**
+     * Sets the left tangent angle for the point at `index` to `tangent`.
+     */
+    setPointLeftTangent(index: number, tangent: number): void { _C(this, 12356, index, tangent); }
+
+    /**
+     * Sets the right tangent angle for the point at `index` to `tangent`.
+     */
+    setPointRightTangent(index: number, tangent: number): void { _C(this, 12363, index, tangent); }
+
+    /**
+     * Sets the left {@link TangentMode} for the point at `index` to `mode`.
+     */
+    setPointLeftMode(index: number, mode: TangentMode): void { _C(this, 12355, index, mode); }
+
+    /**
+     * Sets the right {@link TangentMode} for the point at `index` to `mode`.
+     */
+    setPointRightMode(index: number, mode: TangentMode): void { _C(this, 12362, index, mode); }
+
+    /**
+     * Returns the difference between {@link minValue} and {@link maxValue}.
+     */
+    getValueRange(): number { return _C(this, 7020) as number; }
+
+    /**
+     * Returns the difference between {@link minDomain} and {@link maxDomain}.
+     */
+    getDomainRange(): number { return _C(this, 4536) as number; }
+
+    /**
+     * Removes duplicate points, i.e. points that are less than 0.00001 units (engine epsilon value) away from their neighbor on the curve.
+     */
+    cleanDupes(): void { _C(this, 2230); }
+
+    /**
+     * Recomputes the baked cache of points for the curve.
+     */
+    bake(): void { _C(this, 1708); }
+
+    /**
+     * The minimum domain (x-coordinate) that points can have.
+     */
+    get minDomain(): number { return _C(this, 5539) as number; }
+    set minDomain(v: number) { _C(this, 12050, v); }
+
+    /**
+     * The maximum domain (x-coordinate) that points can have.
+     */
+    get maxDomain(): number { return _C(this, 5468) as number; }
+    set maxDomain(v: number) { _C(this, 11993, v); }
+
+    /**
+     * The minimum value (y-coordinate) that points can have. Tangents can cause lower values between points.
+     */
+    get minValue(): number { return _C(this, 5546) as number; }
+    set minValue(v: number) { _C(this, 12056, v); }
+
+    /**
+     * The maximum value (y-coordinate) that points can have. Tangents can cause higher values between points.
+     */
+    get maxValue(): number { return _C(this, 5494) as number; }
+    set maxValue(v: number) { _C(this, 12016, v); }
+
+    /**
+     * The number of points to include in the baked (i.e. cached) curve data.
+     */
+    get bakeResolution(): number { return _C(this, 3881) as number; }
+    set bakeResolution(v: number) { _C(this, 10634, v); }
+
+    /**
+     * The number of points describing the curve.
+     */
+    get pointCount(): number { return _C(this, 5942) as number; }
+    set pointCount(v: number) { _C(this, 12352, v); }
+
+    /**
+     * Emitted when {@link maxValue} or {@link minValue} is changed.
+     */
+    get rangeChanged(): Signal<() => void> { return _G(this, 9732) as Signal<() => void>; }
+    set rangeChanged(v: (() => void) | null) { _G(this, 9732, v); }
+
+    /**
+     * Emitted when {@link maxDomain} or {@link minDomain} is changed.
+     */
+    get domainChanged(): Signal<() => void> { return _G(this, 2861) as Signal<() => void>; }
+    set domainChanged(v: (() => void) | null) { _G(this, 2861, v); }
+
+    static readonly name = _R(235, Curve);
+}
+
+export const TangentMode = {
+    /**
+     * The tangent on this side of the point is user-defined.
+     */
+    TANGENT_FREE: 0,
+    /**
+     * The curve calculates the tangent on this side of the point as the slope halfway towards the adjacent point.
+     */
+    TANGENT_LINEAR: 1,
+    /**
+     * The total number of available tangent modes.
+     */
+    TANGENT_MODE_COUNT: 2,
+} as const;
+
+export type TangentMode = (typeof TangentMode)[keyof typeof TangentMode];
+

package/gen/classes/Curve2D.ts

@@ -0,0 +1,145 @@
+// 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 { PackedVector2Array } from '../heap-types/index.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+
+/**
+ * This class describes a Bézier curve in 2D space. It is mainly used to give a shape to a {@link Path2D}, but can be manually sampled for other purposes.
+ * It keeps a cache of precalculated points along the curve, to speed up further calculations.
+ */
+export class Curve2D extends Resource {
+    constructor(name = 236) { super(name); }
+
+    /**
+     * Adds a point with the specified `position` relative to the curve's own position, with control points `in` and `out`. Appends the new point at the end of the point list.
+     * If `index` is given, the new point is inserted before the existing point identified by index `index`. Every existing point starting from `index` is shifted further down the list of points. The index must be greater than or equal to `0` and must not exceed the number of existing points in the line. See {@link pointCount}.
+     */
+    addPoint(position: Vector2, _in?: Vector2 /* = Vector2(0, 0) */, out?: Vector2 /* = Vector2(0, 0) */, index?: number /* = -1 */): void { _C(this, 1272, position, _in, out, index); }
+
+    /**
+     * Sets the position for the vertex `idx`. If the index is out of bounds, the function sends an error to the console.
+     */
+    setPointPosition(idx: number, position: Vector2): void { _C(this, 12361, idx, position); }
+
+    /**
+     * Returns the position of the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0)`.
+     */
+    getPointPosition(idx: number): Vector2 { return _C(this, 5951, idx) as Vector2; }
+
+    /**
+     * Sets the position of the control point leading to the vertex `idx`. If the index is out of bounds, the function sends an error to the console. The position is relative to the vertex.
+     */
+    setPointIn(idx: number, position: Vector2): void { _C(this, 12354, idx, position); }
+
+    /**
+     * Returns the position of the control point leading to the vertex `idx`. The returned position is relative to the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0)`.
+     */
+    getPointIn(idx: number): Vector2 { return _C(this, 5945, idx) as Vector2; }
+
+    /**
+     * Sets the position of the control point leading out of the vertex `idx`. If the index is out of bounds, the function sends an error to the console. The position is relative to the vertex.
+     */
+    setPointOut(idx: number, position: Vector2): void { _C(this, 12358, idx, position); }
+
+    /**
+     * Returns the position of the control point leading out of the vertex `idx`. The returned position is relative to the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0)`.
+     */
+    getPointOut(idx: number): Vector2 { return _C(this, 5948, idx) as Vector2; }
+
+    /**
+     * Deletes the point `idx` from the curve. Sends an error to the console if `idx` is out of bounds.
+     */
+    removePoint(idx: number): void { _C(this, 9948, idx); }
+
+    /**
+     * Removes all points from the curve.
+     */
+    clearPoints(): void { _C(this, 2287); }
+
+    /**
+     * Returns the position between the vertex `idx` and the vertex `idx + 1`, where `t` controls if the point is the first vertex (`t = 0.0`), the last vertex (`t = 1.0`), or in between. Values of `t` outside the range (`0.0 <= t <= 1.0`) give strange, but predictable results.
+     * If `idx` is out of bounds it is truncated to the first or last vertex, and `t` is ignored. If the curve has no points, the function sends an error to the console, and returns `(0, 0)`.
+     */
+    sample(idx: number, t: number): Vector2 { return _C(this, 10180, idx, t) as Vector2; }
+
+    /**
+     * Returns the position at the vertex `fofs`. It calls {@link sample} using the integer part of `fofs` as `idx`, and its fractional part as `t`.
+     */
+    samplef(fofs: number): Vector2 { return _C(this, 10187, fofs) as Vector2; }
+
+    /**
+     * Returns the total length of the curve, based on the cached points. Given enough density (see {@link bakeInterval}), it should be approximate enough.
+     */
+    getBakedLength(): number { return _C(this, 3883) as number; }
+
+    /**
+     * Returns a point within the curve at position `offset`, where `offset` is measured as a pixel distance along the curve.
+     * To do that, it finds the two cached points where the `offset` lies between, then interpolates the values. This interpolation is cubic if `cubic` is set to `true`, or linear if set to `false`.
+     * Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough).
+     */
+    sampleBaked(offset?: number /* = 0.0 */, cubic?: boolean /* = false */): Vector2 { return _C(this, 10181, offset, cubic) as Vector2; }
+
+    /**
+     * Similar to {@link sampleBaked}, but returns {@link Transform2D} that includes a rotation along the curve, with {@link Transform2D.origin} as the point position and the {@link Transform2D.x} vector pointing in the direction of the path at that point. Returns an empty transform if the length of the curve is `0`.
+     *
+     * ```text
+     *
+     * var baked = curve.sample_baked_with_rotation(offset)
+     * # The returned Transform2D can be set directly.
+     * transform = baked
+     * # You can also read the origin and rotation separately from the returned Transform2D.
+     * position = baked.get_origin()
+     * rotation = baked.get_rotation()
+     *
+     * ```
+     */
+    sampleBakedWithRotation(offset?: number /* = 0.0 */, cubic?: boolean /* = false */): Transform2D { return _C(this, 10183, offset, cubic) as Transform2D; }
+
+    /**
+     * Returns the cache of points as a {@link PackedVector2Array}.
+     */
+    getBakedPoints(): PackedVector2Array { return _C(this, 3884) as PackedVector2Array; }
+
+    /**
+     * Returns the closest point on baked segments (in curve's local space) to `toPoint`.
+     * `toPoint` must be in this curve's local space.
+     */
+    getClosestPoint(toPoint: Vector2): Vector2 { return _C(this, 4174, toPoint) as Vector2; }
+
+    /**
+     * Returns the closest offset to `toPoint`. This offset is meant to be used in {@link sampleBaked}.
+     * `toPoint` must be in this curve's local space.
+     */
+    getClosestOffset(toPoint: Vector2): number { return _C(this, 4173, toPoint) as number; }
+
+    /**
+     * Returns a list of points along the curve, with a curvature controlled point density. That is, the curvier parts will have more points than the straighter parts.
+     * This approximation makes straight segments between each point, then subdivides those segments until the resulting shape is similar enough.
+     * `maxStages` controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care!
+     * `toleranceDegrees` controls how many degrees the midpoint of a segment may deviate from the real curve, before the segment has to be subdivided.
+     */
+    tessellate(maxStages?: number /* = 5 */, toleranceDegrees?: number /* = 4 */): PackedVector2Array { return _C(this, 14146, maxStages, toleranceDegrees) as PackedVector2Array; }
+
+    /**
+     * Returns a list of points along the curve, with almost uniform density. `maxStages` controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care!
+     * `toleranceLength` controls the maximal distance between two neighboring points, before the segment has to be subdivided.
+     */
+    tessellateEvenLength(maxStages?: number /* = 5 */, toleranceLength?: number /* = 20.0 */): PackedVector2Array { return _C(this, 14147, maxStages, toleranceLength) as PackedVector2Array; }
+
+    /**
+     * The distance in pixels between two adjacent cached points. Changing it forces the cache to be recomputed the next time the {@link getBakedPoints} or {@link getBakedLength} function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care.
+     */
+    get bakeInterval(): number { return _C(this, 3874) as number; }
+    set bakeInterval(v: number) { _C(this, 10628, v); }
+
+    /**
+     * The number of points describing the curve.
+     */
+    get pointCount(): number { return _C(this, 5942) as number; }
+    set pointCount(v: number) { _C(this, 12352, v); }
+
+    static readonly name = _R(236, Curve2D);
+}

package/gen/classes/Curve3D.ts

@@ -0,0 +1,173 @@
+// 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 { PackedFloat32Array, PackedVector3Array } from '../heap-types/index.ts';
+import type { Transform3D, Vector3 } from '../value-types/index.ts';
+
+/**
+ * This class describes a Bézier curve in 3D space. It is mainly used to give a shape to a {@link Path3D}, but can be manually sampled for other purposes.
+ * It keeps a cache of precalculated points along the curve, to speed up further calculations.
+ */
+export class Curve3D extends Resource {
+    constructor(name = 237) { super(name); }
+
+    /**
+     * Adds a point with the specified `position` relative to the curve's own position, with control points `in` and `out`. Appends the new point at the end of the point list.
+     * If `index` is given, the new point is inserted before the existing point identified by index `index`. Every existing point starting from `index` is shifted further down the list of points. The index must be greater than or equal to `0` and must not exceed the number of existing points in the line. See {@link pointCount}.
+     */
+    addPoint(position: Vector3, _in?: Vector3 /* = Vector3(0, 0, 0) */, out?: Vector3 /* = Vector3(0, 0, 0) */, index?: number /* = -1 */): void { _C(this, 1272, position, _in, out, index); }
+
+    /**
+     * Sets the position for the vertex `idx`. If the index is out of bounds, the function sends an error to the console.
+     */
+    setPointPosition(idx: number, position: Vector3): void { _C(this, 12361, idx, position); }
+
+    /**
+     * Returns the position of the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0, 0)`.
+     */
+    getPointPosition(idx: number): Vector3 { return _C(this, 5951, idx) as Vector3; }
+
+    /**
+     * Sets the tilt angle in radians for the point `idx`. If the index is out of bounds, the function sends an error to the console.
+     * The tilt controls the rotation along the look-at axis an object traveling the path would have. In the case of a curve controlling a {@link PathFollow3D}, this tilt is an offset over the natural tilt the {@link PathFollow3D} calculates.
+     */
+    setPointTilt(idx: number, tilt: number): void { _C(this, 12366, idx, tilt); }
+
+    /**
+     * Returns the tilt angle in radians for the point `idx`. If the index is out of bounds, the function sends an error to the console, and returns `0`.
+     */
+    getPointTilt(idx: number): number { return _C(this, 5955, idx) as number; }
+
+    /**
+     * Sets the position of the control point leading to the vertex `idx`. If the index is out of bounds, the function sends an error to the console. The position is relative to the vertex.
+     */
+    setPointIn(idx: number, position: Vector3): void { _C(this, 12354, idx, position); }
+
+    /**
+     * Returns the position of the control point leading to the vertex `idx`. The returned position is relative to the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0, 0)`.
+     */
+    getPointIn(idx: number): Vector3 { return _C(this, 5945, idx) as Vector3; }
+
+    /**
+     * Sets the position of the control point leading out of the vertex `idx`. If the index is out of bounds, the function sends an error to the console. The position is relative to the vertex.
+     */
+    setPointOut(idx: number, position: Vector3): void { _C(this, 12358, idx, position); }
+
+    /**
+     * Returns the position of the control point leading out of the vertex `idx`. The returned position is relative to the vertex `idx`. If the index is out of bounds, the function sends an error to the console, and returns `(0, 0, 0)`.
+     */
+    getPointOut(idx: number): Vector3 { return _C(this, 5948, idx) as Vector3; }
+
+    /**
+     * Deletes the point `idx` from the curve. Sends an error to the console if `idx` is out of bounds.
+     */
+    removePoint(idx: number): void { _C(this, 9948, idx); }
+
+    /**
+     * Removes all points from the curve.
+     */
+    clearPoints(): void { _C(this, 2287); }
+
+    /**
+     * Returns the position between the vertex `idx` and the vertex `idx + 1`, where `t` controls if the point is the first vertex (`t = 0.0`), the last vertex (`t = 1.0`), or in between. Values of `t` outside the range (`0.0 >= t <=1`) give strange, but predictable results.
+     * If `idx` is out of bounds it is truncated to the first or last vertex, and `t` is ignored. If the curve has no points, the function sends an error to the console, and returns `(0, 0, 0)`.
+     */
+    sample(idx: number, t: number): Vector3 { return _C(this, 10180, idx, t) as Vector3; }
+
+    /**
+     * Returns the position at the vertex `fofs`. It calls {@link sample} using the integer part of `fofs` as `idx`, and its fractional part as `t`.
+     */
+    samplef(fofs: number): Vector3 { return _C(this, 10187, fofs) as Vector3; }
+
+    /**
+     * Returns the total length of the curve, based on the cached points. Given enough density (see {@link bakeInterval}), it should be approximate enough.
+     */
+    getBakedLength(): number { return _C(this, 3883) as number; }
+
+    /**
+     * Returns a point within the curve at position `offset`, where `offset` is measured as a distance in 3D units along the curve. To do that, it finds the two cached points where the `offset` lies between, then interpolates the values. This interpolation is cubic if `cubic` is set to `true`, or linear if set to `false`.
+     * Cubic interpolation tends to follow the curves better, but linear is faster (and often, precise enough).
+     */
+    sampleBaked(offset?: number /* = 0.0 */, cubic?: boolean /* = false */): Vector3 { return _C(this, 10181, offset, cubic) as Vector3; }
+
+    /**
+     * Returns a {@link Transform3D} with `origin` as point position, `basis.x` as sideway vector, `basis.y` as up vector, `basis.z` as forward vector. When the curve length is 0, there is no reasonable way to calculate the rotation, all vectors aligned with global space axes. See also {@link sampleBaked}.
+     */
+    sampleBakedWithRotation(offset?: number /* = 0.0 */, cubic?: boolean /* = false */, applyTilt?: boolean /* = false */): Transform3D { return _C(this, 10183, offset, cubic, applyTilt) as Transform3D; }
+
+    /**
+     * Returns an up vector within the curve at position `offset`, where `offset` is measured as a distance in 3D units along the curve. To do that, it finds the two cached up vectors where the `offset` lies between, then interpolates the values. If `applyTilt` is `true`, an interpolated tilt is applied to the interpolated up vector.
+     * If the curve has no up vectors, the function sends an error to the console, and returns `(0, 1, 0)`.
+     */
+    sampleBakedUpVector(offset: number, applyTilt?: boolean /* = false */): Vector3 { return _C(this, 10182, offset, applyTilt) as Vector3; }
+
+    /**
+     * Returns the cache of points as a {@link PackedVector3Array}.
+     */
+    getBakedPoints(): PackedVector3Array { return _C(this, 3884) as PackedVector3Array; }
+
+    /**
+     * Returns the cache of tilts as a {@link PackedFloat32Array}.
+     */
+    getBakedTilts(): PackedFloat32Array { return _C(this, 3885) as PackedFloat32Array; }
+
+    /**
+     * Returns the cache of up vectors as a {@link PackedVector3Array}.
+     * If {@link upVectorEnabled} is `false`, the cache will be empty.
+     */
+    getBakedUpVectors(): PackedVector3Array { return _C(this, 3886) as PackedVector3Array; }
+
+    /**
+     * Returns the closest point on baked segments (in curve's local space) to `toPoint`.
+     * `toPoint` must be in this curve's local space.
+     */
+    getClosestPoint(toPoint: Vector3): Vector3 { return _C(this, 4174, toPoint) as Vector3; }
+
+    /**
+     * Returns the closest offset to `toPoint`. This offset is meant to be used in {@link sampleBaked} or {@link sampleBakedUpVector}.
+     * `toPoint` must be in this curve's local space.
+     */
+    getClosestOffset(toPoint: Vector3): number { return _C(this, 4173, toPoint) as number; }
+
+    /**
+     * Returns a list of points along the curve, with a curvature controlled point density. That is, the curvier parts will have more points than the straighter parts.
+     * This approximation makes straight segments between each point, then subdivides those segments until the resulting shape is similar enough.
+     * `maxStages` controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care!
+     * `toleranceDegrees` controls how many degrees the midpoint of a segment may deviate from the real curve, before the segment has to be subdivided.
+     */
+    tessellate(maxStages?: number /* = 5 */, toleranceDegrees?: number /* = 4 */): PackedVector3Array { return _C(this, 14146, maxStages, toleranceDegrees) as PackedVector3Array; }
+
+    /**
+     * Returns a list of points along the curve, with almost uniform density. `maxStages` controls how many subdivisions a curve segment may face before it is considered approximate enough. Each subdivision splits the segment in half, so the default 5 stages may mean up to 32 subdivisions per curve segment. Increase with care!
+     * `toleranceLength` controls the maximal distance between two neighboring points, before the segment has to be subdivided.
+     */
+    tessellateEvenLength(maxStages?: number /* = 5 */, toleranceLength?: number /* = 0.2 */): PackedVector3Array { return _C(this, 14147, maxStages, toleranceLength) as PackedVector3Array; }
+
+    /**
+     * If `true`, and the curve has more than 2 control points, the last point and the first one will be connected in a loop.
+     */
+    get closed(): boolean { return _C(this, 7835) as boolean; }
+    set closed(v: boolean) { _C(this, 10872, v); }
+
+    /**
+     * The distance in meters between two adjacent cached points. Changing it forces the cache to be recomputed the next time the {@link getBakedPoints} or {@link getBakedLength} function is called. The smaller the distance, the more points in the cache and the more memory it will consume, so use with care.
+     */
+    get bakeInterval(): number { return _C(this, 3874) as number; }
+    set bakeInterval(v: number) { _C(this, 10628, v); }
+
+    /**
+     * The number of points describing the curve.
+     */
+    get pointCount(): number { return _C(this, 5942) as number; }
+    set pointCount(v: number) { _C(this, 12352, v); }
+
+    /**
+     * If `true`, the curve will bake up vectors used for orientation. This is used when {@link PathFollow3D.rotationMode} is set to {@link PathFollow3D.ROTATION_ORIENTED}. Changing it forces the cache to be recomputed.
+     */
+    get upVectorEnabled(): boolean { return _C(this, 8384) as boolean; }
+    set upVectorEnabled(v: boolean) { _C(this, 13179, v); }
+
+    static readonly name = _R(237, Curve3D);
+}

package/gen/classes/CurveTexture.ts

@@ -0,0 +1,48 @@
+// 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 { Curve } from './Curve.ts';
+
+/**
+ * A 1D texture where pixel brightness corresponds to points on a unit {@link Curve} resource, either in grayscale or in red. This visual representation simplifies the task of saving curves as image files.
+ * If you need to store up to 3 curves within a single texture, use {@link CurveXYZTexture} instead. See also {@link GradientTexture1D} and {@link GradientTexture2D}.
+ */
+export class CurveTexture extends Texture2D {
+    constructor(name = 238) { super(name); }
+
+    /**
+     * The width of the texture (in pixels). Higher values make it possible to represent high-frequency data better (such as sudden direction changes), at the cost of increased generation time and memory usage.
+     */
+    get width(): number { return _C(this, 7148) as number; }
+    set width(v: number) { _C(this, 13372, v); }
+
+    /**
+     * The format the texture should be generated with. When passing a CurveTexture as an input to a {@link Shader}, this may need to be adjusted.
+     */
+    get textureMode(): TextureMode { return _C(this, 6738) as TextureMode; }
+    set textureMode(v: TextureMode) { _C(this, 13035, v); }
+
+    /**
+     * The {@link Curve} that is rendered onto the texture. Should be a unit {@link Curve}.
+     */
+    get curve(): Curve { return _C(this, 4370) as Curve; }
+    set curve(v: Curve) { _C(this, 10993, v); }
+
+    static readonly name = _R(238, CurveTexture);
+}
+
+export const TextureMode = {
+    /**
+     * Store the curve equally across the red, green and blue channels. This uses more video memory, but is more compatible with shaders that only read the green and blue values.
+     */
+    TEXTURE_MODE_RGB: 0,
+    /**
+     * Store the curve only in the red channel. This saves video memory, but some custom shaders may not be able to work with this.
+     */
+    TEXTURE_MODE_RED: 1,
+} as const;
+
+export type TextureMode = (typeof TextureMode)[keyof typeof TextureMode];
+

package/gen/classes/CurveXYZTexture.ts

@@ -0,0 +1,40 @@
+// 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 { Curve } from './Curve.ts';
+
+/**
+ * A 1D texture where the red, green, and blue color channels correspond to points on 3 unit {@link Curve} resources. Compared to using separate {@link CurveTexture}s, this further simplifies the task of saving curves as image files.
+ * If you only need to store one curve within a single texture, use {@link CurveTexture} instead. See also {@link GradientTexture1D} and {@link GradientTexture2D}.
+ */
+export class CurveXYZTexture extends Texture2D {
+    constructor(name = 239) { super(name); }
+
+    /**
+     * The width of the texture (in pixels). Higher values make it possible to represent high-frequency data better (such as sudden direction changes), at the cost of increased generation time and memory usage.
+     */
+    get width(): number { return _C(this, 7148) as number; }
+    set width(v: number) { _C(this, 13372, v); }
+
+    /**
+     * The {@link Curve} that is rendered onto the texture's red channel. Should be a unit {@link Curve}.
+     */
+    get curveX(): Curve { return _C(this, 4372) as Curve; }
+    set curveX(v: Curve) { _C(this, 10995, v); }
+
+    /**
+     * The {@link Curve} that is rendered onto the texture's green channel. Should be a unit {@link Curve}.
+     */
+    get curveY(): Curve { return _C(this, 4373) as Curve; }
+    set curveY(v: Curve) { _C(this, 10996, v); }
+
+    /**
+     * The {@link Curve} that is rendered onto the texture's blue channel. Should be a unit {@link Curve}.
+     */
+    get curveZ(): Curve { return _C(this, 4374) as Curve; }
+    set curveZ(v: Curve) { _C(this, 10997, v); }
+
+    static readonly name = _R(239, CurveXYZTexture);
+}

package/gen/classes/CylinderMesh.ts

@@ -0,0 +1,58 @@
+// 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';
+
+/**
+ * Class representing a cylindrical {@link PrimitiveMesh}. This class can be used to create cones by setting either the {@link topRadius} or {@link bottomRadius} properties to `0.0`.
+ */
+export class CylinderMesh extends PrimitiveMesh {
+    constructor(name = 240) { super(name); }
+
+    /**
+     * Top radius of the cylinder. If set to `0.0`, the top faces will not be generated, resulting in a conic shape. See also {@link capTop}.
+     */
+    get topRadius(): number { return _C(this, 6847) as number; }
+    set topRadius(v: number) { _C(this, 13116, v); }
+
+    /**
+     * Bottom radius of the cylinder. If set to `0.0`, the bottom faces will not be generated, resulting in a conic shape. See also {@link capBottom}.
+     */
+    get bottomRadius(): number { return _C(this, 3990) as number; }
+    set bottomRadius(v: number) { _C(this, 10730, v); }
+
+    /**
+     * Full height of the cylinder.
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    /**
+     * Number of radial segments on the cylinder. Higher values result in a more detailed cylinder/cone at the cost of performance.
+     */
+    get radialSegments(): number { return _C(this, 6065) as number; }
+    set radialSegments(v: number) { _C(this, 12464, v); }
+
+    /**
+     * Number of edge rings along the height of the cylinder. Changing {@link rings} does not have any visual impact unless a shader or procedural mesh tool is used to alter the vertex data. Higher values result in more subdivisions, which can be used to create smoother-looking effects with shaders or procedural mesh tools (at the cost of performance). When not altering the vertex data using a shader or procedural mesh tool, {@link rings} should be kept to its default value.
+     */
+    get rings(): number { return _C(this, 6185) as number; }
+    set rings(v: number) { _C(this, 12562, v); }
+
+    /**
+     * If `true`, generates a cap at the top of the cylinder. This can be set to `false` to speed up generation and rendering when the cap is never seen by the camera. See also {@link topRadius}.
+     * **Note:** If {@link topRadius} is `0.0`, cap generation is always skipped even if {@link capTop} is `true`.
+     */
+    get capTop(): boolean { return _C(this, 7816) as boolean; }
+    set capTop(v: boolean) { _C(this, 10799, v); }
+
+    /**
+     * If `true`, generates a cap at the bottom of the cylinder. This can be set to `false` to speed up generation and rendering when the cap is never seen by the camera. See also {@link bottomRadius}.
+     * **Note:** If {@link bottomRadius} is `0.0`, cap generation is always skipped even if {@link capBottom} is `true`.
+     */
+    get capBottom(): boolean { return _C(this, 7815) as boolean; }
+    set capBottom(v: boolean) { _C(this, 10798, v); }
+
+    static readonly name = _R(240, CylinderMesh);
+}