@ringozz/godot 0.1.0

package/gen/classes/GPUParticlesAttractorBox3D.ts

@@ -0,0 +1,23 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GPUParticlesAttractor3D } from './GPUParticlesAttractor3D.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * A box-shaped attractor that influences particles from {@link GPUParticles3D} nodes. Can be used to attract particles towards its origin, or to push them away from its origin.
+ * Particle attractors work in real-time and can be moved, rotated and scaled during gameplay. Unlike collision shapes, non-uniform scaling of attractors is also supported.
+ * **Note:** Particle attractors only affect {@link GPUParticles3D}, not {@link CPUParticles3D}.
+ */
+export class GPUParticlesAttractorBox3D extends GPUParticlesAttractor3D {
+    constructor(name = 301) { super(name); }
+
+    /**
+     * The attractor box's size in 3D units.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    static readonly name = _R(301, GPUParticlesAttractorBox3D);
+}

package/gen/classes/GPUParticlesAttractorSphere3D.ts

@@ -0,0 +1,23 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GPUParticlesAttractor3D } from './GPUParticlesAttractor3D.ts';
+
+/**
+ * A spheroid-shaped attractor that influences particles from {@link GPUParticles3D} nodes. Can be used to attract particles towards its origin, or to push them away from its origin.
+ * Particle attractors work in real-time and can be moved, rotated and scaled during gameplay. Unlike collision shapes, non-uniform scaling of attractors is also supported.
+ * **Note:** Particle attractors only affect {@link GPUParticles3D}, not {@link CPUParticles3D}.
+ */
+export class GPUParticlesAttractorSphere3D extends GPUParticlesAttractor3D {
+    constructor(name = 302) { super(name); }
+
+    /**
+     * The attractor sphere's radius in 3D units.
+     * **Note:** Stretched ellipses can be obtained by using non-uniform scaling on the {@link GPUParticlesAttractorSphere3D} node.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    static readonly name = _R(302, GPUParticlesAttractorSphere3D);
+}

package/gen/classes/GPUParticlesAttractorVectorField3D.ts

@@ -0,0 +1,32 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GPUParticlesAttractor3D } from './GPUParticlesAttractor3D.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { Texture3D } from './Texture3D.ts';
+
+/**
+ * A box-shaped attractor with varying directions and strengths defined in it that influences particles from {@link GPUParticles3D} nodes.
+ * Unlike {@link GPUParticlesAttractorBox3D}, {@link GPUParticlesAttractorVectorField3D} uses a {@link texture} to affect attraction strength within the box. This can be used to create complex attraction scenarios where particles travel in different directions depending on their location. This can be useful for weather effects such as sandstorms.
+ * Particle attractors work in real-time and can be moved, rotated and scaled during gameplay. Unlike collision shapes, non-uniform scaling of attractors is also supported.
+ * **Note:** Particle attractors only affect {@link GPUParticles3D}, not {@link CPUParticles3D}.
+ */
+export class GPUParticlesAttractorVectorField3D extends GPUParticlesAttractor3D {
+    constructor(name = 303) { super(name); }
+
+    /**
+     * The size of the vector field box in 3D units.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    /**
+     * The 3D texture to be used. Values are linearly interpolated between the texture's pixels.
+     * **Note:** To get better performance, the 3D texture's resolution should reflect the {@link size} of the attractor. Since particle attraction is usually low-frequency data, the texture can be kept at a low resolution such as 64×64×64.
+     */
+    get texture(): Texture3D { return _C(this, 6726) as Texture3D; }
+    set texture(v: Texture3D) { _C(this, 13024, v); }
+
+    static readonly name = _R(303, GPUParticlesAttractorVectorField3D);
+}

package/gen/classes/GPUParticlesCollision3D.ts

@@ -0,0 +1,26 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualInstance3D } from './VisualInstance3D.ts';
+
+/**
+ * Particle collision shapes can be used to make particles stop or bounce against them.
+ * Particle collision shapes work in real-time and can be moved, rotated and scaled during gameplay. Unlike attractors, non-uniform scaling of collision shapes is *not* supported.
+ * Particle collision shapes can be temporarily disabled by hiding them.
+ * **Note:** {@link ParticleProcessMaterial.collisionMode} must be {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT} on the {@link GPUParticles3D}'s process material for collision to work.
+ * **Note:** Particle collision only affects {@link GPUParticles3D}, not {@link CPUParticles3D}.
+ * **Note:** Particles pushed by a collider that is being moved will not be interpolated, which can result in visible stuttering. This can be alleviated by setting {@link GPUParticles3D.fixedFps} to `0` or a value that matches or exceeds the target framerate.
+ */
+export class GPUParticlesCollision3D extends VisualInstance3D {
+
+    /**
+     * The particle rendering layers ({@link VisualInstance3D.layers}) that will be affected by the collision shape. By default, all particles that have {@link ParticleProcessMaterial.collisionMode} set to {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT} will be affected by a collision shape.
+     * After configuring particle nodes accordingly, specific layers can be unchecked to prevent certain particles from being affected by colliders. For example, this can be used if you're using a collider as part of a spell effect but don't want the collider to affect unrelated weather particles at the same position.
+     * Particle collision can also be disabled on a per-process material basis by setting {@link ParticleProcessMaterial.collisionMode} on the {@link GPUParticles3D} node.
+     */
+    get cullMask(): number { return _C(this, 4339) as number; }
+    set cullMask(v: number) { _C(this, 10981, v); }
+
+    static readonly name = _R(304, GPUParticlesCollision3D);
+}

package/gen/classes/GPUParticlesCollisionBox3D.ts

@@ -0,0 +1,24 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GPUParticlesCollision3D } from './GPUParticlesCollision3D.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * A box-shaped 3D particle collision shape affecting {@link GPUParticles3D} nodes.
+ * Particle collision shapes work in real-time and can be moved, rotated and scaled during gameplay. Unlike attractors, non-uniform scaling of collision shapes is *not* supported.
+ * **Note:** {@link ParticleProcessMaterial.collisionMode} must be {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT} on the {@link GPUParticles3D}'s process material for collision to work.
+ * **Note:** Particle collision only affects {@link GPUParticles3D}, not {@link CPUParticles3D}.
+ */
+export class GPUParticlesCollisionBox3D extends GPUParticlesCollision3D {
+    constructor(name = 305) { super(name); }
+
+    /**
+     * The collision box's size in 3D units.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    static readonly name = _R(305, GPUParticlesCollisionBox3D);
+}

package/gen/classes/GPUParticlesCollisionHeightField3D.ts

@@ -0,0 +1,109 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GPUParticlesCollision3D } from './GPUParticlesCollision3D.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * A real-time heightmap-shaped 3D particle collision shape affecting {@link GPUParticles3D} nodes.
+ * Heightmap shapes allow for efficiently representing collisions for convex and concave objects with a single "floor" (such as terrain). This is less flexible than {@link GPUParticlesCollisionSDF3D}, but it doesn't require a baking step.
+ * {@link GPUParticlesCollisionHeightField3D} can also be regenerated in real-time when it is moved, when the camera moves, or even continuously. This makes {@link GPUParticlesCollisionHeightField3D} a good choice for weather effects such as rain and snow and games with highly dynamic geometry. However, this class is limited since heightmaps cannot represent overhangs (e.g. indoors or caves).
+ * **Note:** {@link ParticleProcessMaterial.collisionMode} must be `true` on the {@link GPUParticles3D}'s process material for collision to work.
+ * **Note:** Particle collision only affects {@link GPUParticles3D}, not {@link CPUParticles3D}.
+ */
+export class GPUParticlesCollisionHeightField3D extends GPUParticlesCollision3D {
+    constructor(name = 306) { super(name); }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link heightfieldMask}, given a `layerNumber` between `1` and `20`, inclusive.
+     */
+    setHeightfieldMaskValue(layerNumber: number, value: boolean): void { _C(this, 11612, layerNumber, value); }
+
+    /**
+     * Returns `true` if the specified layer of the {@link heightfieldMask} is enabled, given a `layerNumber` between `1` and `20`, inclusive.
+     */
+    getHeightfieldMaskValue(layerNumber: number): boolean { return _C(this, 5027, layerNumber) as boolean; }
+
+    /**
+     * The collision heightmap's size in 3D units. To improve heightmap quality, {@link size} should be set as small as possible while covering the parts of the scene you need.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    /**
+     * Higher resolutions can represent small details more accurately in large scenes, at the cost of lower performance. If {@link updateMode} is {@link UPDATE_MODE_ALWAYS}, consider using the lowest resolution possible.
+     */
+    get resolution(): Resolution { return _C(this, 6154) as Resolution; }
+    set resolution(v: Resolution) { _C(this, 12540, v); }
+
+    /**
+     * The update policy to use for the generated heightmap.
+     */
+    get updateMode(): UpdateMode { return _C(this, 6960) as UpdateMode; }
+    set updateMode(v: UpdateMode) { _C(this, 13180, v); }
+
+    /**
+     * If `true`, the {@link GPUParticlesCollisionHeightField3D} will follow the current camera in global space. The {@link GPUParticlesCollisionHeightField3D} does not need to be a child of the {@link Camera3D} node for this to work.
+     * Following the camera has a performance cost, as it will force the heightmap to update whenever the camera moves. Consider lowering {@link resolution} to improve performance if {@link followCameraEnabled} is `true`.
+     */
+    get followCameraEnabled(): boolean { return _C(this, 7966) as boolean; }
+    set followCameraEnabled(v: boolean) { _C(this, 11448, v); }
+
+    /**
+     * The visual layers to account for when updating the heightmap. Only {@link MeshInstance3D}s whose {@link VisualInstance3D.layers} match with this {@link heightfieldMask} will be included in the heightmap collision update. By default, all 20 user-visible layers are taken into account for updating the heightmap collision.
+     * **Note:** Since the {@link heightfieldMask} allows for 32 layers to be stored in total, there are an additional 12 layers that are only used internally by the engine and aren't exposed in the editor. Setting {@link heightfieldMask} using a script allows you to toggle those reserved layers, which can be useful for editor plugins.
+     * To adjust {@link heightfieldMask} more easily using a script, use {@link getHeightfieldMaskValue} and {@link setHeightfieldMaskValue}.
+     */
+    get heightfieldMask(): number { return _C(this, 5026) as number; }
+    set heightfieldMask(v: number) { _C(this, 11611, v); }
+
+    static readonly name = _R(306, GPUParticlesCollisionHeightField3D);
+}
+
+export const Resolution = {
+    /**
+     * Generate a 256×256 heightmap. Intended for small-scale scenes, or larger scenes with no distant particles.
+     */
+    RESOLUTION_256: 0,
+    /**
+     * Generate a 512×512 heightmap. Intended for medium-scale scenes, or larger scenes with no distant particles.
+     */
+    RESOLUTION_512: 1,
+    /**
+     * Generate a 1024×1024 heightmap. Intended for large scenes with distant particles.
+     */
+    RESOLUTION_1024: 2,
+    /**
+     * Generate a 2048×2048 heightmap. Intended for very large scenes with distant particles.
+     */
+    RESOLUTION_2048: 3,
+    /**
+     * Generate a 4096×4096 heightmap. Intended for huge scenes with distant particles.
+     */
+    RESOLUTION_4096: 4,
+    /**
+     * Generate a 8192×8192 heightmap. Intended for gigantic scenes with distant particles.
+     */
+    RESOLUTION_8192: 5,
+    /**
+     * Represents the size of the {@link Resolution} enum.
+     */
+    RESOLUTION_MAX: 6,
+} as const;
+
+export type Resolution = (typeof Resolution)[keyof typeof Resolution];
+
+export const UpdateMode = {
+    /**
+     * Only update the heightmap when the {@link GPUParticlesCollisionHeightField3D} node is moved, or when the camera moves if {@link followCameraEnabled} is `true`. An update can be forced by slightly moving the {@link GPUParticlesCollisionHeightField3D} in any direction, or by calling {@link RenderingServer.particlesCollisionHeightFieldUpdate}.
+     */
+    UPDATE_MODE_WHEN_MOVED: 0,
+    /**
+     * Update the heightmap every frame. This has a significant performance cost. This update should only be used when geometry that particles can collide with changes significantly during gameplay.
+     */
+    UPDATE_MODE_ALWAYS: 1,
+} as const;
+
+export type UpdateMode = (typeof UpdateMode)[keyof typeof UpdateMode];
+

