@ringozz/godot 0.1.0

package/gen/classes/Sky.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 { Resource } from './Resource.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * The {@link Sky} class uses a {@link Material} to render a 3D environment's background and the light it emits by updating the reflection/radiance cubemaps.
+ */
+export class Sky extends Resource {
+    constructor(name = 718) { super(name); }
+
+    /**
+     * {@link Material} used to draw the background. Can be {@link PanoramaSkyMaterial}, {@link ProceduralSkyMaterial}, {@link PhysicalSkyMaterial}, or even a {@link ShaderMaterial} if you want to use your own custom shader.
+     */
+    get skyMaterial(): Material { return _C(this, 5452) as Material; }
+    set skyMaterial(v: Material) { _C(this, 11978, v); }
+
+    /**
+     * The method for generating the radiance map from the sky. The radiance map is a cubemap with increasingly blurry versions of the sky corresponding to different levels of roughness. Radiance maps can be expensive to calculate.
+     */
+    get processMode(): ProcessMode { return _C(this, 6026) as ProcessMode; }
+    set processMode(v: ProcessMode) { _C(this, 12427, v); }
+
+    /**
+     * The {@link Sky}'s radiance map size. The higher the radiance map size, the more detailed the lighting from the {@link Sky} will be.
+     * **Note:** Some hardware will have trouble with higher radiance sizes, especially {@link RADIANCE_SIZE_512} and above. Only use such high values on high-end hardware.
+     */
+    get radianceSize(): RadianceSize { return _C(this, 6067) as RadianceSize; }
+    set radianceSize(v: RadianceSize) { _C(this, 12466, v); }
+
+    static readonly name = _R(718, Sky);
+}
+
+export const RadianceSize = {
+    /**
+     * Radiance texture size is 32×32 pixels.
+     */
+    RADIANCE_SIZE_32: 0,
+    /**
+     * Radiance texture size is 64×64 pixels.
+     */
+    RADIANCE_SIZE_64: 1,
+    /**
+     * Radiance texture size is 128×128 pixels.
+     */
+    RADIANCE_SIZE_128: 2,
+    /**
+     * Radiance texture size is 256×256 pixels.
+     */
+    RADIANCE_SIZE_256: 3,
+    /**
+     * Radiance texture size is 512×512 pixels.
+     */
+    RADIANCE_SIZE_512: 4,
+    /**
+     * Radiance texture size is 1024×1024 pixels.
+     */
+    RADIANCE_SIZE_1024: 5,
+    /**
+     * Radiance texture size is 2048×2048 pixels.
+     */
+    RADIANCE_SIZE_2048: 6,
+    /**
+     * Represents the size of the {@link RadianceSize} enum.
+     */
+    RADIANCE_SIZE_MAX: 7,
+} as const;
+
+export type RadianceSize = (typeof RadianceSize)[keyof typeof RadianceSize];
+
+export const ProcessMode = {
+    /**
+     * Automatically selects the appropriate process mode based on your sky shader. If your shader uses `TIME` or `POSITION`, this will use {@link PROCESS_MODE_REALTIME}. If your shader uses any of the `LIGHT_*` variables or any custom uniforms, this uses {@link PROCESS_MODE_INCREMENTAL}. Otherwise, this defaults to {@link PROCESS_MODE_QUALITY}.
+     */
+    PROCESS_MODE_AUTOMATIC: 0,
+    /**
+     * Uses high quality importance sampling to process the radiance map. In general, this results in much higher quality than {@link PROCESS_MODE_REALTIME} but takes much longer to generate. This should not be used if you plan on changing the sky at runtime. If you are finding that the reflection is not blurry enough and is showing sparkles or fireflies, try increasing {@link ProjectSettings.rendering/reflections/skyReflections/ggxSamples}.
+     */
+    PROCESS_MODE_QUALITY: 1,
+    /**
+     * Uses the same high quality importance sampling to process the radiance map as {@link PROCESS_MODE_QUALITY}, but updates over several frames. The number of frames is determined by {@link ProjectSettings.rendering/reflections/skyReflections/roughnessLayers}. Use this when you need highest quality radiance maps, but have a sky that updates slowly.
+     */
+    PROCESS_MODE_INCREMENTAL: 2,
+    /**
+     * Uses the fast filtering algorithm to process the radiance map. In general this results in lower quality, but substantially faster run times. If you need better quality, but still need to update the sky every frame, consider turning on {@link ProjectSettings.rendering/reflections/skyReflections/fastFilterHighQuality}.
+     * **Note:** The fast filtering algorithm is limited to 256×256 cubemaps, so {@link radianceSize} must be set to {@link RADIANCE_SIZE_256}. Otherwise, a warning is printed and the overridden radiance size is ignored.
+     */
+    PROCESS_MODE_REALTIME: 3,
+} as const;
+
+export type ProcessMode = (typeof ProcessMode)[keyof typeof ProcessMode];
+

