@ringozz/godot 0.1.0

package/gen/classes/PhysicalBone3D.ts

@@ -0,0 +1,189 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PhysicsBody3D } from './PhysicsBody3D.ts';
+import type { Transform3D, Vector3 } from '../value-types/index.ts';
+import type { PhysicsDirectBodyState3D } from './PhysicsDirectBodyState3D.ts';
+
+/**
+ * The {@link PhysicalBone3D} node is a physics body that can be used to make bones in a {@link Skeleton3D} react to physics.
+ * **Note:** In order to detect physical bones with raycasts, the {@link SkeletonModifier3D.active} property of the parent {@link PhysicalBoneSimulator3D} must be `true` and the {@link Skeleton3D}'s bone must be assigned to {@link PhysicalBone3D} correctly; it means that {@link getBoneId} should return a valid id (`>= 0`).
+ */
+export class PhysicalBone3D extends PhysicsBody3D {
+    constructor(name = 556) { super(name); }
+
+    /**
+     * Applies a directional impulse without affecting rotation.
+     * 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 "_integrate_forces" functions otherwise).
+     * This is equivalent to using {@link applyImpulse} at the body's center of mass.
+     */
+    applyCentralImpulse(impulse: Vector3): void { _C(this, 1529, impulse); }
+
+    /**
+     * Applies a positioned impulse to the PhysicsBone3D.
+     * 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 "_integrate_forces" functions otherwise).
+     * `position` is the offset from the PhysicsBone3D origin in global coordinates.
+     */
+    applyImpulse(impulse: Vector3, position?: Vector3 /* = Vector3(0, 0, 0) */): void { _C(this, 1533, impulse, position); }
+
+    /**
+     * Returns `true` if the PhysicsBone3D is allowed to simulate physics.
+     */
+    getSimulatePhysics(): boolean { return _C(this, 6395) as boolean; }
+
+    /**
+     * Returns `true` if the PhysicsBone3D is currently simulating physics.
+     */
+    isSimulatingPhysics(): boolean { return _C(this, 8316) as boolean; }
+
+    /**
+     * Returns the unique identifier of the PhysicsBone3D.
+     */
+    getBoneId(): number { return _C(this, 3966) as number; }
+
+    /**
+     * Sets the joint type.
+     */
+    get jointType(): JointType { return _C(this, 5260) as JointType; }
+    set jointType(v: JointType) { _C(this, 11842, v); }
+
+    /**
+     * Sets the joint's transform.
+     */
+    get jointOffset(): Transform3D { return _C(this, 5248) as Transform3D; }
+    set jointOffset(v: Transform3D) { _C(this, 11830, v); }
+
+    /**
+     * Sets the joint's rotation in radians.
+     */
+    get jointRotation(): Vector3 { return _C(this, 5252) as Vector3; }
+    set jointRotation(v: Vector3) { _C(this, 11834, v); }
+
+    /**
+     * Sets the body's transform.
+     */
+    get bodyOffset(): Transform3D { return _C(this, 3947) as Transform3D; }
+    set bodyOffset(v: Transform3D) { _C(this, 10693, v); }
+
+    /**
+     * The body's mass.
+     */
+    get mass(): number { return _C(this, 5451) as number; }
+    set mass(v: number) { _C(this, 11977, v); }
+
+    /**
+     * The body's friction, from `0` (frictionless) to `1` (max friction).
+     */
+    get friction(): number { return _C(this, 4897) as number; }
+    set friction(v: number) { _C(this, 11490, 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 {@link PhysicalBone3D} that preserves all its energy over time, set {@link bounce} to `1.0`, {@link linearDampMode} to {@link DAMP_MODE_REPLACE}, {@link linearDamp} to `0.0`, {@link angularDampMode} to {@link DAMP_MODE_REPLACE}, and {@link angularDamp} to `0.0`.
+     */
+    get bounce(): number { return _C(this, 3991) as number; }
+    set bounce(v: number) { _C(this, 10731, v); }
+
+    /**
+     * This is multiplied by {@link ProjectSettings.physics/3d/defaultGravity} to produce this body's gravity. For example, a value of `1.0` will apply normal gravity, `2.0` will apply double the gravity, and `0.5` will apply half the gravity to this body.
+     */
+    get gravityScale(): number { return _C(this, 4976) as number; }
+    set gravityScale(v: number) { _C(this, 11559, v); }
+
+    /**
+     * If `true`, the standard force integration (like gravity or damping) will be disabled for this body. Other than collision response, the body will only move as determined by the {@link _integrateForces} method, if that virtual method is overridden.
+     * Setting this property will call the method {@link PhysicsServer3D.bodySetOmitForceIntegration} internally.
+     */
+    get customIntegrator(): boolean { return _C(this, 8399) as boolean; }
+    set customIntegrator(v: boolean) { _C(this, 13205, v); }
+
+    /**
+     * Defines how {@link linearDamp} is applied.
+     */
+    get linearDampMode(): DampMode { return _C(this, 5383) as DampMode; }
+    set linearDampMode(v: DampMode) { _C(this, 11932, v); }
+
+    /**
+     * Damps the body's movement. By default, the body will use {@link ProjectSettings.physics/3d/defaultLinearDamp} or any value override set by an {@link Area3D} the body is in. Depending on {@link linearDampMode}, {@link linearDamp} may be added to or replace the body's damping value.
+     * See {@link ProjectSettings.physics/3d/defaultLinearDamp} for more details about damping.
+     */
+    get linearDamp(): number { return _C(this, 5382) as number; }
+    set linearDamp(v: number) { _C(this, 11931, v); }
+
+    /**
+     * Defines how {@link angularDamp} is applied.
+     */
+    get angularDampMode(): DampMode { return _C(this, 3752) as DampMode; }
+    set angularDampMode(v: DampMode) { _C(this, 10494, v); }
+
+    /**
+     * Damps the body's rotation. By default, the body will use the {@link ProjectSettings.physics/3d/defaultAngularDamp} project setting or any value override set by an {@link Area3D} the body is in. Depending on {@link angularDampMode}, you can set {@link angularDamp} to be added to or to replace the body's damping value.
+     * See {@link ProjectSettings.physics/3d/defaultAngularDamp} for more details about damping.
+     */
+    get angularDamp(): number { return _C(this, 3751) as number; }
+    set angularDamp(v: number) { _C(this, 10493, v); }
+
+    /**
+     * The body's linear velocity in units per second. Can be used sporadically, but **don't set this every frame**, because physics may run in another thread and runs at a different granularity. Use {@link _integrateForces} as your process loop for precise control of the body state.
+     */
+    get linearVelocity(): Vector3 { return _C(this, 5386) as Vector3; }
+    set linearVelocity(v: Vector3) { _C(this, 11935, v); }
+
+    /**
+     * The PhysicalBone3D's rotational velocity in *radians* per second.
+     */
+    get angularVelocity(): Vector3 { return _C(this, 3757) as Vector3; }
+    set angularVelocity(v: Vector3) { _C(this, 10500, v); }
+
+    /**
+     * If `true`, the body is deactivated when there is no movement, so it will not take part in the simulation until it is awakened by an external force.
+     */
+    get canSleep(): boolean { return _C(this, 7726) as boolean; }
+    set canSleep(v: boolean) { _C(this, 10790, v); }
+
+    static readonly name = _R(556, PhysicalBone3D);
+}
+
+export const DampMode = {
+    /**
+     * In this mode, the body's damping value is added to any value set in areas or the default value.
+     */
+    DAMP_MODE_COMBINE: 0,
+    /**
+     * In this mode, the body's damping value replaces any value set in areas or the default value.
+     */
+    DAMP_MODE_REPLACE: 1,
+} as const;
+
+export type DampMode = (typeof DampMode)[keyof typeof DampMode];
+
+export const JointType = {
+    /**
+     * No joint is applied to the PhysicsBone3D.
+     */
+    JOINT_TYPE_NONE: 0,
+    /**
+     * A pin joint is applied to the PhysicsBone3D.
+     */
+    JOINT_TYPE_PIN: 1,
+    /**
+     * A cone joint is applied to the PhysicsBone3D.
+     */
+    JOINT_TYPE_CONE: 2,
+    /**
+     * A hinge joint is applied to the PhysicsBone3D.
+     */
+    JOINT_TYPE_HINGE: 3,
+    /**
+     * A slider joint is applied to the PhysicsBone3D.
+     */
+    JOINT_TYPE_SLIDER: 4,
+    /**
+     * A 6 degrees of freedom joint is applied to the PhysicsBone3D.
+     */
+    JOINT_TYPE_6DOF: 5,
+} as const;
+
+export type JointType = (typeof JointType)[keyof typeof JointType];
+

package/gen/classes/PhysicalBoneSimulator3D.ts

@@ -0,0 +1,43 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModifier3D } from './SkeletonModifier3D.ts';
+import type { GodotArray, RID, StringName } from '../heap-types/index.ts';
+
+/**
+ * Node that can be the parent of {@link PhysicalBone3D} and can apply the simulation results to {@link Skeleton3D}.
+ */
+export class PhysicalBoneSimulator3D extends SkeletonModifier3D {
+    constructor(name = 557) { super(name); }
+
+    /**
+     * Returns a boolean that indicates whether the {@link PhysicalBoneSimulator3D} is running and simulating.
+     */
+    isSimulatingPhysics(): boolean { return _C(this, 8316) as boolean; }
+
+    /**
+     * Tells the {@link PhysicalBone3D} nodes in the Skeleton to stop simulating.
+     */
+    physicalBonesStopSimulation(): void { _C(this, 9403); }
+
+    /**
+     * Tells the {@link PhysicalBone3D} nodes in the Skeleton to start simulating and reacting to the physics world.
+     * Optionally, a list of bone names can be passed-in, allowing only the passed-in bones to be simulated.
+     */
+    physicalBonesStartSimulation(bones?: GodotArray<StringName> /* = [] */): void { _C(this, 9402, bones); }
+
+    /**
+     * Adds a collision exception to the physical bone.
+     * Works just like the {@link RigidBody3D} node.
+     */
+    physicalBonesAddCollisionException(exception: RID): void { _C(this, 9400, exception); }
+
+    /**
+     * Removes a collision exception to the physical bone.
+     * Works just like the {@link RigidBody3D} node.
+     */
+    physicalBonesRemoveCollisionException(exception: RID): void { _C(this, 9401, exception); }
+
+    static readonly name = _R(557, PhysicalBoneSimulator3D);
+}

package/gen/classes/PhysicalSkyMaterial.ts

@@ -0,0 +1,83 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Material } from './Material.ts';
+import type { Color } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * The {@link PhysicalSkyMaterial} uses the Preetham analytic daylight model to draw a sky based on physical properties. This results in a substantially more realistic sky than the {@link ProceduralSkyMaterial}, but it is slightly slower and less flexible.
+ * The {@link PhysicalSkyMaterial} only supports one sun. The color, energy, and direction of the sun are taken from the first {@link DirectionalLight3D} in the scene tree.
+ */
+export class PhysicalSkyMaterial extends Material {
+    constructor(name = 558) { super(name); }
+
+    /**
+     * Controls the strength of the [Rayleigh scattering](https://en.wikipedia.org/wiki/Rayleigh_scattering). Rayleigh scattering results from light colliding with small particles. It is responsible for the blue color of the sky.
+     */
+    get rayleighCoefficient(): number { return _C(this, 6080) as number; }
+    set rayleighCoefficient(v: number) { _C(this, 12480, v); }
+
+    /**
+     * Controls the {@link Color} of the [Rayleigh scattering](https://en.wikipedia.org/wiki/Rayleigh_scattering). While not physically accurate, this allows for the creation of alien-looking planets. For example, setting this to a red {@link Color} results in a Mars-looking atmosphere with a corresponding blue sunset.
+     */
+    get rayleighColor(): Color { return _C(this, 6081) as Color; }
+    set rayleighColor(v: Color) { _C(this, 12481, v); }
+
+    /**
+     * Controls the strength of [Mie scattering](https://en.wikipedia.org/wiki/Mie_scattering) for the sky. Mie scattering results from light colliding with larger particles (like water). On earth, Mie scattering results in a whitish color around the sun and horizon.
+     */
+    get mieCoefficient(): number { return _C(this, 5534) as number; }
+    set mieCoefficient(v: number) { _C(this, 12045, v); }
+
+    /**
+     * Controls the direction of the [Mie scattering](https://en.wikipedia.org/wiki/Mie_scattering). A value of `1` means that when light hits a particle it's passing through straight forward. A value of `-1` means that all light is scatter backwards.
+     */
+    get mieEccentricity(): number { return _C(this, 5536) as number; }
+    set mieEccentricity(v: number) { _C(this, 12047, v); }
+
+    /**
+     * Controls the {@link Color} of the [Mie scattering](https://en.wikipedia.org/wiki/Mie_scattering) effect. While not physically accurate, this allows for the creation of alien-looking planets.
+     */
+    get mieColor(): Color { return _C(this, 5535) as Color; }
+    set mieColor(v: Color) { _C(this, 12046, v); }
+
+    /**
+     * Sets the thickness of the atmosphere. High turbidity creates a foggy-looking atmosphere, while a low turbidity results in a clearer atmosphere.
+     */
+    get turbidity(): number { return _C(this, 6914) as number; }
+    set turbidity(v: number) { _C(this, 13154, v); }
+
+    /**
+     * Sets the size of the sun disk. Default value is based on Sol's perceived size from Earth.
+     */
+    get sunDiskScale(): number { return _C(this, 6610) as number; }
+    set sunDiskScale(v: number) { _C(this, 12934, v); }
+
+    /**
+     * Modulates the {@link Color} on the bottom half of the sky to represent the ground.
+     */
+    get groundColor(): Color { return _C(this, 4981) as Color; }
+    set groundColor(v: Color) { _C(this, 11564, v); }
+
+    /**
+     * The sky's overall brightness multiplier. Higher values result in a brighter sky.
+     */
+    get energyMultiplier(): number { return _C(this, 4669) as number; }
+    set energyMultiplier(v: number) { _C(this, 11296, v); }
+
+    /**
+     * If `true`, enables debanding. Debanding adds a small amount of noise which helps reduce banding that appears from the smooth changes in color in the sky.
+     */
+    get useDebanding(): boolean { return _C(this, 6974) as boolean; }
+    set useDebanding(v: boolean) { _C(this, 13208, v); }
+
+    /**
+     * {@link Texture2D} for the night sky. This is added to the sky, so if it is bright enough, it may be visible during the day.
+     */
+    get nightSky(): Texture2D { return _C(this, 5636) as Texture2D; }
+    set nightSky(v: Texture2D) { _C(this, 12133, v); }
+
+    static readonly name = _R(558, PhysicalSkyMaterial);
+}