package/gen/classes/GPUParticlesCollisionSDF3D.ts

@@ -0,0 +1,95 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GPUParticlesCollision3D } from './GPUParticlesCollision3D.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { Texture3D } from './Texture3D.ts';
+
+/**
+ * A baked signed distance field 3D particle collision shape affecting {@link GPUParticles3D} nodes.
+ * Signed distance fields (SDF) allow for efficiently representing approximate collision shapes for convex and concave objects of any shape. This is more flexible than {@link GPUParticlesCollisionHeightField3D}, but it requires a baking step.
+ * **Baking:** The signed distance field texture can be baked by selecting the {@link GPUParticlesCollisionSDF3D} node in the editor, then clicking **Bake SDF** at the top of the 3D viewport. Any *visible* {@link MeshInstance3D}s within the {@link size} will be taken into account for baking, regardless of their {@link GeometryInstance3D.giMode}.
+ * **Note:** Baking a {@link GPUParticlesCollisionSDF3D}'s {@link texture} is only possible within the editor, as there is no bake method exposed for use in exported projects. However, it's still possible to load pre-baked {@link Texture3D}s into its {@link texture} property in an exported project.
+ * **Note:** {@link ParticleProcessMaterial.collisionMode} must be {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT} on the {@link GPUParticles3D}'s process material for collision to work.
+ * **Note:** Particle collision only affects {@link GPUParticles3D}, not {@link CPUParticles3D}.
+ */
+export class GPUParticlesCollisionSDF3D extends GPUParticlesCollision3D {
+    constructor(name = 307) { super(name); }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link bakeMask}, given a `layerNumber` between 1 and 32.
+     */
+    setBakeMaskValue(layerNumber: number, value: boolean): void { _C(this, 10630, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link bakeMask} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getBakeMaskValue(layerNumber: number): boolean { return _C(this, 3876, layerNumber) as boolean; }
+
+    /**
+     * The collision SDF's size in 3D units. To improve SDF quality, the {@link size} should be set as small as possible while covering the parts of the scene you need.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    /**
+     * The bake resolution to use for the signed distance field {@link texture}. The texture must be baked again for changes to the {@link resolution} property to be effective. Higher resolutions have a greater performance cost and take more time to bake. Higher resolutions also result in larger baked textures, leading to increased VRAM and storage space requirements. To improve performance and reduce bake times, use the lowest resolution possible for the object you're representing the collision of.
+     */
+    get resolution(): Resolution { return _C(this, 6154) as Resolution; }
+    set resolution(v: Resolution) { _C(this, 12540, v); }
+
+    /**
+     * The collision shape's thickness. Unlike other particle colliders, {@link GPUParticlesCollisionSDF3D} is actually hollow on the inside. {@link thickness} can be increased to prevent particles from tunneling through the collision shape at high speeds, or when the {@link GPUParticlesCollisionSDF3D} is moved.
+     */
+    get thickness(): number { return _C(this, 6773) as number; }
+    set thickness(v: number) { _C(this, 13054, v); }
+
+    /**
+     * The visual layers to account for when baking the particle collision SDF. Only {@link MeshInstance3D}s whose {@link VisualInstance3D.layers} match with this {@link bakeMask} will be included in the generated particle collision SDF. By default, all objects are taken into account for the particle collision SDF baking.
+     */
+    get bakeMask(): number { return _C(this, 3875) as number; }
+    set bakeMask(v: number) { _C(this, 10629, v); }
+
+    /**
+     * The 3D texture representing the signed distance field.
+     */
+    get texture(): Texture3D { return _C(this, 6726) as Texture3D; }
+    set texture(v: Texture3D) { _C(this, 13024, v); }
+
+    static readonly name = _R(307, GPUParticlesCollisionSDF3D);
+}
+
+export const Resolution = {
+    /**
+     * Bake a 16×16×16 signed distance field. This is the fastest option, but also the least precise.
+     */
+    RESOLUTION_16: 0,
+    /**
+     * Bake a 32×32×32 signed distance field.
+     */
+    RESOLUTION_32: 1,
+    /**
+     * Bake a 64×64×64 signed distance field.
+     */
+    RESOLUTION_64: 2,
+    /**
+     * Bake a 128×128×128 signed distance field.
+     */
+    RESOLUTION_128: 3,
+    /**
+     * Bake a 256×256×256 signed distance field.
+     */
+    RESOLUTION_256: 4,
+    /**
+     * Bake a 512×512×512 signed distance field. This is the slowest option, but also the most precise.
+     */
+    RESOLUTION_512: 5,
+    /**
+     * Represents the size of the {@link Resolution} enum.
+     */
+    RESOLUTION_MAX: 6,
+} as const;
+
+export type Resolution = (typeof Resolution)[keyof typeof Resolution];
+