package/gen/classes/Slider.ts

@@ -0,0 +1,78 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Range } from './Range.ts';
+import type { Signal } from '../heap-types/index.ts';
+
+/**
+ * Abstract base class for sliders, used to adjust a value by moving a grabber along a horizontal or vertical axis. Sliders are {@link Range}-based controls.
+ */
+export class Slider extends Range {
+
+    /**
+     * If `true`, the slider can be interacted with. If `false`, the value can be changed only by code.
+     */
+    get editable(): boolean { return _C(this, 7916) as boolean; }
+    set editable(v: boolean) { _C(this, 11216, v); }
+
+    /**
+     * If `true`, the value can be changed using the mouse wheel.
+     */
+    get scrollable(): boolean { return _C(this, 8278) as boolean; }
+    set scrollable(v: boolean) { _C(this, 12644, v); }
+
+    /**
+     * Number of ticks displayed on the slider, including border ticks. Ticks are uniformly-distributed value markers.
+     */
+    get tickCount(): number { return _C(this, 6778) as number; }
+    set tickCount(v: number) { _C(this, 13062, v); }
+
+    /**
+     * If `true`, the slider will display ticks for minimum and maximum values.
+     */
+    get ticksOnBorders(): boolean { return _C(this, 6780) as boolean; }
+    set ticksOnBorders(v: boolean) { _C(this, 13063, v); }
+
+    /**
+     * Sets the position of the ticks. See {@link TickPosition} for details.
+     */
+    get ticksPosition(): TickPosition { return _C(this, 6781) as TickPosition; }
+    set ticksPosition(v: TickPosition) { _C(this, 13064, v); }
+
+    /**
+     * Emitted when the grabber starts being dragged. This is emitted before the corresponding {@link Range.value_changed} signal.
+     */
+    get dragStarted(): Signal<() => void> { return _G(this, 2893) as Signal<() => void>; }
+    set dragStarted(v: (() => void) | null) { _G(this, 2893, v); }
+
+    /**
+     * Emitted when the grabber stops being dragged. If `valueChanged` is `true`, {@link Range.value} is different from the value when the dragging was started.
+     */
+    get dragEnded(): Signal<(valueChanged: boolean) => void> { return _G(this, 2886) as Signal<(valueChanged: boolean) => void>; }
+    set dragEnded(v: ((valueChanged: boolean) => void) | null) { _G(this, 2886, v); }
+
+    static readonly name = _R(719, Slider);
+}
+
+export const TickPosition = {
+    /**
+     * Places the ticks at the bottom of the {@link HSlider}, or right of the {@link VSlider}.
+     */
+    TICK_POSITION_BOTTOM_RIGHT: 0,
+    /**
+     * Places the ticks at the top of the {@link HSlider}, or left of the {@link VSlider}.
+     */
+    TICK_POSITION_TOP_LEFT: 1,
+    /**
+     * Places the ticks at the both sides of the slider.
+     */
+    TICK_POSITION_BOTH: 2,
+    /**
+     * Places the ticks at the center of the slider.
+     */
+    TICK_POSITION_CENTER: 3,
+} as const;
+
+export type TickPosition = (typeof TickPosition)[keyof typeof TickPosition];
+

package/gen/classes/SliderJoint3D.ts

