@ringozz/godot 0.1.0

package/gen/classes/CSGCylinder3D.ts

@@ -0,0 +1,52 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CSGPrimitive3D } from './CSGPrimitive3D.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * This node allows you to create a cylinder (or cone) for use with the CSG system.
+ * **Note:** CSG nodes are intended to be used for level prototyping. Creating CSG nodes has a significant CPU cost compared to creating a {@link MeshInstance3D} with a {@link PrimitiveMesh}. Moving a CSG node within another CSG node also has a significant CPU cost, so it should be avoided during gameplay.
+ */
+export class CSGCylinder3D extends CSGPrimitive3D {
+    constructor(name = 166) { super(name); }
+
+    /**
+     * The radius of the cylinder.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * The height of the cylinder.
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    /**
+     * The number of sides of the cylinder, the higher this number the more detail there will be in the cylinder.
+     */
+    get sides(): number { return _C(this, 6389) as number; }
+    set sides(v: number) { _C(this, 12747, v); }
+
+    /**
+     * If `true` a cone is created, the {@link radius} will only apply to one side.
+     */
+    get cone(): boolean { return _C(this, 7852) as boolean; }
+    set cone(v: boolean) { _C(this, 10935, v); }
+
+    /**
+     * If `true` the normals of the cylinder are set to give a smooth effect making the cylinder seem rounded. If `false` the cylinder will have a flat shaded look.
+     */
+    get smoothFaces(): boolean { return _C(this, 6444) as boolean; }
+    set smoothFaces(v: boolean) { _C(this, 12795, v); }
+
+    /**
+     * The material used to render the cylinder.
+     */
+    get material(): Material { return _C(this, 5452) as Material; }
+    set material(v: Material) { _C(this, 11978, v); }
+
+    static readonly name = _R(166, CSGCylinder3D);
+}

package/gen/classes/CSGMesh3D.ts

@@ -0,0 +1,32 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CSGPrimitive3D } from './CSGPrimitive3D.ts';
+import type { Material } from './Material.ts';
+import type { Mesh } from './Mesh.ts';
+
+/**
+ * This CSG node allows you to use any mesh resource as a CSG shape, provided it is *manifold*. A manifold shape is closed, does not self-intersect, does not contain internal faces and has no edges that connect to more than two faces. See also {@link CSGPolygon3D} for drawing 2D extruded polygons to be used as CSG nodes.
+ * **Note:** CSG nodes are intended to be used for level prototyping. Creating CSG nodes has a significant CPU cost compared to creating a {@link MeshInstance3D} with a {@link PrimitiveMesh}. Moving a CSG node within another CSG node also has a significant CPU cost, so it should be avoided during gameplay.
+ */
+export class CSGMesh3D extends CSGPrimitive3D {
+    constructor(name = 167) { super(name); }
+
+    /**
+     * The {@link Mesh} resource to use as a CSG shape.
+     * **Note:** Some {@link Mesh} types such as {@link PlaneMesh}, {@link PointMesh}, {@link QuadMesh}, and {@link RibbonTrailMesh} are excluded from the type hint for this property, as these primitives are non-*manifold* and thus not compatible with the CSG algorithm.
+     * **Note:** When using an {@link ArrayMesh}, all vertex attributes except {@link Mesh.ARRAY_VERTEX}, {@link Mesh.ARRAY_NORMAL} and {@link Mesh.ARRAY_TEX_UV} are left unused. Only {@link Mesh.ARRAY_VERTEX} and {@link Mesh.ARRAY_TEX_UV} will be passed to the GPU.
+     * {@link Mesh.ARRAY_NORMAL} is only used to determine which faces require the use of flat shading. By default, CSGMesh will ignore the mesh's vertex normals, recalculate them for each vertex and use a smooth shader. If a flat shader is required for a face, ensure that all vertex normals of the face are approximately equal.
+     */
+    get mesh(): Mesh { return _C(this, 5511) as Mesh; }
+    set mesh(v: Mesh) { _C(this, 12024, v); }
+
+    /**
+     * The {@link Material} used in drawing the CSG shape.
+     */
+    get material(): Material { return _C(this, 5452) as Material; }
+    set material(v: Material) { _C(this, 11978, v); }
+
+    static readonly name = _R(167, CSGMesh3D);
+}

