@ringozz/godot 0.1.0

package/gen/classes/CodeHighlighter.ts

@@ -0,0 +1,132 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SyntaxHighlighter } from './SyntaxHighlighter.ts';
+import type { GodotDictionary } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+
+/**
+ * By adjusting various properties of this resource, you can change the colors of strings, comments, numbers, and other text patterns inside a {@link TextEdit} control.
+ */
+export class CodeHighlighter extends SyntaxHighlighter {
+    constructor(name = 201) { super(name); }
+
+    /**
+     * Sets the color for a keyword.
+     * The keyword cannot contain any symbols except '_'.
+     */
+    addKeywordColor(keyword: string, color: Color): void { _C(this, 1243, keyword, color); }
+
+    /**
+     * Removes the keyword.
+     */
+    removeKeywordColor(keyword: string): void { _C(this, 9927, keyword); }
+
+    /**
+     * Returns `true` if the keyword exists, else `false`.
+     */
+    hasKeywordColor(keyword: string): boolean { return _C(this, 7411, keyword) as boolean; }
+
+    /**
+     * Returns the color for a keyword.
+     */
+    getKeywordColor(keyword: string): Color { return _C(this, 5295, keyword) as Color; }
+
+    /**
+     * Removes all keywords.
+     */
+    clearKeywordColors(): void { _C(this, 2279); }
+
+    /**
+     * Sets the color for a member keyword.
+     * The member keyword cannot contain any symbols except '_'.
+     * It will not be highlighted if preceded by a '.'.
+     */
+    addMemberKeywordColor(memberKeyword: string, color: Color): void { _C(this, 1247, memberKeyword, color); }
+
+    /**
+     * Removes the member keyword.
+     */
+    removeMemberKeywordColor(memberKeyword: string): void { _C(this, 9933, memberKeyword); }
+
+    /**
+     * Returns `true` if the member keyword exists, else `false`.
+     */
+    hasMemberKeywordColor(memberKeyword: string): boolean { return _C(this, 7414, memberKeyword) as boolean; }
+
+    /**
+     * Returns the color for a member keyword.
+     */
+    getMemberKeywordColor(memberKeyword: string): Color { return _C(this, 5497, memberKeyword) as Color; }
+
+    /**
+     * Removes all member keywords.
+     */
+    clearMemberKeywordColors(): void { _C(this, 2282); }
+
+    /**
+     * Adds a color region (such as for comments or strings) from `startKey` to `endKey`. Both keys should be symbols, and `startKey` must not be shared with other delimiters.
+     * If `lineOnly` is `true` or `endKey` is an empty {@link String}, the region does not carry over to the next line.
+     */
+    addColorRegion(startKey: string, endKey: string, color: Color, lineOnly?: boolean /* = false */): void { _C(this, 1200, startKey, endKey, color, lineOnly); }
+
+    /**
+     * Removes the color region that uses that start key.
+     */
+    removeColorRegion(startKey: string): void { _C(this, 9901, startKey); }
+
+    /**
+     * Returns `true` if the start key exists, else `false`.
+     */
+    hasColorRegion(startKey: string): boolean { return _C(this, 7377, startKey) as boolean; }
+
+    /**
+     * Removes all color regions.
+     */
+    clearColorRegions(): void { _C(this, 2251); }
+
+    /**
+     * Sets the color for numbers.
+     */
+    get numberColor(): Color { return _C(this, 5682) as Color; }
+    set numberColor(v: Color) { _C(this, 12155, v); }
+
+    /**
+     * Sets the color for symbols.
+     */
+    get symbolColor(): Color { return _C(this, 6650) as Color; }
+    set symbolColor(v: Color) { _C(this, 12954, v); }
+
+    /**
+     * Sets color for functions. A function is a non-keyword string followed by a '('.
+     */
+    get functionColor(): Color { return _C(this, 4912) as Color; }
+    set functionColor(v: Color) { _C(this, 11505, v); }
+
+    /**
+     * Sets color for member variables. A member variable is non-keyword, non-function string proceeded with a '.'.
+     */
+    get memberVariableColor(): Color { return _C(this, 5499) as Color; }
+    set memberVariableColor(v: Color) { _C(this, 12018, v); }
+
+    /**
+     * Sets the keyword colors. All existing keywords will be removed. The {@link Dictionary} key is the keyword. The value is the keyword color.
+     */
+    get keywordColors(): GodotDictionary { return _C(this, 5296) as GodotDictionary; }
+    set keywordColors(v: GodotDictionary) { _C(this, 11869, v); }
+
+    /**
+     * Sets the member keyword colors. All existing member keyword will be removed. The {@link Dictionary} key is the member keyword. The value is the member keyword color.
+     */
+    get memberKeywordColors(): GodotDictionary { return _C(this, 5498) as GodotDictionary; }
+    set memberKeywordColors(v: GodotDictionary) { _C(this, 12017, v); }
+
+    /**
+     * Sets the color regions. All existing regions will be removed. The {@link Dictionary} key is the region start and end key, separated by a space. The value is the region color.
+     */
+    get colorRegions(): GodotDictionary { return _C(this, 4229) as GodotDictionary; }
+    set colorRegions(v: GodotDictionary) { _C(this, 10913, v); }
+
+    static readonly name = _R(201, CodeHighlighter);
+}