@@ -0,0 +1,122 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Joint3D } from './Joint3D.ts';
+
+/**
+ * A physics joint that restricts the movement of a 3D physics body along an axis relative to another physics body. For example, Body A could be a {@link StaticBody3D} representing a piston base, while Body B could be a {@link RigidBody3D} representing the piston head, moving up and down.
+ */
+export class SliderJoint3D extends Joint3D {
+    constructor(name = 720) { super(name); }
+
+    /**
+     * Assigns `value` to the given parameter.
+     */
+    setParam(param: Param, value: number): void { _C(this, 12248, param, value); }
+
+    /**
+     * Returns the value of the given parameter.
+     */
+    getParam(param: Param): number { return _C(this, 5809, param) as number; }
+
+    static readonly name = _R(720, SliderJoint3D);
+}
+
+export const Param = {
+    /**
+     * Constant for accessing {@link linearLimit/upperDistance}. The maximum difference between the pivot points on their X axis before damping happens.
+     */
+    PARAM_LINEAR_LIMIT_UPPER: 0,
+    /**
+     * Constant for accessing {@link linearLimit/lowerDistance}. The minimum difference between the pivot points on their X axis before damping happens.
+     */
+    PARAM_LINEAR_LIMIT_LOWER: 1,
+    /**
+     * Constant for accessing {@link linearLimit/softness}. A factor applied to the movement across the slider axis once the limits get surpassed. The lower, the slower the movement.
+     */
+    PARAM_LINEAR_LIMIT_SOFTNESS: 2,
+    /**
+     * Constant for accessing {@link linearLimit/restitution}. The amount of restitution once the limits are surpassed. The lower, the more velocity-energy gets lost.
+     */
+    PARAM_LINEAR_LIMIT_RESTITUTION: 3,
+    /**
+     * Constant for accessing {@link linearLimit/damping}. The amount of damping once the slider limits are surpassed.
+     */
+    PARAM_LINEAR_LIMIT_DAMPING: 4,
+    /**
+     * Constant for accessing {@link linearMotion/softness}. A factor applied to the movement across the slider axis as long as the slider is in the limits. The lower, the slower the movement.
+     */
+    PARAM_LINEAR_MOTION_SOFTNESS: 5,
+    /**
+     * Constant for accessing {@link linearMotion/restitution}. The amount of restitution inside the slider limits.
+     */
+    PARAM_LINEAR_MOTION_RESTITUTION: 6,
+    /**
+     * Constant for accessing {@link linearMotion/damping}. The amount of damping inside the slider limits.
+     */
+    PARAM_LINEAR_MOTION_DAMPING: 7,
+    /**
+     * Constant for accessing {@link linearOrtho/softness}. A factor applied to the movement across axes orthogonal to the slider.
+     */
+    PARAM_LINEAR_ORTHOGONAL_SOFTNESS: 8,
+    /**
+     * Constant for accessing {@link linearMotion/restitution}. The amount of restitution when movement is across axes orthogonal to the slider.
+     */
+    PARAM_LINEAR_ORTHOGONAL_RESTITUTION: 9,
+    /**
+     * Constant for accessing {@link linearMotion/damping}. The amount of damping when movement is across axes orthogonal to the slider.
+     */
+    PARAM_LINEAR_ORTHOGONAL_DAMPING: 10,
+    /**
+     * Constant for accessing {@link angularLimit/upperAngle}. The upper limit of rotation in the slider.
+     */
+    PARAM_ANGULAR_LIMIT_UPPER: 11,
+    /**
+     * Constant for accessing {@link angularLimit/lowerAngle}. The lower limit of rotation in the slider.
+     */
+    PARAM_ANGULAR_LIMIT_LOWER: 12,
+    /**
+     * Constant for accessing {@link angularLimit/softness}. A factor applied to the all rotation once the limit is surpassed.
+     */
+    PARAM_ANGULAR_LIMIT_SOFTNESS: 13,
+    /**
+     * Constant for accessing {@link angularLimit/restitution}. The amount of restitution of the rotation when the limit is surpassed.
+     */
+    PARAM_ANGULAR_LIMIT_RESTITUTION: 14,
+    /**
+     * Constant for accessing {@link angularLimit/damping}. The amount of damping of the rotation when the limit is surpassed.
+     */
+    PARAM_ANGULAR_LIMIT_DAMPING: 15,
+    /**
+     * Constant for accessing {@link angularMotion/softness}. A factor applied to the all rotation in the limits.
+     */
+    PARAM_ANGULAR_MOTION_SOFTNESS: 16,
+    /**
+     * Constant for accessing {@link angularMotion/restitution}. The amount of restitution of the rotation in the limits.
+     */
+    PARAM_ANGULAR_MOTION_RESTITUTION: 17,
+    /**
+     * Constant for accessing {@link angularMotion/damping}. The amount of damping of the rotation in the limits.
+     */
+    PARAM_ANGULAR_MOTION_DAMPING: 18,
+    /**
+     * Constant for accessing {@link angularOrtho/softness}. A factor applied to the all rotation across axes orthogonal to the slider.
+     */
+    PARAM_ANGULAR_ORTHOGONAL_SOFTNESS: 19,
+    /**
+     * Constant for accessing {@link angularOrtho/restitution}. The amount of restitution of the rotation across axes orthogonal to the slider.
+     */
+    PARAM_ANGULAR_ORTHOGONAL_RESTITUTION: 20,
+    /**
+     * Constant for accessing {@link angularOrtho/damping}. The amount of damping of the rotation across axes orthogonal to the slider.
+     */
+    PARAM_ANGULAR_ORTHOGONAL_DAMPING: 21,
+    /**
+     * Represents the size of the {@link Param} enum.
+     */
+    PARAM_MAX: 22,
+} as const;
+
+export type Param = (typeof Param)[keyof typeof Param];
+