package/gen/classes/CSGPolygon3D.ts

@@ -0,0 +1,170 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CSGPrimitive3D } from './CSGPrimitive3D.ts';
+import type { NodePath, PackedVector2Array } from '../heap-types/index.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * An array of 2D points is extruded to quickly and easily create a variety of 3D meshes. See also {@link CSGMesh3D} for using 3D meshes as CSG nodes.
+ * **Note:** CSG nodes are intended to be used for level prototyping. Creating CSG nodes has a significant CPU cost compared to creating a {@link MeshInstance3D} with a {@link PrimitiveMesh}. Moving a CSG node within another CSG node also has a significant CPU cost, so it should be avoided during gameplay.
+ */
+export class CSGPolygon3D extends CSGPrimitive3D {
+    constructor(name = 168) { super(name); }
+
+    /**
+     * The point array that defines the 2D polygon that is extruded. This can be a convex or concave polygon with 3 or more points. The polygon must *not* have any intersecting edges. Otherwise, triangulation will fail and no mesh will be generated.
+     * **Note:** If only 1 or 2 points are defined in {@link polygon}, no mesh will be generated.
+     */
+    get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
+    set polygon(v: PackedVector2Array) { _C(this, 12373, v); }
+
+    /**
+     * The {@link mode} used to extrude the {@link polygon}.
+     */
+    get mode(): Mode { return _C(this, 5568) as Mode; }
+    set mode(v: Mode) { _C(this, 12073, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_DEPTH}, the depth of the extrusion.
+     */
+    get depth(): number { return _C(this, 4468) as number; }
+    set depth(v: number) { _C(this, 11083, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_SPIN}, the total number of degrees the {@link polygon} is rotated when extruding.
+     */
+    get spinDegrees(): number { return _C(this, 6496) as number; }
+    set spinDegrees(v: number) { _C(this, 12840, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_SPIN}, the number of extrusions made.
+     */
+    get spinSides(): number { return _C(this, 6497) as number; }
+    set spinSides(v: number) { _C(this, 12841, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, the location of the {@link Path3D} object used to extrude the {@link polygon}.
+     */
+    get pathNode(): NodePath { return _C(this, 5851) as NodePath; }
+    set pathNode(v: NodePath) { _C(this, 12284, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, this will determine if the interval should be by distance ({@link PATH_INTERVAL_DISTANCE}) or subdivision fractions ({@link PATH_INTERVAL_SUBDIVIDE}).
+     */
+    get pathIntervalType(): PathIntervalType { return _C(this, 5847) as PathIntervalType; }
+    set pathIntervalType(v: PathIntervalType) { _C(this, 12278, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, the path interval or ratio of path points to extrusions.
+     */
+    get pathInterval(): number { return _C(this, 5846) as number; }
+    set pathInterval(v: number) { _C(this, 12277, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, extrusions that are less than this angle, will be merged together to reduce polygon count.
+     */
+    get pathSimplifyAngle(): number { return _C(this, 5861) as number; }
+    set pathSimplifyAngle(v: number) { _C(this, 12294, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, the path rotation method used to rotate the {@link polygon} as it is extruded.
+     */
+    get pathRotation(): PathRotation { return _C(this, 5857) as PathRotation; }
+    set pathRotation(v: PathRotation) { _C(this, 12290, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, if `true` the polygon will be rotated according to the proper tangent of the path at the sampled points. If `false` an approximation is used, which decreases in accuracy as the number of subdivisions decreases.
+     */
+    get pathRotationAccurate(): boolean { return _C(this, 5858) as boolean; }
+    set pathRotationAccurate(v: boolean) { _C(this, 12291, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, if `true` the {@link Transform3D} of the {@link CSGPolygon3D} is used as the starting point for the extrusions, not the {@link Transform3D} of the {@link pathNode}.
+     */
+    get pathLocal(): boolean { return _C(this, 8171) as boolean; }
+    set pathLocal(v: boolean) { _C(this, 12281, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, by default, the top half of the {@link material} is stretched along the entire length of the extruded shape. If `false` the top half of the material is repeated every step of the extrusion.
+     */
+    get pathContinuousU(): boolean { return _C(this, 8168) as boolean; }
+    set pathContinuousU(v: boolean) { _C(this, 12274, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, this is the distance along the path, in meters, the texture coordinates will tile. When set to 0, texture coordinates will match geometry exactly with no tiling.
+     */
+    get pathUDistance(): number { return _C(this, 5864) as number; }
+    set pathUDistance(v: number) { _C(this, 12296, v); }
+
+    /**
+     * When {@link mode} is {@link MODE_PATH}, if `true` the ends of the path are joined, by adding an extrusion between the last and first points of the path.
+     */
+    get pathJoined(): boolean { return _C(this, 8170) as boolean; }
+    set pathJoined(v: boolean) { _C(this, 12279, v); }
+
+    /**
+     * If `true`, applies smooth shading to the extrusions.
+     */
+    get smoothFaces(): boolean { return _C(this, 6444) as boolean; }
+    set smoothFaces(v: boolean) { _C(this, 12795, v); }
+
+    /**
+     * Material to use for the resulting mesh. The UV maps the top half of the material to the extruded shape (U along the length of the extrusions and V around the outline of the {@link polygon}), the bottom-left quarter to the front end face, and the bottom-right quarter to the back end face.
+     */
+    get material(): Material { return _C(this, 5452) as Material; }
+    set material(v: Material) { _C(this, 11978, v); }
+
+    static readonly name = _R(168, CSGPolygon3D);
+}
+
+export const Mode = {
+    /**
+     * The {@link polygon} shape is extruded along the negative Z axis.
+     */
+    MODE_DEPTH: 0,
+    /**
+     * The {@link polygon} shape is extruded by rotating it around the Y axis.
+     */
+    MODE_SPIN: 1,
+    /**
+     * The {@link polygon} shape is extruded along the {@link Path3D} specified in {@link pathNode}.
+     */
+    MODE_PATH: 2,
+} as const;
+
+export type Mode = (typeof Mode)[keyof typeof Mode];
+
+export const PathRotation = {
+    /**
+     * The {@link polygon} shape is not rotated.
+     * **Note:** Requires the path Z coordinates to continually decrease to ensure viable shapes.
+     */
+    PATH_ROTATION_POLYGON: 0,
+    /**
+     * The {@link polygon} shape is rotated along the path, but it is not rotated around the path axis.
+     * **Note:** Requires the path Z coordinates to continually decrease to ensure viable shapes.
+     */
+    PATH_ROTATION_PATH: 1,
+    /**
+     * The {@link polygon} shape follows the path and its rotations around the path axis.
+     */
+    PATH_ROTATION_PATH_FOLLOW: 2,
+} as const;
+
+export type PathRotation = (typeof PathRotation)[keyof typeof PathRotation];
+
+export const PathIntervalType = {
+    /**
+     * When {@link mode} is set to {@link MODE_PATH}, {@link pathInterval} will determine the distance, in meters, each interval of the path will extrude.
+     */
+    PATH_INTERVAL_DISTANCE: 0,
+    /**
+     * When {@link mode} is set to {@link MODE_PATH}, {@link pathInterval} will subdivide the polygons along the path.
+     */
+    PATH_INTERVAL_SUBDIVIDE: 1,
+} as const;
+
+export type PathIntervalType = (typeof PathIntervalType)[keyof typeof PathIntervalType];
+

package/gen/classes/CSGPrimitive3D.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 { CSGShape3D } from './CSGShape3D.ts';
+
+/**
+ * Parent class for various CSG primitives. It contains code and functionality that is common between them. It cannot be used directly. Instead use one of the various classes that inherit from it.
+ * **Note:** CSG nodes are intended to be used for level prototyping. Creating CSG nodes has a significant CPU cost compared to creating a {@link MeshInstance3D} with a {@link PrimitiveMesh}. Moving a CSG node within another CSG node also has a significant CPU cost, so it should be avoided during gameplay.
+ */
+export class CSGPrimitive3D extends CSGShape3D {
+
+    /**
+     * If set, the order of the vertices in each triangle are reversed resulting in the backside of the mesh being drawn.
+     */
+    get flipFaces(): boolean { return _C(this, 4810) as boolean; }
+    set flipFaces(v: boolean) { _C(this, 11416, v); }
+
+    static readonly name = _R(169, CSGPrimitive3D);
+}

package/gen/classes/CSGShape3D.ts

@@ -0,0 +1,140 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GeometryInstance3D } from './GeometryInstance3D.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { ArrayMesh } from './ArrayMesh.ts';
+import type { ConcavePolygonShape3D } from './ConcavePolygonShape3D.ts';
+
+/**
+ * This is the CSG base class that provides CSG operation support to the various CSG nodes in Godot.
+ * **Performance:** CSG nodes are only intended for prototyping as they have a significant CPU performance cost. Consider baking final CSG operation results into static geometry that replaces the CSG nodes.
+ * Individual CSG root node results can be baked to nodes with static resources with the editor menu that appears when a CSG root node is selected.
+ * Individual CSG root nodes can also be baked to static resources with scripts by calling {@link bakeStaticMesh} for the visual mesh or {@link bakeCollisionShape} for the physics collision.
+ * Entire scenes of CSG nodes can be baked to static geometry and exported with the editor glTF scene exporter: **Scene > Export As... > glTF 2.0 Scene...**
+ */
+export class CSGShape3D extends GeometryInstance3D {
+
+    /**
+     * Returns `true` if this is a root shape and is thus the object that is rendered.
+     */
+    isRootShape(): boolean { return _C(this, 8252) as boolean; }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link collisionMask}, given a `layerNumber` between 1 and 32.
+     */
+    setCollisionMaskValue(layerNumber: number, value: boolean): void { _C(this, 10895, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link collisionMask} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getCollisionMaskValue(layerNumber: number): boolean { return _C(this, 4206, layerNumber) as boolean; }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link collisionLayer}, given a `layerNumber` between 1 and 32.
+     */
+    setCollisionLayerValue(layerNumber: number, value: boolean): void { _C(this, 10893, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link collisionLayer} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getCollisionLayerValue(layerNumber: number): boolean { return _C(this, 4203, layerNumber) as boolean; }
+
+    /**
+     * Returns a baked physics {@link ConcavePolygonShape3D} of this node's CSG operation result. Returns an empty shape if the node is not a CSG root node or has no valid geometry.
+     * **Performance:** If the CSG operation results in a very detailed geometry with many faces physics performance will be very slow. Concave shapes should in general only be used for static level geometry and not with dynamic objects that are moving.
+     * **Note:** CSG mesh data updates are deferred, which means they are updated with a delay of one rendered frame. To avoid getting an empty shape or outdated mesh data, make sure to call `await get_tree().process_frame` before using {@link bakeCollisionShape} in {@link Node.Ready} or after changing properties on the {@link CSGShape3D}.
+     */
+    bakeCollisionShape(): ConcavePolygonShape3D { return _C(this, 1709) as ConcavePolygonShape3D; }
+
+    /**
+     * Returns an {@link Array} with two elements, the first is the {@link Transform3D} of this node and the second is the root {@link Mesh} of this node. Only works when this node is the root shape.
+     * **Note:** CSG mesh data updates are deferred, which means they are updated with a delay of one rendered frame. To avoid getting an empty shape or outdated mesh data, make sure to call `await get_tree().process_frame` before using {@link getMeshes} in {@link Node.Ready} or after changing properties on the {@link CSGShape3D}.
+     */
+    getMeshes(): GodotArray { return _C(this, 5517) as GodotArray; }
+
+    /**
+     * Returns a baked static {@link ArrayMesh} of this node's CSG operation result. Materials from involved CSG nodes are added as extra mesh surfaces. Returns an empty mesh if the node is not a CSG root node or has no valid geometry.
+     * **Note:** CSG mesh data updates are deferred, which means they are updated with a delay of one rendered frame. To avoid getting an empty mesh or outdated mesh data, make sure to call `await get_tree().process_frame` before using {@link bakeStaticMesh} in {@link Node.Ready} or after changing properties on the {@link CSGShape3D}.
+     */
+    bakeStaticMesh(): ArrayMesh { return _C(this, 1724) as ArrayMesh; }
+
+    /**
+     * Enables automatic smoothing. This overrides any smoothing on the CSG node and instead uses {@link smoothingAngle} to calculate normals based on the angle between faces.
+     * Children of a {@link CSGCombiner3D} node will be treated as a single mesh.
+     */
+    get autosmooth(): boolean { return _C(this, 7779) as boolean; }
+    set autosmooth(v: boolean) { _C(this, 10593, v); }
+
+    /**
+     * When autosmooth is enabled, faces with an angle between them greater than this will be smoothed, while faces with a smaller angle will remain sharp.
+     * Note: An angle lower than 0.1 will cause all smoothing to be disabled, this can be used to increase performance.
+     */
+    get smoothingAngle(): number { return _C(this, 6445) as number; }
+    set smoothingAngle(v: number) { _C(this, 12798, v); }
+
+    /**
+     * The operation that is performed on this shape. This is ignored for the first CSG child node as the operation is between this node and the previous child of this nodes parent.
+     */
+    get operation(): Operation { return _C(this, 5727) as Operation; }
+    set operation(v: Operation) { _C(this, 12192, v); }
+
+    /**
+     * This property does nothing.
+     */
+    get snap(): number { return _C(this, 6446) as number; }
+    set snap(v: number) { _C(this, 12799, v); }
+
+    /**
+     * Calculate tangents for the CSG shape which allows the use of normal and height maps. This is only applied on the root shape, this setting is ignored on any child. Setting this to `false` can speed up shape generation slightly.
+     */
+    get calculateTangents(): boolean { return _C(this, 7812) as boolean; }
+    set calculateTangents(v: boolean) { _C(this, 10779, v); }
+
+    /**
+     * Adds a collision shape to the physics engine for our CSG shape. This will always act like a static body. Note that the collision shape is still active even if the CSG shape itself is hidden. See also {@link collisionMask} and {@link collisionPriority}.
+     */
+    get useCollision(): boolean { return _C(this, 8395) as boolean; }
+    set useCollision(v: boolean) { _C(this, 13201, v); }
+
+    /**
+     * The physics layers this area is in.
+     * Collidable objects can exist in any of 32 different layers. These layers work like a tagging system, and are not visual. A collidable can use these layers to select with which objects it can collide, using the collision_mask property.
+     * A contact is detected if object A is in any of the layers that object B scans, or object B is in any layer scanned by object A. See [Collision layers and masks]($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+     */
+    get collisionLayer(): number { return _C(this, 4202) as number; }
+    set collisionLayer(v: number) { _C(this, 10892, v); }
+
+    /**
+     * The physics layers this CSG shape scans for collisions. Only effective if {@link useCollision} is `true`. See [Collision layers and masks]($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+     */
+    get collisionMask(): number { return _C(this, 4205) as number; }
+    set collisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * The priority used to solve colliding when occurring penetration. Only effective if {@link useCollision} is `true`. The higher the priority is, the lower the penetration into the object will be. This can for example be used to prevent the player from breaking through the boundaries of a level.
+     */
+    get collisionPriority(): number { return _C(this, 4214) as number; }
+    set collisionPriority(v: number) { _C(this, 10902, v); }
+
+    static readonly name = _R(170, CSGShape3D);
+}
+
+export const Operation = {
+    /**
+     * Geometry of both primitives is merged, intersecting geometry is removed.
+     */
+    OPERATION_UNION: 0,
+    /**
+     * Only intersecting geometry remains, the rest is removed.
+     */
+    OPERATION_INTERSECTION: 1,
+    /**
+     * The second shape is subtracted from the first, leaving a dent with its shape.
+     */
+    OPERATION_SUBTRACTION: 2,
+} as const;
+
+export type Operation = (typeof Operation)[keyof typeof Operation];
+

package/gen/classes/CSGSphere3D.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CSGPrimitive3D } from './CSGPrimitive3D.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * This node allows you to create a sphere for use with the CSG system.
+ * **Note:** CSG nodes are intended to be used for level prototyping. Creating CSG nodes has a significant CPU cost compared to creating a {@link MeshInstance3D} with a {@link PrimitiveMesh}. Moving a CSG node within another CSG node also has a significant CPU cost, so it should be avoided during gameplay.
+ */
+export class CSGSphere3D extends CSGPrimitive3D {
+    constructor(name = 171) { super(name); }
+
+    /**
+     * Radius of the sphere.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * Number of vertical slices for the sphere.
+     */
+    get radialSegments(): number { return _C(this, 6065) as number; }
+    set radialSegments(v: number) { _C(this, 12464, v); }
+
+    /**
+     * Number of horizontal slices for the sphere.
+     */
+    get rings(): number { return _C(this, 6185) as number; }
+    set rings(v: number) { _C(this, 12562, v); }
+
+    /**
+     * If `true` the normals of the sphere are set to give a smooth effect making the sphere seem rounded. If `false` the sphere will have a flat shaded look.
+     */
+    get smoothFaces(): boolean { return _C(this, 6444) as boolean; }
+    set smoothFaces(v: boolean) { _C(this, 12795, v); }
+
+    /**
+     * The material used to render the sphere.
+     */
+    get material(): Material { return _C(this, 5452) as Material; }
+    set material(v: Material) { _C(this, 11978, v); }
+
+    static readonly name = _R(171, CSGSphere3D);
+}

package/gen/classes/CSGTorus3D.ts

@@ -0,0 +1,52 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CSGPrimitive3D } from './CSGPrimitive3D.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * This node allows you to create a torus for use with the CSG system.
+ * **Note:** CSG nodes are intended to be used for level prototyping. Creating CSG nodes has a significant CPU cost compared to creating a {@link MeshInstance3D} with a {@link PrimitiveMesh}. Moving a CSG node within another CSG node also has a significant CPU cost, so it should be avoided during gameplay.
+ */
+export class CSGTorus3D extends CSGPrimitive3D {
+    constructor(name = 172) { super(name); }
+
+    /**
+     * The inner radius of the torus.
+     */
+    get innerRadius(): number { return _C(this, 5105) as number; }
+    set innerRadius(v: number) { _C(this, 11706, v); }
+
+    /**
+     * The outer radius of the torus.
+     */
+    get outerRadius(): number { return _C(this, 5754) as number; }
+    set outerRadius(v: number) { _C(this, 12213, v); }
+
+    /**
+     * The number of slices the torus is constructed of.
+     */
+    get sides(): number { return _C(this, 6389) as number; }
+    set sides(v: number) { _C(this, 12747, v); }
+
+    /**
+     * The number of edges each ring of the torus is constructed of.
+     */
+    get ringSides(): number { return _C(this, 6184) as number; }
+    set ringSides(v: number) { _C(this, 12561, v); }
+
+    /**
+     * If `true` the normals of the torus are set to give a smooth effect making the torus seem rounded. If `false` the torus will have a flat shaded look.
+     */
+    get smoothFaces(): boolean { return _C(this, 6444) as boolean; }
+    set smoothFaces(v: boolean) { _C(this, 12795, v); }
+
+    /**
+     * The material used to render the torus.
+     */
+    get material(): Material { return _C(this, 5452) as Material; }
+    set material(v: Material) { _C(this, 11978, v); }
+
+    static readonly name = _R(172, CSGTorus3D);
+}

package/gen/classes/CallbackTweener.ts

@@ -0,0 +1,29 @@
+// 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';
+
+/**
+ * {@link CallbackTweener} is used to call a method in a tweening sequence. See {@link Tween.tweenCallback} for more usage information.
+ * The tweener will finish automatically if the callback's target object is freed.
+ * **Note:** {@link Tween.tweenCallback} is the only correct way to create {@link CallbackTweener}. Any {@link CallbackTweener} created manually will not function correctly.
+ */
+export class CallbackTweener extends Tweener {
+    constructor(name = 173) { super(name); }
+
+    /**
+     * Makes the callback call delayed by given time in seconds.
+     * **Example:** Call {@link Node.queueFree} after 2 seconds:
+     *
+     * ```text
+     *
+     * var tween = get_tree().create_tween()
+     * tween.tween_callback(queue_free).set_delay(2)
+     *
+     * ```
+     */
+    setDelay(delay: number /* double */): CallbackTweener { return _C(this, 11075, delay) as CallbackTweener; }
+
+    static readonly name = _R(173, CallbackTweener);
+}