package/gen/classes/CollisionObject2D.ts

@@ -0,0 +1,235 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { PackedInt32Array, RID, Signal } from '../heap-types/index.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+import type { InputEvent } from './InputEvent.ts';
+import type { Node } from './Node.ts';
+import type { Object } from './Object.ts';
+import type { Shape2D } from './Shape2D.ts';
+import type { Viewport } from './Viewport.ts';
+
+/**
+ * Abstract base class for 2D physics objects. {@link CollisionObject2D} can hold any number of {@link Shape2D}s for collision. Each shape must be assigned to a *shape owner*. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the `shape_owner_*` methods.
+ * **Note:** Only collisions between objects within the same canvas ({@link Viewport} canvas or {@link CanvasLayer}) are supported. The behavior of collisions between objects in different canvases is undefined.
+ */
+export class CollisionObject2D extends Node2D {
+
+    /**
+     * Returns the object's {@link RID}.
+     */
+    getRid(): RID { return _C(this, 6177) as RID; }
+
+    /**
+     * 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; }
+
+    /**
+     * 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; }
+
+    /**
+     * Creates a new shape owner for the given object. Returns `owner_id` of the new owner for future reference.
+     */
+    createShapeOwner(owner: Object): number { return _C(this, 2569, owner) as number; }
+
+    /**
+     * Removes the given shape owner.
+     */
+    removeShapeOwner(ownerId: number /* uint32 */): void { _C(this, 9956, ownerId); }
+
+    /**
+     * Returns an {@link Array} of `owner_id` identifiers. You can use these ids in other methods that take `owner_id` as an argument.
+     */
+    getShapeOwners(): PackedInt32Array { return _C(this, 6373) as PackedInt32Array; }
+
+    /**
+     * Sets the {@link Transform2D} of the given shape owner.
+     */
+    shapeOwnerSetTransform(ownerId: number /* uint32 */, transform: Transform2D): void { _C(this, 13474, ownerId, transform); }
+
+    /**
+     * Returns the shape owner's {@link Transform2D}.
+     */
+    shapeOwnerGetTransform(ownerId: number /* uint32 */): Transform2D { return _C(this, 13468, ownerId) as Transform2D; }
+
+    /**
+     * Returns the parent object of the given shape owner.
+     */
+    shapeOwnerGetOwner(ownerId: number /* uint32 */): Object { return _C(this, 13464, ownerId) as Object; }
+
+    /**
+     * If `true`, disables the given shape owner.
+     */
+    shapeOwnerSetDisabled(ownerId: number /* uint32 */, disabled: boolean): void { _C(this, 13470, ownerId, disabled); }
+
+    /**
+     * If `true`, the shape owner and its shapes are disabled.
+     */
+    isShapeOwnerDisabled(ownerId: number /* uint32 */): boolean { return _C(this, 8299, ownerId) as boolean; }
+
+    /**
+     * If `enable` is `true`, collisions for the shape owner originating from this {@link CollisionObject2D} will not be reported to collided with {@link CollisionObject2D}s.
+     */
+    shapeOwnerSetOneWayCollision(ownerId: number /* uint32 */, enable: boolean): void { _C(this, 13471, ownerId, enable); }
+
+    /**
+     * Returns `true` if collisions for the shape owner originating from this {@link CollisionObject2D} will not be reported to collided with {@link CollisionObject2D}s.
+     */
+    isShapeOwnerOneWayCollisionEnabled(ownerId: number /* uint32 */): boolean { return _C(this, 8300, ownerId) as boolean; }
+
+    /**
+     * Sets the `one_way_collision_margin` of the shape owner identified by given `ownerId` to `margin` pixels.
+     */
+    shapeOwnerSetOneWayCollisionMargin(ownerId: number /* uint32 */, margin: number): void { _C(this, 13473, ownerId, margin); }
+
+    /**
+     * Returns the `one_way_collision_margin` of the shape owner identified by given `ownerId`.
+     */
+    getShapeOwnerOneWayCollisionMargin(ownerId: number /* uint32 */): number { return _C(this, 6372, ownerId) as number; }
+
+    /**
+     * Returns the `one_way_collision_direction` of the shape owner identified by the given `ownerId`.
+     */
+    getShapeOwnerOneWayCollisionDirection(ownerId: number /* uint32 */): Vector2 { return _C(this, 6371, ownerId) as Vector2; }
+
+    /**
+     * Sets the `one_way_collision_direction` of the shape owner identified by the given `ownerId` to `direction`.
+     */
+    shapeOwnerSetOneWayCollisionDirection(ownerId: number /* uint32 */, direction: Vector2): void { _C(this, 13472, ownerId, direction); }
+
+    /**
+     * Adds a {@link Shape2D} to the shape owner.
+     */
+    shapeOwnerAddShape(ownerId: number /* uint32 */, shape: Shape2D): void { _C(this, 13462, ownerId, shape); }
+
+    /**
+     * Returns the number of shapes the given shape owner contains.
+     */
+    shapeOwnerGetShapeCount(ownerId: number /* uint32 */): number { return _C(this, 13466, ownerId) as number; }
+
+    /**
+     * Returns the {@link Shape2D} with the given ID from the given shape owner.
+     */
+    shapeOwnerGetShape(ownerId: number /* uint32 */, shapeId: number): Shape2D { return _C(this, 13465, ownerId, shapeId) as Shape2D; }
+
+    /**
+     * Returns the child index of the {@link Shape2D} with the given ID from the given shape owner.
+     */
+    shapeOwnerGetShapeIndex(ownerId: number /* uint32 */, shapeId: number): number { return _C(this, 13467, ownerId, shapeId) as number; }
+
+    /**
+     * Removes a shape from the given shape owner.
+     */
+    shapeOwnerRemoveShape(ownerId: number /* uint32 */, shapeId: number): void { _C(this, 13469, ownerId, shapeId); }
+
+    /**
+     * Removes all shapes from the shape owner.
+     */
+    shapeOwnerClearShapes(ownerId: number /* uint32 */): void { _C(this, 13463, ownerId); }
+
+    /**
+     * Returns the `owner_id` of the given shape.
+     */
+    shapeFindOwner(shapeIndex: number): number { return _C(this, 13458, shapeIndex) as number; }
+
+    /**
+     * 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); }
+
+    /**
+     * The physics layers this CollisionObject2D 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 CollisionObject2D 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); }
+
+    /**
+     * The priority used to solve colliding when occurring penetration. 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); }
+
+    /**
+     * If `true`, this object is pickable. A pickable object can detect the mouse pointer entering/leaving, and if the mouse is inside it, report input events. Requires at least one {@link collisionLayer} bit to be set.
+     */
+    get inputPickable(): boolean { return _C(this, 8181) as boolean; }
+    set inputPickable(v: boolean) { _C(this, 12327, v); }
+
+    /**
+     * Emitted when an input event occurs. Requires {@link inputPickable} to be `true` and at least one {@link collisionLayer} bit to be set. See {@link _inputEvent} for details.
+     */
+    get inputEvent(): Signal<(viewport: Node, event: InputEvent, shapeIdx: number) => void> { return _G(this, 7623) as Signal<(viewport: Node, event: InputEvent, shapeIdx: number) => void>; }
+    set inputEvent(v: ((viewport: Node, event: InputEvent, shapeIdx: number) => void) | null) { _G(this, 7623, v); }
+
+    /**
+     * Emitted when the mouse pointer enters any of this object's shapes. Requires {@link inputPickable} to be `true` and at least one {@link collisionLayer} bit to be set. Note that moving between different shapes within a single {@link CollisionObject2D} won't cause this signal to be emitted.
+     * **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the {@link CollisionObject2D}'s area is small. This signal may also not be emitted if another {@link CollisionObject2D} is overlapping the {@link CollisionObject2D} in question.
+     */
+    get mouseEntered(): Signal<() => void> { return _G(this, 8963) as Signal<() => void>; }
+    set mouseEntered(v: (() => void) | null) { _G(this, 8963, v); }
+
+    /**
+     * Emitted when the mouse pointer exits all this object's shapes. Requires {@link inputPickable} to be `true` and at least one {@link collisionLayer} bit to be set. Note that moving between different shapes within a single {@link CollisionObject2D} won't cause this signal to be emitted.
+     * **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the {@link CollisionObject2D}'s area is small. This signal may also not be emitted if another {@link CollisionObject2D} is overlapping the {@link CollisionObject2D} in question.
+     */
+    get mouseExited(): Signal<() => void> { return _G(this, 8964) as Signal<() => void>; }
+    set mouseExited(v: (() => void) | null) { _G(this, 8964, v); }
+
+    /**
+     * Emitted when the mouse pointer enters any of this object's shapes or moves from one shape to another. `shapeIdx` is the child index of the newly entered {@link Shape2D}. Requires {@link inputPickable} to be `true` and at least one {@link collisionLayer} bit to be set.
+     */
+    get mouseShapeEntered(): Signal<(shapeIdx: number) => void> { return _G(this, 8974) as Signal<(shapeIdx: number) => void>; }
+    set mouseShapeEntered(v: ((shapeIdx: number) => void) | null) { _G(this, 8974, v); }
+
+    /**
+     * Emitted when the mouse pointer exits any of this object's shapes. `shapeIdx` is the child index of the exited {@link Shape2D}. Requires {@link inputPickable} to be `true` and at least one {@link collisionLayer} bit to be set.
+     */
+    get mouseShapeExited(): Signal<(shapeIdx: number) => void> { return _G(this, 8975) as Signal<(shapeIdx: number) => void>; }
+    set mouseShapeExited(v: ((shapeIdx: number) => void) | null) { _G(this, 8975, v); }
+
+    static readonly name = _R(202, CollisionObject2D);
+}
+
+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 CollisionObject2D}.
+     * 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}, make the body static. Doesn't affect {@link Area2D}. {@link PhysicsBody2D} can't be affected by forces or other bodies while static.
+     * Automatically set {@link PhysicsBody2D} back to its original mode when the {@link Node} is processed again.
+     */
+    DISABLE_MODE_MAKE_STATIC: 1,
+    /**
+     * When {@link Node.processMode} is set to {@link Node.PROCESS_MODE_DISABLED}, do not affect the physics simulation.
+     */
+    DISABLE_MODE_KEEP_ACTIVE: 2,
+} as const;
+
+export type DisableMode = (typeof DisableMode)[keyof typeof DisableMode];
+