package/gen/classes/SocketServer.ts

@@ -0,0 +1,34 @@
+// 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 { StreamPeerSocket } from './StreamPeerSocket.ts';
+
+/**
+ * A socket server.
+ */
+export class SocketServer extends RefCounted {
+
+    /**
+     * Returns `true` if a connection is available for taking.
+     */
+    isConnectionAvailable(): boolean { return _C(this, 7857) as boolean; }
+
+    /**
+     * Returns `true` if the server is currently listening for connections.
+     */
+    isListening(): boolean { return _C(this, 8086) as boolean; }
+
+    /**
+     * Stops listening.
+     */
+    stop(): void { _C(this, 13866); }
+
+    /**
+     * If a connection is available, returns a StreamPeerSocket with the connection.
+     */
+    takeSocketConnection(): StreamPeerSocket { return _C(this, 14116) as StreamPeerSocket; }
+
+    static readonly name = _R(721, SocketServer);
+}

package/gen/classes/SoftBody3D.ts

@@ -0,0 +1,188 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { MeshInstance3D } from './MeshInstance3D.ts';
+import type { GodotArray, NodePath, RID } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { Node } from './Node.ts';
+import type { PhysicsBody3D } from './PhysicsBody3D.ts';
+
+/**
+ * A deformable 3D physics mesh. Used to create elastic or deformable objects such as cloth, rubber, or other flexible materials.
+ * Additionally, {@link SoftBody3D} is subject to wind forces defined in {@link Area3D} (see {@link Area3D.windSourcePath}, {@link Area3D.windForceMagnitude}, and {@link Area3D.windAttenuationFactor}).
+ * **Note:** It's recommended to use Jolt Physics when using {@link SoftBody3D} instead of the default GodotPhysics3D, as Jolt Physics' soft body implementation is faster and more reliable. You can switch the physics engine using the {@link ProjectSettings.physics/3d/physicsEngine} project setting.
+ */
+export class SoftBody3D extends MeshInstance3D {
+    constructor(name = 722) { super(name); }
+
+    /**
+     * Returns the internal {@link RID} used by the {@link PhysicsServer3D} for this body.
+     */
+    getPhysicsRid(): RID { return _C(this, 5904) as RID; }
+
+    /**
+     * 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 an array of nodes that were added as collision exceptions for this body.
+     */
+    getCollisionExceptions(): GodotArray<PhysicsBody3D> { return _C(this, 4199) as GodotArray<PhysicsBody3D>; }
+
+    /**
+     * Adds a body to the list of bodies that this body can't collide with.
+     */
+    addCollisionExceptionWith(body: Node): void { _C(this, 1198, body); }
+
+    /**
+     * Removes a body from the list of bodies that this body can't collide with.
+     */
+    removeCollisionExceptionWith(body: Node): void { _C(this, 9899, body); }
+
+    /**
+     * Returns local translation of a vertex in the surface array.
+     */
+    getPointTransform(pointIndex: number): Vector3 { return _C(this, 5956, pointIndex) as Vector3; }
+
+    /**
+     * Applies an impulse to a point.
+     * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+     */
+    applyImpulse(pointIndex: number, impulse: Vector3): void { _C(this, 1533, pointIndex, impulse); }
+
+    /**
+     * Applies a force to a point. A force is time dependent and meant to be applied every physics update.
+     */
+    applyForce(pointIndex: number, force: Vector3): void { _C(this, 1531, pointIndex, force); }
+
+    /**
+     * Distributes and applies an impulse to all points.
+     * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+     */
+    applyCentralImpulse(impulse: Vector3): void { _C(this, 1529, impulse); }
+
+    /**
+     * Distributes and applies a force to all points. A force is time dependent and meant to be applied every physics update.
+     */
+    applyCentralForce(force: Vector3): void { _C(this, 1528, force); }
+
+    /**
+     * Sets the pinned state of a surface vertex. When set to `true`, the optional `attachmentPath` can define a {@link Node3D} the pinned vertex will be attached to.
+     */
+    setPointPinned(pointIndex: number, pinned: boolean, attachmentPath?: NodePath /* = NodePath("") */, insertAt?: number /* = -1 */): void { _C(this, 12360, pointIndex, pinned, attachmentPath, insertAt); }
+
+    /**
+     * Returns `true` if vertex is set to pinned.
+     */
+    isPointPinned(pointIndex: number): boolean { return _C(this, 8189, pointIndex) as boolean; }
+
+    /**
+     * The physics layers this SoftBody3D **is in**. Collision objects can exist in one or more of 32 different layers. See also {@link collisionMask}.
+     * **Note:** Object A can detect a contact with object B only if object B is in any of the layers that object A scans. 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 SoftBody3D **scans**. Collision objects can scan one or more of 32 different layers. See also {@link collisionLayer}.
+     * **Note:** Object A can detect a contact with object B only if object B is in any of the layers that object A scans. 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); }
+
+    /**
+     * {@link NodePath} to a {@link CollisionObject3D} this SoftBody3D should avoid clipping.
+     */
+    get parentCollisionIgnore(): NodePath { return _C(this, 5822) as NodePath; }
+    set parentCollisionIgnore(v: NodePath) { _C(this, 12259, v); }
+
+    /**
+     * Increasing this value will improve the resulting simulation, but can affect performance. Use with care.
+     */
+    get simulationPrecision(): number { return _C(this, 6396) as number; }
+    set simulationPrecision(v: number) { _C(this, 12751, v); }
+
+    /**
+     * The SoftBody3D's mass.
+     */
+    get totalMass(): number { return _C(this, 6855) as number; }
+    set totalMass(v: number) { _C(this, 13118, v); }
+
+    /**
+     * Higher values will result in a stiffer body, while lower values will increase the body's ability to bend. The value can be between `0.0` and `1.0` (inclusive).
+     */
+    get linearStiffness(): number { return _C(this, 5385) as number; }
+    set linearStiffness(v: number) { _C(this, 11934, v); }
+
+    /**
+     * Scales the rest lengths of {@link SoftBody3D}'s edge constraints. Positive values shrink the mesh, while negative values expand it. For example, a value of `0.1` shortens the edges of the mesh by 10%, while `-0.1` expands the edges by 10%.
+     * **Note:** {@link shrinkingFactor} is best used on surface meshes with pinned points.
+     */
+    get shrinkingFactor(): number { return _C(this, 6385) as number; }
+    set shrinkingFactor(v: number) { _C(this, 12743, v); }
+
+    /**
+     * The pressure coefficient of this soft body. Simulate pressure build-up from inside this body. Higher values increase the strength of this effect.
+     */
+    get pressureCoefficient(): number { return _C(this, 5997) as number; }
+    set pressureCoefficient(v: number) { _C(this, 12407, v); }
+
+    /**
+     * The body's damping coefficient. Higher values will slow down the body more noticeably when forces are applied.
+     */
+    get dampingCoefficient(): number { return _C(this, 4406) as number; }
+    set dampingCoefficient(v: number) { _C(this, 11030, v); }
+
+    /**
+     * The body's drag coefficient. Higher values increase this body's air resistance.
+     * **Note:** This value is currently unused by Godot's default physics implementation.
+     */
+    get dragCoefficient(): number { return _C(this, 4556) as number; }
+    set dragCoefficient(v: number) { _C(this, 11166, v); }
+
+    /**
+     * If `true`, the {@link SoftBody3D} will respond to {@link RayCast3D}s.
+     */
+    get rayPickable(): boolean { return _C(this, 8226) as boolean; }
+    set rayPickable(v: boolean) { _C(this, 12479, v); }
+
+    /**
+     * Defines the behavior in physics when {@link Node.processMode} is set to {@link Node.PROCESS_MODE_DISABLED}.
+     */
+    get disableMode(): DisableMode { return _C(this, 4511) as DisableMode; }
+    set disableMode(v: DisableMode) { _C(this, 11119, v); }
+
+    static readonly name = _R(722, SoftBody3D);
+}
+
+export const DisableMode = {
+    /**
+     * When {@link Node.processMode} is set to {@link Node.PROCESS_MODE_DISABLED}, remove from the physics simulation to stop all physics interactions with this {@link SoftBody3D}.
+     * Automatically re-added to the physics simulation when the {@link Node} is processed again.
+     */
+    DISABLE_MODE_REMOVE: 0,
+    /**
+     * When {@link Node.processMode} is set to {@link Node.PROCESS_MODE_DISABLED}, do not affect the physics simulation.
+     */
+    DISABLE_MODE_KEEP_ACTIVE: 1,
+} as const;
+
+export type DisableMode = (typeof DisableMode)[keyof typeof DisableMode];
+

