@ringozz/godot 0.1.0

package/gen/classes/PhysicsDirectSpaceState3D.ts

@@ -0,0 +1,81 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { GodotArray, GodotDictionary, PackedFloat32Array } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { PhysicsPointQueryParameters3D } from './PhysicsPointQueryParameters3D.ts';
+import type { PhysicsRayQueryParameters3D } from './PhysicsRayQueryParameters3D.ts';
+import type { PhysicsShapeQueryParameters3D } from './PhysicsShapeQueryParameters3D.ts';
+
+/**
+ * Provides direct access to a physics space in the {@link PhysicsServer3D}. It's used mainly to do queries against objects and areas residing in a given space.
+ * **Note:** This class is not meant to be instantiated directly. Use {@link World3D.directSpaceState} to get the world's physics 3D space state.
+ */
+export class PhysicsDirectSpaceState3D extends Object {
+
+    /**
+     * Checks whether a point is inside any solid shape. Position and other parameters are defined through {@link PhysicsPointQueryParameters3D}. The shapes the point is inside of are returned in an array containing dictionaries with the following fields:
+     * `collider`: The colliding object.
+     * `collider_id`: The colliding object's ID.
+     * `rid`: The intersecting object's {@link RID}.
+     * `shape`: The shape index of the colliding shape.
+     * The number of intersections can be limited with the `maxResults` parameter, to reduce the processing time.
+     */
+    intersectPoint(parameters: PhysicsPointQueryParameters3D, maxResults?: number /* = 32 */): GodotArray<GodotDictionary> { return _C(this, 7699, parameters, maxResults) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Intersects a ray in a given space. Ray position and other parameters are defined through {@link PhysicsRayQueryParameters3D}. The returned object is a dictionary with the following fields:
+     * `collider`: The colliding object.
+     * `collider_id`: The colliding object's ID.
+     * `normal`: The object's surface normal at the intersection point, or `Vector3(0, 0, 0)` if the ray starts inside the shape and {@link PhysicsRayQueryParameters3D.hitFromInside} is `true`.
+     * `position`: The intersection point.
+     * `face_index`: The face index at the intersection point.
+     * **Note:** Returns a valid number only if the intersected shape is a {@link ConcavePolygonShape3D}. Otherwise, `-1` is returned.
+     * `rid`: The intersecting object's {@link RID}.
+     * `shape`: The shape index of the colliding shape.
+     * If the ray did not intersect anything, then an empty dictionary is returned instead.
+     */
+    intersectRay(parameters: PhysicsRayQueryParameters3D): GodotDictionary { return _C(this, 7702, parameters) as GodotDictionary; }
+
+    /**
+     * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters3D} object, against the space. The intersected shapes are returned in an array containing dictionaries with the following fields:
+     * `collider`: The colliding object.
+     * `collider_id`: The colliding object's ID.
+     * `rid`: The intersecting object's {@link RID}.
+     * `shape`: The shape index of the colliding shape.
+     * The number of intersections can be limited with the `maxResults` parameter, to reduce the processing time.
+     * **Note:** This method does not take into account the `motion` property of the object.
+     */
+    intersectShape(parameters: PhysicsShapeQueryParameters3D, maxResults?: number /* = 32 */): GodotArray<GodotDictionary> { return _C(this, 7704, parameters, maxResults) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Checks how far a {@link Shape3D} can move without colliding. All the parameters for the query, including the shape and the motion, are supplied through a {@link PhysicsShapeQueryParameters3D} object.
+     * Returns an array with the safe and unsafe proportions (between 0 and 1) of the motion. The safe proportion is the maximum fraction of the motion that can be made without a collision. The unsafe proportion is the minimum fraction of the distance that must be moved for a collision. If no collision is detected a result of `[1.0, 1.0]` will be returned.
+     * **Note:** Any {@link Shape3D}s that the shape is already colliding with e.g. inside of, will be ignored. Use {@link collideShape} to determine the {@link Shape3D}s that the shape is already colliding with.
+     */
+    castMotion(parameters: PhysicsShapeQueryParameters3D): PackedFloat32Array { return _C(this, 2153, parameters) as PackedFloat32Array; }
+
+    /**
+     * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters3D} object, against the space. The resulting array contains a list of points where the shape intersects another. Like with {@link intersectShape}, the number of returned results can be limited to save processing time.
+     * Returned points are a list of pairs of contact points. For each pair the first one is in the shape passed in {@link PhysicsShapeQueryParameters3D} object, second one is in the collided shape from the physics space.
+     * **Note:** This method does not take into account the `motion` property of the object.
+     */
+    collideShape(parameters: PhysicsShapeQueryParameters3D, maxResults?: number /* = 32 */): GodotArray<Vector3> { return _C(this, 2347, parameters, maxResults) as GodotArray<Vector3>; }
+
+    /**
+     * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters3D} object, against the space. If it collides with more than one shape, the nearest one is selected. The returned object is a dictionary containing the following fields:
+     * `collider_id`: The colliding object's ID.
+     * `linear_velocity`: The colliding object's velocity {@link Vector3}. If the object is an {@link Area3D}, the result is `(0, 0, 0)`.
+     * `normal`: The collision normal of the query shape at the intersection point, pointing away from the intersecting object.
+     * `point`: The intersection point.
+     * `rid`: The intersecting object's {@link RID}.
+     * `shape`: The shape index of the colliding shape.
+     * If the shape did not intersect anything, then an empty dictionary is returned instead.
+     * **Note:** This method does not take into account the `motion` property of the object.
+     */
+    getRestInfo(parameters: PhysicsShapeQueryParameters3D): GodotDictionary { return _C(this, 6169, parameters) as GodotDictionary; }
+
+    static readonly name = _R(567, PhysicsDirectSpaceState3D);
+}

package/gen/classes/PhysicsDirectSpaceState3DExtension.ts

@@ -0,0 +1,19 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PhysicsDirectSpaceState3D } from './PhysicsDirectSpaceState3D.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { Transform3D, Vector3 } from '../value-types/index.ts';
+
+/**
+ * This class extends {@link PhysicsDirectSpaceState3D} by providing additional virtual methods that can be overridden. When these methods are overridden, they will be called instead of the internal methods of the physics server.
+ * Intended for use with GDExtension to create custom implementations of {@link PhysicsDirectSpaceState3D}.
+ */
+export class PhysicsDirectSpaceState3DExtension extends PhysicsDirectSpaceState3D {
+    constructor(name = 568) { super(name); }
+
+    isBodyExcludedFromQuery(body: RID): boolean { return _C(this, 7799, body) as boolean; }
+
+    static readonly name = _R(568, PhysicsDirectSpaceState3DExtension);
+}

package/gen/classes/PhysicsMaterial.ts

@@ -0,0 +1,39 @@
+// 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';
+
+/**
+ * Holds physics-related properties of a surface, namely its roughness and bounciness. This class is used to apply these properties to a physics body.
+ */
+export class PhysicsMaterial extends Resource {
+    constructor(name = 569) { super(name); }
+
+    /**
+     * The body's friction. Values range from `0` (frictionless) to `1` (maximum friction).
+     */
+    get friction(): number { return _C(this, 4897) as number; }
+    set friction(v: number) { _C(this, 11490, v); }
+
+    /**
+     * If `true`, the physics engine will use the friction of the object marked as "rough" when two objects collide. If `false`, the physics engine will use the lowest friction of all colliding objects instead. If `true` for both colliding objects, the physics engine will use the highest friction.
+     */
+    get rough(): boolean { return _C(this, 8257) as boolean; }
+    set rough(v: boolean) { _C(this, 12593, v); }
+
+    /**
+     * The body's bounciness. Values range from `0` (no bounce) to `1` (full bounciness).
+     * **Note:** Even with {@link bounce} set to `1.0`, some energy will be lost over time due to linear and angular damping. To have a physics body that preserves all its energy over time, set {@link bounce} to `1.0`, the body's linear damp mode to **Replace** (if applicable), its linear damp to `0.0`, its angular damp mode to **Replace** (if applicable), and its angular damp to `0.0`.
+     */
+    get bounce(): number { return _C(this, 3991) as number; }
+    set bounce(v: number) { _C(this, 10731, v); }
+
+    /**
+     * If `true`, subtracts the bounciness from the colliding object's bounciness instead of adding it.
+     */
+    get absorbent(): boolean { return _C(this, 7730) as boolean; }
+    set absorbent(v: boolean) { _C(this, 10398, v); }
+
+    static readonly name = _R(569, PhysicsMaterial);
+}

package/gen/classes/PhysicsPointQueryParameters2D.ts

@@ -0,0 +1,54 @@
+// 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 { GodotArray, RID } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * By changing various properties of this object, such as the point position, you can configure the parameters for {@link PhysicsDirectSpaceState2D.intersectPoint}.
+ */
+export class PhysicsPointQueryParameters2D extends RefCounted {
+    constructor(name = 570) { super(name); }
+
+    /**
+     * The position being queried for, in global coordinates.
+     */
+    get position(): Vector2 { return _C(this, 5973) as Vector2; }
+    set position(v: Vector2) { _C(this, 12381, v); }
+
+    /**
+     * If different from `0`, restricts the query to a specific canvas layer specified by its instance ID. See {@link Object.getInstanceId}.
+     * If `0`, restricts the query to the Viewport's default canvas layer.
+     */
+    get canvasInstanceId(): number { return _C(this, 4074) as number; }
+    set canvasInstanceId(v: number) { _C(this, 10795, v); }
+
+    /**
+     * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. 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 list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject2D.getRid} to get the {@link RID} associated with a {@link CollisionObject2D}-derived node.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+     */
+    get exclude(): GodotArray<RID> { return _C(this, 4693) as GodotArray<RID>; }
+    set exclude(v: GodotArray<RID>) { _C(this, 11309, v); }
+
+    /**
+     * If `true`, the query will take {@link PhysicsBody2D}s into account.
+     */
+    get collideWithBodies(): boolean { return _C(this, 7840) as boolean; }
+    set collideWithBodies(v: boolean) { _C(this, 10885, v); }
+
+    /**
+     * If `true`, the query will take {@link Area2D}s into account.
+     */
+    get collideWithAreas(): boolean { return _C(this, 7839) as boolean; }
+    set collideWithAreas(v: boolean) { _C(this, 10884, v); }
+
+    static readonly name = _R(570, PhysicsPointQueryParameters2D);
+}

package/gen/classes/PhysicsPointQueryParameters3D.ts

@@ -0,0 +1,47 @@
+// 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 { GodotArray, RID } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * By changing various properties of this object, such as the point position, you can configure the parameters for {@link PhysicsDirectSpaceState3D.intersectPoint}.
+ */
+export class PhysicsPointQueryParameters3D extends RefCounted {
+    constructor(name = 571) { super(name); }
+
+    /**
+     * The position being queried for, in global coordinates.
+     */
+    get position(): Vector3 { return _C(this, 5973) as Vector3; }
+    set position(v: Vector3) { _C(this, 12381, v); }
+
+    /**
+     * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. 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 list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject3D.getRid} to get the {@link RID} associated with a {@link CollisionObject3D}-derived node.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+     */
+    get exclude(): GodotArray<RID> { return _C(this, 4693) as GodotArray<RID>; }
+    set exclude(v: GodotArray<RID>) { _C(this, 11309, v); }
+
+    /**
+     * If `true`, the query will take {@link PhysicsBody3D}s into account.
+     */
+    get collideWithBodies(): boolean { return _C(this, 7840) as boolean; }
+    set collideWithBodies(v: boolean) { _C(this, 10885, v); }
+
+    /**
+     * If `true`, the query will take {@link Area3D}s into account.
+     */
+    get collideWithAreas(): boolean { return _C(this, 7839) as boolean; }
+    set collideWithAreas(v: boolean) { _C(this, 10884, v); }
+
+    static readonly name = _R(571, PhysicsPointQueryParameters3D);
+}

package/gen/classes/PhysicsRayQueryParameters2D.ts

@@ -0,0 +1,71 @@
+// 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 { GodotArray, RID } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * By changing various properties of this object, such as the ray position, you can configure the parameters for {@link PhysicsDirectSpaceState2D.intersectRay}.
+ */
+export class PhysicsRayQueryParameters2D extends RefCounted {
+    constructor(name = 572) { super(name); }
+
+    /**
+     * Returns a new, pre-configured {@link PhysicsRayQueryParameters2D} object. Use it to quickly create query parameters using the most common options.
+     *
+     * ```text
+     *
+     * var query = PhysicsRayQueryParameters2D.create(global_position, global_position + Vector2(0, 100))
+     * var collision = get_world_2d().direct_space_state.intersect_ray(query)
+     *
+     * ```
+     */
+    static create(from: Vector2, to: Vector2, collisionMask?: number /* = 4294967295,  uint32 */, exclude?: GodotArray<RID> /* = Array[RID]([]) */): PhysicsRayQueryParameters2D { return _C(572, 2506, from, to, collisionMask, exclude) as PhysicsRayQueryParameters2D; }
+
+    /**
+     * The starting point of the ray being queried for, in global coordinates.
+     */
+    get from(): Vector2 { return _C(this, 4899) as Vector2; }
+    set from(v: Vector2) { _C(this, 11492, v); }
+
+    /**
+     * The ending point of the ray being queried for, in global coordinates.
+     */
+    get to(): Vector2 { return _C(this, 6835) as Vector2; }
+    set to(v: Vector2) { _C(this, 13105, v); }
+
+    /**
+     * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. 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 list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject2D.getRid} to get the {@link RID} associated with a {@link CollisionObject2D}-derived node.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+     */
+    get exclude(): GodotArray<RID> { return _C(this, 4693) as GodotArray<RID>; }
+    set exclude(v: GodotArray<RID>) { _C(this, 11309, v); }
+
+    /**
+     * If `true`, the query will take {@link PhysicsBody2D}s into account.
+     */
+    get collideWithBodies(): boolean { return _C(this, 7840) as boolean; }
+    set collideWithBodies(v: boolean) { _C(this, 10885, v); }
+
+    /**
+     * If `true`, the query will take {@link Area2D}s into account.
+     */
+    get collideWithAreas(): boolean { return _C(this, 7839) as boolean; }
+    set collideWithAreas(v: boolean) { _C(this, 10884, v); }
+
+    /**
+     * If `true`, the query will detect a hit when starting inside shapes. In this case the collision normal will be `Vector2(0, 0)`. Does not affect concave polygon shapes.
+     */
+    get hitFromInside(): boolean { return _C(this, 8000) as boolean; }
+    set hitFromInside(v: boolean) { _C(this, 11636, v); }
+
+    static readonly name = _R(572, PhysicsRayQueryParameters2D);
+}

package/gen/classes/PhysicsRayQueryParameters3D.ts

@@ -0,0 +1,77 @@
+// 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 { GodotArray, RID } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * By changing various properties of this object, such as the ray position, you can configure the parameters for {@link PhysicsDirectSpaceState3D.intersectRay}.
+ */
+export class PhysicsRayQueryParameters3D extends RefCounted {
+    constructor(name = 573) { super(name); }
+
+    /**
+     * Returns a new, pre-configured {@link PhysicsRayQueryParameters3D} object. Use it to quickly create query parameters using the most common options.
+     *
+     * ```text
+     *
+     * var query = PhysicsRayQueryParameters3D.create(position, position + Vector3(0, -10, 0))
+     * var collision = get_world_3d().direct_space_state.intersect_ray(query)
+     *
+     * ```
+     */
+    static create(from: Vector3, to: Vector3, collisionMask?: number /* = 4294967295,  uint32 */, exclude?: GodotArray<RID> /* = Array[RID]([]) */): PhysicsRayQueryParameters3D { return _C(573, 2506, from, to, collisionMask, exclude) as PhysicsRayQueryParameters3D; }
+
+    /**
+     * The starting point of the ray being queried for, in global coordinates.
+     */
+    get from(): Vector3 { return _C(this, 4899) as Vector3; }
+    set from(v: Vector3) { _C(this, 11492, v); }
+
+    /**
+     * The ending point of the ray being queried for, in global coordinates.
+     */
+    get to(): Vector3 { return _C(this, 6835) as Vector3; }
+    set to(v: Vector3) { _C(this, 13105, v); }
+
+    /**
+     * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. 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 list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject3D.getRid} to get the {@link RID} associated with a {@link CollisionObject3D}-derived node.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+     */
+    get exclude(): GodotArray<RID> { return _C(this, 4693) as GodotArray<RID>; }
+    set exclude(v: GodotArray<RID>) { _C(this, 11309, v); }
+
+    /**
+     * If `true`, the query will take {@link PhysicsBody3D}s into account.
+     */
+    get collideWithBodies(): boolean { return _C(this, 7840) as boolean; }
+    set collideWithBodies(v: boolean) { _C(this, 10885, v); }
+
+    /**
+     * If `true`, the query will take {@link Area3D}s into account.
+     */
+    get collideWithAreas(): boolean { return _C(this, 7839) as boolean; }
+    set collideWithAreas(v: boolean) { _C(this, 10884, v); }
+
+    /**
+     * If `true`, the query will detect a hit when starting inside shapes. In this case the collision normal will be `Vector3(0, 0, 0)`. Does not affect concave polygon shapes or heightmap shapes.
+     */
+    get hitFromInside(): boolean { return _C(this, 8000) as boolean; }
+    set hitFromInside(v: boolean) { _C(this, 11636, v); }
+
+    /**
+     * If `true`, the query will hit back faces with concave polygon shapes with back face enabled or heightmap shapes.
+     */
+    get hitBackFaces(): boolean { return _C(this, 7999) as boolean; }
+    set hitBackFaces(v: boolean) { _C(this, 11635, v); }
+
+    static readonly name = _R(573, PhysicsRayQueryParameters3D);
+}