package/gen/classes/CollisionObject3D.ts

@@ -0,0 +1,199 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { PackedInt32Array, RID, Signal } from '../heap-types/index.ts';
+import type { Transform3D, Vector3 } from '../value-types/index.ts';
+import type { Camera3D } from './Camera3D.ts';
+import type { InputEvent } from './InputEvent.ts';
+import type { Node } from './Node.ts';
+import type { Object } from './Object.ts';
+import type { Shape3D } from './Shape3D.ts';
+
+/**
+ * Abstract base class for 3D physics objects. {@link CollisionObject3D} can hold any number of {@link Shape3D}s for collision. Each shape must be assigned to a *shape owner*. Shape owners are not nodes and do not appear in the editor, but are accessible through code using the `shape_owner_*` methods.
+ * **Warning:** With a non-uniform scale, this node will likely not behave as expected. It is advised to keep its scale the same on all axes and adjust its collision shape(s) instead.
+ */
+export class CollisionObject3D extends Node3D {
+
+    /**
+     * 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; }
+
+    /**
+     * 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; }
+
+    /**
+     * Returns the object's {@link RID}.
+     */
+    getRid(): RID { return _C(this, 6177) as RID; }
+
+    /**
+     * Creates a new shape owner for the given object. Returns `owner_id` of the new owner for future reference.
+     */
+    createShapeOwner(owner: Object): number { return _C(this, 2569, owner) as number; }
+
+    /**
+     * Removes the given shape owner.
+     */
+    removeShapeOwner(ownerId: number /* uint32 */): void { _C(this, 9956, ownerId); }
+
+    /**
+     * Returns an {@link Array} of `owner_id` identifiers. You can use these ids in other methods that take `owner_id` as an argument.
+     */
+    getShapeOwners(): PackedInt32Array { return _C(this, 6373) as PackedInt32Array; }
+
+    /**
+     * Sets the {@link Transform3D} of the given shape owner.
+     */
+    shapeOwnerSetTransform(ownerId: number /* uint32 */, transform: Transform3D): void { _C(this, 13474, ownerId, transform); }
+
+    /**
+     * Returns the shape owner's {@link Transform3D}.
+     */
+    shapeOwnerGetTransform(ownerId: number /* uint32 */): Transform3D { return _C(this, 13468, ownerId) as Transform3D; }
+
+    /**
+     * Returns the parent object of the given shape owner.
+     */
+    shapeOwnerGetOwner(ownerId: number /* uint32 */): Object { return _C(this, 13464, ownerId) as Object; }
+
+    /**
+     * If `true`, disables the given shape owner.
+     */
+    shapeOwnerSetDisabled(ownerId: number /* uint32 */, disabled: boolean): void { _C(this, 13470, ownerId, disabled); }
+
+    /**
+     * If `true`, the shape owner and its shapes are disabled.
+     */
+    isShapeOwnerDisabled(ownerId: number /* uint32 */): boolean { return _C(this, 8299, ownerId) as boolean; }
+
+    /**
+     * Adds a {@link Shape3D} to the shape owner.
+     */
+    shapeOwnerAddShape(ownerId: number /* uint32 */, shape: Shape3D): void { _C(this, 13462, ownerId, shape); }
+
+    /**
+     * Returns the number of shapes the given shape owner contains.
+     */
+    shapeOwnerGetShapeCount(ownerId: number /* uint32 */): number { return _C(this, 13466, ownerId) as number; }
+
+    /**
+     * Returns the {@link Shape3D} with the given ID from the given shape owner.
+     */
+    shapeOwnerGetShape(ownerId: number /* uint32 */, shapeId: number): Shape3D { return _C(this, 13465, ownerId, shapeId) as Shape3D; }
+
+    /**
+     * Returns the child index of the {@link Shape3D} with the given ID from the given shape owner.
+     */
+    shapeOwnerGetShapeIndex(ownerId: number /* uint32 */, shapeId: number): number { return _C(this, 13467, ownerId, shapeId) as number; }
+
+    /**
+     * Removes a shape from the given shape owner.
+     */
+    shapeOwnerRemoveShape(ownerId: number /* uint32 */, shapeId: number): void { _C(this, 13469, ownerId, shapeId); }
+
+    /**
+     * Removes all shapes from the shape owner.
+     */
+    shapeOwnerClearShapes(ownerId: number /* uint32 */): void { _C(this, 13463, ownerId); }
+
+    /**
+     * Returns the `owner_id` of the given shape.
+     */
+    shapeFindOwner(shapeIndex: number): number { return _C(this, 13458, shapeIndex) as number; }
+
+    /**
+     * 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); }
+
+    /**
+     * The physics layers this CollisionObject3D **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 CollisionObject3D **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); }
+
+    /**
+     * The priority used to solve colliding when occurring penetration. 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); }
+
+    /**
+     * If `true`, this object is pickable. A pickable object can detect the mouse pointer entering/leaving, and if the mouse is inside it, report input events. Requires at least one {@link collisionLayer} bit to be set.
+     */
+    get inputRayPickable(): boolean { return _C(this, 8226) as boolean; }
+    set inputRayPickable(v: boolean) { _C(this, 12479, v); }
+
+    /**
+     * If `true`, the {@link CollisionObject3D} will continue to receive input events as the mouse is dragged across its shapes.
+     */
+    get inputCaptureOnDrag(): boolean { return _C(this, 4081) as boolean; }
+    set inputCaptureOnDrag(v: boolean) { _C(this, 10801, v); }
+
+    /**
+     * Emitted when the object receives an unhandled {@link InputEvent}. `eventPosition` is the location in world space of the mouse pointer on the surface of the shape with index `shapeIdx` and `normal` is the normal vector of the surface at that point.
+     */
+    get inputEvent(): Signal<(camera: Node, event: InputEvent, eventPosition: Vector3, normal: Vector3, shapeIdx: number) => void> { return _G(this, 7623) as Signal<(camera: Node, event: InputEvent, eventPosition: Vector3, normal: Vector3, shapeIdx: number) => void>; }
+    set inputEvent(v: ((camera: Node, event: InputEvent, eventPosition: Vector3, normal: Vector3, shapeIdx: number) => void) | null) { _G(this, 7623, v); }
+
+    /**
+     * Emitted when the mouse pointer enters any of this object's shapes. Requires {@link inputRayPickable} to be `true` and at least one {@link collisionLayer} bit to be set.
+     * **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the {@link CollisionObject3D}'s area is small. This signal may also not be emitted if another {@link CollisionObject3D} is overlapping the {@link CollisionObject3D} in question.
+     */
+    get mouseEntered(): Signal<() => void> { return _G(this, 8963) as Signal<() => void>; }
+    set mouseEntered(v: (() => void) | null) { _G(this, 8963, v); }
+
+    /**
+     * Emitted when the mouse pointer exits all this object's shapes. Requires {@link inputRayPickable} to be `true` and at least one {@link collisionLayer} bit to be set.
+     * **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the {@link CollisionObject3D}'s area is small. This signal may also not be emitted if another {@link CollisionObject3D} is overlapping the {@link CollisionObject3D} in question.
+     */
+    get mouseExited(): Signal<() => void> { return _G(this, 8964) as Signal<() => void>; }
+    set mouseExited(v: (() => void) | null) { _G(this, 8964, v); }
+
+    static readonly name = _R(203, CollisionObject3D);
+}
+
+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 CollisionObject3D}.
+     * 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}, make the body static. Doesn't affect {@link Area3D}. {@link PhysicsBody3D} can't be affected by forces or other bodies while static.
+     * Automatically set {@link PhysicsBody3D} back to its original mode when the {@link Node} is processed again.
+     */
+    DISABLE_MODE_MAKE_STATIC: 1,
+    /**
+     * When {@link Node.processMode} is set to {@link Node.PROCESS_MODE_DISABLED}, do not affect the physics simulation.
+     */
+    DISABLE_MODE_KEEP_ACTIVE: 2,
+} as const;
+
+export type DisableMode = (typeof DisableMode)[keyof typeof DisableMode];
+