package/gen/classes/GPUParticlesCollisionSphere3D.ts

@@ -0,0 +1,23 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { GPUParticlesCollision3D } from './GPUParticlesCollision3D.ts';
+
+/**
+ * A sphere-shaped 3D particle collision shape affecting {@link GPUParticles3D} nodes.
+ * Particle collision shapes work in real-time and can be moved, rotated and scaled during gameplay. Unlike attractors, non-uniform scaling of collision shapes is *not* supported.
+ * **Note:** {@link ParticleProcessMaterial.collisionMode} must be {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT} on the {@link GPUParticles3D}'s process material for collision to work.
+ * **Note:** Particle collision only affects {@link GPUParticles3D}, not {@link CPUParticles3D}.
+ */
+export class GPUParticlesCollisionSphere3D extends GPUParticlesCollision3D {
+    constructor(name = 308) { super(name); }
+
+    /**
+     * The collision 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(308, GPUParticlesCollisionSphere3D);
+}

package/gen/classes/Generic6DOFJoint3D.ts

@@ -0,0 +1,146 @@
+// 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';
+
+/**
+ * The {@link Generic6DOFJoint3D} (6 Degrees Of Freedom) joint allows for implementing custom types of joints by locking the rotation and translation of certain axes.
+ * The first 3 DOF represent the linear motion of the physics bodies and the last 3 DOF represent the angular motion of the physics bodies. Each axis can be either locked, or limited.
+ */
+export class Generic6DOFJoint3D extends Joint3D {
+    constructor(name = 309) { super(name); }
+
+    setParamX(param: Param, value: number): void { _C(this, 12253, param, value); }
+
+    getParamX(param: Param): number { return _C(this, 5814, param) as number; }
+
+    setParamY(param: Param, value: number): void { _C(this, 12254, param, value); }
+
+    getParamY(param: Param): number { return _C(this, 5815, param) as number; }
+
+    setParamZ(param: Param, value: number): void { _C(this, 12255, param, value); }
+
+    getParamZ(param: Param): number { return _C(this, 5816, param) as number; }
+
+    setFlagX(flag: Flag, value: boolean): void { _C(this, 11409, flag, value); }
+
+    getFlagX(flag: Flag): boolean { return _C(this, 4804, flag) as boolean; }
+
+    setFlagY(flag: Flag, value: boolean): void { _C(this, 11410, flag, value); }
+
+    getFlagY(flag: Flag): boolean { return _C(this, 4805, flag) as boolean; }
+
+    setFlagZ(flag: Flag, value: boolean): void { _C(this, 11411, flag, value); }
+
+    getFlagZ(flag: Flag): boolean { return _C(this, 4806, flag) as boolean; }
+
+    static readonly name = _R(309, Generic6DOFJoint3D);
+}
+
+export const Param = {
+    /**
+     * The minimum difference between the pivot points' axes.
+     */
+    PARAM_LINEAR_LOWER_LIMIT: 0,
+    /**
+     * The maximum difference between the pivot points' axes.
+     */
+    PARAM_LINEAR_UPPER_LIMIT: 1,
+    /**
+     * A factor applied to the movement across the axes. The lower, the slower the movement.
+     */
+    PARAM_LINEAR_LIMIT_SOFTNESS: 2,
+    /**
+     * The amount of restitution on the axes' movement. The lower, the more momentum gets lost.
+     */
+    PARAM_LINEAR_RESTITUTION: 3,
+    /**
+     * The amount of damping that happens at the linear motion across the axes.
+     */
+    PARAM_LINEAR_DAMPING: 4,
+    /**
+     * The velocity the linear motor will try to reach.
+     */
+    PARAM_LINEAR_MOTOR_TARGET_VELOCITY: 5,
+    /**
+     * The maximum force the linear motor will apply while trying to reach the velocity target.
+     */
+    PARAM_LINEAR_MOTOR_FORCE_LIMIT: 6,
+    PARAM_LINEAR_SPRING_STIFFNESS: 7,
+    PARAM_LINEAR_SPRING_DAMPING: 8,
+    PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT: 9,
+    /**
+     * The minimum rotation in negative direction to break loose and rotate around the axes.
+     */
+    PARAM_ANGULAR_LOWER_LIMIT: 10,
+    /**
+     * The minimum rotation in positive direction to break loose and rotate around the axes.
+     */
+    PARAM_ANGULAR_UPPER_LIMIT: 11,
+    /**
+     * The speed of all rotations across the axes.
+     */
+    PARAM_ANGULAR_LIMIT_SOFTNESS: 12,
+    /**
+     * The amount of rotational damping across the axes. The lower, the more damping occurs.
+     */
+    PARAM_ANGULAR_DAMPING: 13,
+    /**
+     * The amount of rotational restitution across the axes. The lower, the more restitution occurs.
+     */
+    PARAM_ANGULAR_RESTITUTION: 14,
+    /**
+     * The maximum amount of force that can occur, when rotating around the axes.
+     */
+    PARAM_ANGULAR_FORCE_LIMIT: 15,
+    /**
+     * When rotating across the axes, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.
+     */
+    PARAM_ANGULAR_ERP: 16,
+    /**
+     * Target speed for the motor at the axes.
+     */
+    PARAM_ANGULAR_MOTOR_TARGET_VELOCITY: 17,
+    /**
+     * Maximum acceleration for the motor at the axes.
+     */
+    PARAM_ANGULAR_MOTOR_FORCE_LIMIT: 18,
+    PARAM_ANGULAR_SPRING_STIFFNESS: 19,
+    PARAM_ANGULAR_SPRING_DAMPING: 20,
+    PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT: 21,
+    /**
+     * Represents the size of the {@link Param} enum.
+     */
+    PARAM_MAX: 22,
+} as const;
+
+export type Param = (typeof Param)[keyof typeof Param];
+
+export const Flag = {
+    /**
+     * If enabled, linear motion is possible within the given limits.
+     */
+    FLAG_ENABLE_LINEAR_LIMIT: 0,
+    /**
+     * If enabled, rotational motion is possible within the given limits.
+     */
+    FLAG_ENABLE_ANGULAR_LIMIT: 1,
+    FLAG_ENABLE_LINEAR_SPRING: 3,
+    FLAG_ENABLE_ANGULAR_SPRING: 2,
+    /**
+     * If enabled, there is a rotational motor across these axes.
+     */
+    FLAG_ENABLE_MOTOR: 4,
+    /**
+     * If enabled, there is a linear motor across these axes.
+     */
+    FLAG_ENABLE_LINEAR_MOTOR: 5,
+    /**
+     * Represents the size of the {@link Flag} enum.
+     */
+    FLAG_MAX: 6,
+} as const;
+
+export type Flag = (typeof Flag)[keyof typeof Flag];
+