package/gen/classes/SphereMesh.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';
+
+/**
+ * Class representing a spherical {@link PrimitiveMesh}.
+ */
+export class SphereMesh extends PrimitiveMesh {
+    constructor(name = 723) { super(name); }
+
+    /**
+     * Radius of sphere.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * Full height of the sphere.
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, v); }
+
+    /**
+     * Number of radial segments on the sphere.
+     */
+    get radialSegments(): number { return _C(this, 6065) as number; }
+    set radialSegments(v: number) { _C(this, 12464, v); }
+
+    /**
+     * Number of segments along the height of the sphere.
+     */
+    get rings(): number { return _C(this, 6185) as number; }
+    set rings(v: number) { _C(this, 12562, v); }
+
+    /**
+     * If `true`, a hemisphere is created rather than a full sphere.
+     * **Note:** To get a regular hemisphere, the height and radius of the sphere must be equal.
+     */
+    get isHemisphere(): boolean { return _C(this, 5171) as boolean; }
+    set isHemisphere(v: boolean) { _C(this, 11753, v); }
+
+    static readonly name = _R(723, SphereMesh);
+}

package/gen/classes/SphereOccluder3D.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Occluder3D } from './Occluder3D.ts';
+
+/**
+ * {@link SphereOccluder3D} stores a sphere shape that can be used by the engine's occlusion culling system.
+ * See {@link OccluderInstance3D}'s documentation for instructions on setting up occlusion culling.
+ */
+export class SphereOccluder3D extends Occluder3D {
+    constructor(name = 724) { super(name); }
+
+    /**
+     * The sphere's radius in 3D units.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    static readonly name = _R(724, SphereOccluder3D);
+}

package/gen/classes/SphereShape3D.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Shape3D } from './Shape3D.ts';
+
+/**
+ * A 3D sphere shape, intended for use in physics. Usually used to provide a shape for a {@link CollisionShape3D}.
+ * **Performance:** {@link SphereShape3D} is fast to check collisions against. It is faster than {@link BoxShape3D}, {@link CapsuleShape3D}, and {@link CylinderShape3D}.
+ */
+export class SphereShape3D extends Shape3D {
+    constructor(name = 725) { super(name); }
+
+    /**
+     * The sphere's radius. The shape's diameter is double the radius.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    static readonly name = _R(725, SphereShape3D);
+}