package/gen/classes/CollisionPolygon2D.ts

@@ -0,0 +1,70 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { PackedVector2Array } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * A node that provides a polygon shape to a {@link CollisionObject2D} parent and allows it to be edited. The polygon can be concave or convex. This can give a detection shape to an {@link Area2D}, turn a {@link PhysicsBody2D} into a solid object, or give a hollow shape to a {@link StaticBody2D}.
+ * **Warning:** A non-uniformly scaled {@link CollisionPolygon2D} will likely not behave as expected. Make sure to keep its scale the same on all axes and adjust its polygon instead.
+ */
+export class CollisionPolygon2D extends Node2D {
+    constructor(name = 204) { super(name); }
+
+    /**
+     * Collision build mode.
+     */
+    get buildMode(): BuildMode { return _C(this, 4011) as BuildMode; }
+    set buildMode(v: BuildMode) { _C(this, 10747, v); }
+
+    /**
+     * The polygon's list of vertices. Each point will be connected to the next, and the final point will be connected to the first.
+     * **Note:** The returned vertices are in the local coordinate space of the given {@link CollisionPolygon2D}.
+     */
+    get polygon(): PackedVector2Array { return _C(this, 5962) as PackedVector2Array; }
+    set polygon(v: PackedVector2Array) { _C(this, 12373, v); }
+
+    /**
+     * If `true`, no collisions will be detected. This property should be changed with {@link Object.setDeferred}.
+     */
+    get disabled(): boolean { return _C(this, 7883) as boolean; }
+    set disabled(v: boolean) { _C(this, 11122, v); }
+
+    /**
+     * If `true`, only edges that face up, relative to {@link CollisionPolygon2D}'s rotation, will collide with other objects.
+     * **Note:** This property has no effect if this {@link CollisionPolygon2D} is a child of an {@link Area2D} node.
+     * **Note:** The one way collision direction can be configured by setting {@link oneWayCollisionDirection}.
+     */
+    get oneWayCollision(): boolean { return _C(this, 8153) as boolean; }
+    set oneWayCollision(v: boolean) { _C(this, 12186, v); }
+
+    /**
+     * The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the polygon at a high velocity.
+     */
+    get oneWayCollisionMargin(): number { return _C(this, 5720) as number; }
+    set oneWayCollisionMargin(v: number) { _C(this, 12188, v); }
+
+    /**
+     * The direction used for one-way collision.
+     */
+    get oneWayCollisionDirection(): Vector2 { return _C(this, 5719) as Vector2; }
+    set oneWayCollisionDirection(v: Vector2) { _C(this, 12187, v); }
+
+    static readonly name = _R(204, CollisionPolygon2D);
+}
+
+export const BuildMode = {
+    /**
+     * Collisions will include the polygon and its contained area. In this mode the node has the same effect as several {@link ConvexPolygonShape2D} nodes, one for each convex shape in the convex decomposition of the polygon (but without the overhead of multiple nodes).
+     */
+    BUILD_SOLIDS: 0,
+    /**
+     * Collisions will only include the polygon edges. In this mode the node has the same effect as a single {@link ConcavePolygonShape2D} made of segments, with the restriction that each segment (after the first one) starts where the previous one ends, and the last one ends where the first one starts (forming a closed but hollow polygon).
+     */
+    BUILD_SEGMENTS: 1,
+} as const;
+
+export type BuildMode = (typeof BuildMode)[keyof typeof BuildMode];
+