package/gen/classes/PhysicsBody2D.ts

@@ -0,0 +1,55 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CollisionObject2D } from './CollisionObject2D.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+import type { KinematicCollision2D } from './KinematicCollision2D.ts';
+import type { Node } from './Node.ts';
+
+/**
+ * {@link PhysicsBody2D} is an abstract base class for 2D game objects affected by physics. All 2D physics bodies inherit from it.
+ */
+export class PhysicsBody2D extends CollisionObject2D {
+
+    /**
+     * Moves the body along the vector `motion`. In order to be frame rate independent in {@link Node.PhysicsProcess} or {@link Node.Process}, `motion` should be computed using `delta`.
+     * Returns a {@link KinematicCollision2D}, which contains information about the collision when stopped, or when touching another body along the motion.
+     * If `testOnly` is `true`, the body does not move but the would-be collision information is given.
+     * `safeMargin` is the extra margin used for collision recovery (see {@link CharacterBody2D.safeMargin} for more details).
+     * If `recoveryAsCollision` is `true`, any depenetration from the recovery phase is also reported as a collision; this is used e.g. by {@link CharacterBody2D} for improving floor detection during floor snapping.
+     */
+    moveAndCollide(motion: Vector2, testOnly?: boolean /* = false */, safeMargin?: number /* = 0.08 */, recoveryAsCollision?: boolean /* = false */): KinematicCollision2D { return _C(this, 8978, motion, testOnly, safeMargin, recoveryAsCollision) as KinematicCollision2D; }
+
+    /**
+     * Checks for collisions without moving the body. In order to be frame rate independent in {@link Node.PhysicsProcess} or {@link Node.Process}, `motion` should be computed using `delta`.
+     * Virtually sets the node's position, scale and rotation to that of the given {@link Transform2D}, then tries to move the body along the vector `motion`. Returns `true` if a collision would stop the body from moving along the whole path.
+     * `collision` is an optional object of type {@link KinematicCollision2D}, which contains additional information about the collision when stopped, or when touching another body along the motion.
+     * `safeMargin` is the extra margin used for collision recovery (see {@link CharacterBody2D.safeMargin} for more details).
+     * If `recoveryAsCollision` is `true`, any depenetration from the recovery phase is also reported as a collision; this is useful for checking whether the body would *touch* any other bodies.
+     */
+    testMove(from: Transform2D, motion: Vector2, collision?: KinematicCollision2D /* = null */, safeMargin?: number /* = 0.08 */, recoveryAsCollision?: boolean /* = false */): boolean { return _C(this, 14149, from, motion, collision, safeMargin, recoveryAsCollision) as boolean; }
+
+    /**
+     * Returns the gravity vector computed from all sources that can affect the body, including all gravity overrides from {@link Area2D} nodes and the global world gravity.
+     */
+    getGravity(): Vector2 { return _C(this, 4971) as Vector2; }
+
+    /**
+     * Returns an array of nodes that were added as collision exceptions for this body.
+     */
+    getCollisionExceptions(): GodotArray<PhysicsBody2D> { return _C(this, 4199) as GodotArray<PhysicsBody2D>; }
+
+    /**
+     * 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); }
+
+    static readonly name = _R(559, PhysicsBody2D);
+}

package/gen/classes/PhysicsBody3D.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 { CollisionObject3D } from './CollisionObject3D.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { Transform3D, Vector3 } from '../value-types/index.ts';
+import type { KinematicCollision3D } from './KinematicCollision3D.ts';
+import type { Node } from './Node.ts';
+
+/**
+ * {@link PhysicsBody3D} is an abstract base class for 3D game objects affected by physics. All 3D physics bodies inherit from it.
+ * **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 PhysicsBody3D extends CollisionObject3D {
+
+    /**
+     * Moves the body along the vector `motion`. In order to be frame rate independent in {@link Node.PhysicsProcess} or {@link Node.Process}, `motion` should be computed using `delta`.
+     * The body will stop if it collides. Returns a {@link KinematicCollision3D}, which contains information about the collision when stopped, or when touching another body along the motion.
+     * If `testOnly` is `true`, the body does not move but the would-be collision information is given.
+     * `safeMargin` is the extra margin used for collision recovery (see {@link CharacterBody3D.safeMargin} for more details).
+     * If `recoveryAsCollision` is `true`, any depenetration from the recovery phase is also reported as a collision; this is used e.g. by {@link CharacterBody3D} for improving floor detection during floor snapping.
+     * `maxCollisions` allows to retrieve more than one collision result.
+     */
+    moveAndCollide(motion: Vector3, testOnly?: boolean /* = false */, safeMargin?: number /* = 0.001 */, recoveryAsCollision?: boolean /* = false */, maxCollisions?: number /* = 1 */): KinematicCollision3D { return _C(this, 8978, motion, testOnly, safeMargin, recoveryAsCollision, maxCollisions) as KinematicCollision3D; }
+
+    /**
+     * Checks for collisions without moving the body. In order to be frame rate independent in {@link Node.PhysicsProcess} or {@link Node.Process}, `motion` should be computed using `delta`.
+     * Virtually sets the node's position, scale and rotation to that of the given {@link Transform3D}, then tries to move the body along the vector `motion`. Returns `true` if a collision would stop the body from moving along the whole path.
+     * `collision` is an optional object of type {@link KinematicCollision3D}, which contains additional information about the collision when stopped, or when touching another body along the motion.
+     * `safeMargin` is the extra margin used for collision recovery (see {@link CharacterBody3D.safeMargin} for more details).
+     * If `recoveryAsCollision` is `true`, any depenetration from the recovery phase is also reported as a collision; this is useful for checking whether the body would *touch* any other bodies.
+     * `maxCollisions` allows to retrieve more than one collision result.
+     */
+    testMove(from: Transform3D, motion: Vector3, collision?: KinematicCollision3D /* = null */, safeMargin?: number /* = 0.001 */, recoveryAsCollision?: boolean /* = false */, maxCollisions?: number /* = 1 */): boolean { return _C(this, 14149, from, motion, collision, safeMargin, recoveryAsCollision, maxCollisions) as boolean; }
+
+    /**
+     * Returns the gravity vector computed from all sources that can affect the body, including all gravity overrides from {@link Area3D} nodes and the global world gravity.
+     */
+    getGravity(): Vector3 { return _C(this, 4971) as Vector3; }
+
+    /**
+     * 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); }
+
+    /**
+     * Lock the body's linear movement in the X axis.
+     */
+    get axisLockLinearX(): boolean { return _C(this, 3861, 1) as boolean; }
+    set axisLockLinearX(v: boolean) { _C(this, 10606, 1, v); }
+
+    /**
+     * Lock the body's linear movement in the Y axis.
+     */
+    get axisLockLinearY(): boolean { return _C(this, 3861, 2) as boolean; }
+    set axisLockLinearY(v: boolean) { _C(this, 10606, 2, v); }
+
+    /**
+     * Lock the body's linear movement in the Z axis.
+     */
+    get axisLockLinearZ(): boolean { return _C(this, 3861, 4) as boolean; }
+    set axisLockLinearZ(v: boolean) { _C(this, 10606, 4, v); }
+
+    /**
+     * Lock the body's rotation in the X axis.
+     */
+    get axisLockAngularX(): boolean { return _C(this, 3861, 8) as boolean; }
+    set axisLockAngularX(v: boolean) { _C(this, 10606, 8, v); }
+
+    /**
+     * Lock the body's rotation in the Y axis.
+     */
+    get axisLockAngularY(): boolean { return _C(this, 3861, 16) as boolean; }
+    set axisLockAngularY(v: boolean) { _C(this, 10606, 16, v); }
+
+    /**
+     * Lock the body's rotation in the Z axis.
+     */
+    get axisLockAngularZ(): boolean { return _C(this, 3861, 32) as boolean; }
+    set axisLockAngularZ(v: boolean) { _C(this, 10606, 32, v); }
+
+    static readonly name = _R(560, PhysicsBody3D);
+}