@ringozz/godot 0.1.0

package/gen/classes/CPUParticles3D.ts

@@ -0,0 +1,650 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { GeometryInstance3D } from './GeometryInstance3D.ts';
+import type { PackedColorArray, PackedVector3Array, Signal } from '../heap-types/index.ts';
+import type { AABB, Color, Vector3 } from '../value-types/index.ts';
+import type { Curve } from './Curve.ts';
+import type { Gradient } from './Gradient.ts';
+import type { Mesh } from './Mesh.ts';
+import type { Node } from './Node.ts';
+
+/**
+ * CPU-based 3D particle node used to create a variety of particle systems and effects.
+ * See also {@link GPUParticles3D}, which provides the same functionality with hardware acceleration, but may not run on older devices.
+ */
+export class CPUParticles3D extends GeometryInstance3D {
+    constructor(name = 163) { super(name); }
+
+    /**
+     * Restarts the particle emitter.
+     * If `keepSeed` is `true`, the current random seed will be preserved. Useful for seeking and playback.
+     */
+    restart(keepSeed?: boolean /* = false */): void { _C(this, 10098, keepSeed); }
+
+    /**
+     * Requests the particles to process for extra process time during a single frame.
+     * `processTime` defines the time that the particles will process while emitting is on. `processTimeResidual` defines the time that particles will process with emitting turned off for the simulation. When combined with {@link speedScale} set to `0.0`, this is useful to be able to seek a particle system timeline.
+     */
+    requestParticlesProcess(processTime: number, processTimeResidual?: number /* = 0.0 */): void { _C(this, 10055, processTime, processTimeResidual); }
+
+    /**
+     * Returns the axis-aligned bounding box that contains all the particles that are active in the current frame.
+     */
+    captureAabb(): AABB { return _C(this, 2136) as AABB; }
+
+    /**
+     * Sets this node's properties to match a given {@link GPUParticles3D} node with an assigned {@link ParticleProcessMaterial}.
+     */
+    convertFromParticles(particles: Node): void { _C(this, 2479, particles); }
+
+    /**
+     * If `true`, particles are being emitted. {@link emitting} can be used to start and stop particles from emitting. However, if {@link oneShot} is `true` setting {@link emitting} to `true` will not restart the emission cycle until after all active particles finish processing. You can use the {@link finished} signal to be notified once all active particles finish processing.
+     */
+    get emitting(): boolean { return _C(this, 7929) as boolean; }
+    set emitting(v: boolean) { _C(this, 11256, v); }
+
+    /**
+     * Number of particles emitted in one emission cycle.
+     */
+    get amount(): number { return _C(this, 3741) as number; }
+    set amount(v: number) { _C(this, 10482, v); }
+
+    /**
+     * Amount of time each particle will exist.
+     */
+    get lifetime(): number { return _C(this, 5335) as number; }
+    set lifetime(v: number) { _C(this, 11892, v); }
+
+    /**
+     * If `true`, only one emission cycle occurs. If set `true` during a cycle, emission will stop at the cycle's end.
+     */
+    get oneShot(): boolean { return _C(this, 5718) as boolean; }
+    set oneShot(v: boolean) { _C(this, 12185, v); }
+
+    /**
+     * Particle system starts as if it had already run for this many seconds.
+     */
+    get preprocess(): number { return _C(this, 5984) as number; }
+    set preprocess(v: number) { _C(this, 12392, v); }
+
+    /**
+     * Particle system's running speed scaling ratio. A value of `0` can be used to pause the particles.
+     */
+    get speedScale(): number { return _C(this, 6495) as number; }
+    set speedScale(v: number) { _C(this, 12839, v); }
+
+    /**
+     * How rapidly particles in an emission cycle are emitted. If greater than `0`, there will be a gap in emissions before the next cycle begins.
+     */
+    get explosiveness(): number { return _C(this, 4708) as number; }
+    set explosiveness(v: number) { _C(this, 11328, v); }
+
+    /**
+     * Emission lifetime randomness ratio.
+     */
+    get randomness(): number { return _C(this, 6073) as number; }
+    set randomness(v: number) { _C(this, 12472, v); }
+
+    /**
+     * If `true`, particles will use the same seed for every simulation using the seed defined in {@link seed}. This is useful for situations where the visual outcome should be consistent across replays, for example when using Movie Maker mode.
+     */
+    get useFixedSeed(): boolean { return _C(this, 6977) as boolean; }
+    set useFixedSeed(v: boolean) { _C(this, 13215, v); }
+
+    /**
+     * Sets the random seed used by the particle system. Only effective if {@link useFixedSeed} is `true`.
+     */
+    get seed(): number { return _C(this, 6317) as number; }
+    set seed(v: number) { _C(this, 12682, v); }
+
+    /**
+     * Particle lifetime randomness ratio.
+     */
+    get lifetimeRandomness(): number { return _C(this, 5336) as number; }
+    set lifetimeRandomness(v: number) { _C(this, 11893, v); }
+
+    /**
+     * The particle system's frame rate is fixed to a value. For example, changing the value to 2 will make the particles render at 2 frames per second. Note this does not slow down the particle system itself.
+     */
+    get fixedFps(): number { return _C(this, 4799) as number; }
+    set fixedFps(v: number) { _C(this, 11404, v); }
+
+    /**
+     * If `true`, results in fractional delta calculation which has a smoother particles display effect.
+     */
+    get fractDelta(): boolean { return _C(this, 4877) as boolean; }
+    set fractDelta(v: boolean) { _C(this, 11479, v); }
+
+    /**
+     * The {@link AABB} that determines the node's region which needs to be visible on screen for the particle system to be active.
+     * Grow the box if particles suddenly appear/disappear when the node enters/exits the screen. The {@link AABB} can be grown via code or with the **Particles → Generate AABB** editor tool.
+     */
+    get visibilityAabb(): AABB { return _C(this, 7089) as AABB; }
+    set visibilityAabb(v: AABB) { _C(this, 13317, v); }
+
+    /**
+     * If `true`, particles use the parent node's coordinate space (known as local coordinates). This will cause particles to move and rotate along the {@link CPUParticles3D} node (and its parents) when it is moved or rotated. If `false`, particles use global coordinates; they will not move or rotate along the {@link CPUParticles3D} node (and its parents) when it is moved or rotated.
+     */
+    get localCoords(): boolean { return _C(this, 6981) as boolean; }
+    set localCoords(v: boolean) { _C(this, 13224, v); }
+
+    /**
+     * Particle draw order.
+     */
+    get drawOrder(): DrawOrder { return _C(this, 4568) as DrawOrder; }
+    set drawOrder(v: DrawOrder) { _C(this, 11193, v); }
+
+    /**
+     * The {@link Mesh} used for each particle. If `null`, particles will be spheres.
+     */
+    get mesh(): Mesh { return _C(this, 5511) as Mesh; }
+    set mesh(v: Mesh) { _C(this, 12024, v); }
+
+    /**
+     * Particles will be emitted inside this region.
+     */
+    get emissionShape(): EmissionShape { return _C(this, 4635) as EmissionShape; }
+    set emissionShape(v: EmissionShape) { _C(this, 11252, v); }
+
+    /**
+     * The sphere's radius if {@link EmissionShape} is set to {@link EMISSION_SHAPE_SPHERE}.
+     */
+    get emissionSphereRadius(): number { return _C(this, 4638) as number; }
+    set emissionSphereRadius(v: number) { _C(this, 11255, v); }
+
+    /**
+     * The rectangle's extents if {@link emissionShape} is set to {@link EMISSION_SHAPE_BOX}.
+     */
+    get emissionBoxExtents(): Vector3 { return _C(this, 4616) as Vector3; }
+    set emissionBoxExtents(v: Vector3) { _C(this, 11233, v); }
+
+    /**
+     * Sets the initial positions to spawn particles when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
+     */
+    get emissionPoints(): PackedVector3Array { return _C(this, 4628) as PackedVector3Array; }
+    set emissionPoints(v: PackedVector3Array) { _C(this, 11245, v); }
+
+    /**
+     * Sets the direction the particles will be emitted in when using {@link EMISSION_SHAPE_DIRECTED_POINTS}.
+     */
+    get emissionNormals(): PackedVector3Array { return _C(this, 4624) as PackedVector3Array; }
+    set emissionNormals(v: PackedVector3Array) { _C(this, 11241, v); }
+
+    /**
+     * Sets the {@link Color}s to modulate particles by when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
+     * **Note:** {@link emissionColors} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertexColorUseAsAlbedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link emissionColors} will have no visible effect.
+     */
+    get emissionColors(): PackedColorArray { return _C(this, 4618) as PackedColorArray; }
+    set emissionColors(v: PackedColorArray) { _C(this, 11235, v); }
+
+    /**
+     * The axis of the ring when using the emitter {@link EMISSION_SHAPE_RING}.
+     */
+    get emissionRingAxis(): Vector3 { return _C(this, 4630) as Vector3; }
+    set emissionRingAxis(v: Vector3) { _C(this, 11247, v); }
+
+    /**
+     * The height of the ring when using the emitter {@link EMISSION_SHAPE_RING}.
+     */
+    get emissionRingHeight(): number { return _C(this, 4632) as number; }
+    set emissionRingHeight(v: number) { _C(this, 11249, v); }
+
+    /**
+     * The radius of the ring when using the emitter {@link EMISSION_SHAPE_RING}.
+     */
+    get emissionRingRadius(): number { return _C(this, 4634) as number; }
+    set emissionRingRadius(v: number) { _C(this, 11251, v); }
+
+    /**
+     * The inner radius of the ring when using the emitter {@link EMISSION_SHAPE_RING}.
+     */
+    get emissionRingInnerRadius(): number { return _C(this, 4633) as number; }
+    set emissionRingInnerRadius(v: number) { _C(this, 11250, v); }
+
+    /**
+     * The angle of the cone when using the emitter {@link EMISSION_SHAPE_RING}. The default angle of 90 degrees results in a ring, while an angle of 0 degrees results in a cone. Intermediate values will result in a ring where one end is larger than the other.
+     * **Note:** Depending on {@link emissionRingHeight}, the angle may be clamped if the ring's end is reached to form a perfect cone.
+     */
+    get emissionRingConeAngle(): number { return _C(this, 4631) as number; }
+    set emissionRingConeAngle(v: number) { _C(this, 11248, v); }
+
+    /**
+     * Align Y axis of particle with the direction of its velocity.
+     */
+    get particleFlagAlignY(): boolean { return _C(this, 5832, 0) as boolean; }
+    set particleFlagAlignY(v: boolean) { _C(this, 12263, 0, v); }
+
+    /**
+     * If `true`, particles rotate around Y axis by {@link angleMin}.
+     */
+    get particleFlagRotateY(): boolean { return _C(this, 5832, 1) as boolean; }
+    set particleFlagRotateY(v: boolean) { _C(this, 12263, 1, v); }
+
+    /**
+     * If `true`, particles will not move on the Z axis.
+     */
+    get particleFlagDisableZ(): boolean { return _C(this, 5832, 2) as boolean; }
+    set particleFlagDisableZ(v: boolean) { _C(this, 12263, 2, v); }
+
+    /**
+     * Unit vector specifying the particles' emission direction.
+     */
+    get direction(): Vector3 { return _C(this, 4506) as Vector3; }
+    set direction(v: Vector3) { _C(this, 11112, v); }
+
+    /**
+     * Each particle's initial direction range from `+spread` to `-spread` degrees. Applied to X/Z plane and Y/Z planes.
+     */
+    get spread(): number { return _C(this, 6502) as number; }
+    set spread(v: number) { _C(this, 12845, v); }
+
+    /**
+     * Amount of {@link spread} in Y/Z plane. A value of `1` restricts particles to X/Z plane.
+     */
+    get flatness(): number { return _C(this, 4808) as number; }
+    set flatness(v: number) { _C(this, 11414, v); }
+
+    /**
+     * Gravity applied to every particle.
+     */
+    get gravity(): Vector3 { return _C(this, 4971) as Vector3; }
+    set gravity(v: Vector3) { _C(this, 11553, v); }
+
+    /**
+     * Minimum value of the initial velocity.
+     */
+    get initialVelocityMin(): number { return _C(this, 5812, 0) as number; }
+    set initialVelocityMin(v: number) { _C(this, 12251, 0, v); }
+
+    /**
+     * Maximum value of the initial velocity.
+     */
+    get initialVelocityMax(): number { return _C(this, 5811, 0) as number; }
+    set initialVelocityMax(v: number) { _C(this, 12250, 0, v); }
+
+    /**
+     * Minimum initial angular velocity (rotation speed) applied to each particle in *degrees* per second.
+     */
+    get angularVelocityMin(): number { return _C(this, 5812, 1) as number; }
+    set angularVelocityMin(v: number) { _C(this, 12251, 1, v); }
+
+    /**
+     * Maximum initial angular velocity (rotation speed) applied to each particle in *degrees* per second.
+     */
+    get angularVelocityMax(): number { return _C(this, 5811, 1) as number; }
+    set angularVelocityMax(v: number) { _C(this, 12250, 1, v); }
+
+    /**
+     * Each particle's angular velocity (rotation speed) will vary along this {@link Curve} over its lifetime. Should be a unit {@link Curve}.
+     */
+    get angularVelocityCurve(): Curve { return _C(this, 5810, 1) as Curve; }
+    set angularVelocityCurve(v: Curve) { _C(this, 12249, 1, v); }
+
+    /**
+     * Minimum orbit velocity.
+     */
+    get orbitVelocityMin(): number { return _C(this, 5812, 2) as number; }
+    set orbitVelocityMin(v: number) { _C(this, 12251, 2, v); }
+
+    /**
+     * Maximum orbit velocity.
+     */
+    get orbitVelocityMax(): number { return _C(this, 5811, 2) as number; }
+    set orbitVelocityMax(v: number) { _C(this, 12250, 2, v); }
+
+    /**
+     * Each particle's orbital velocity will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get orbitVelocityCurve(): Curve { return _C(this, 5810, 2) as Curve; }
+    set orbitVelocityCurve(v: Curve) { _C(this, 12249, 2, v); }
+
+    /**
+     * Minimum linear acceleration.
+     */
+    get linearAccelMin(): number { return _C(this, 5812, 3) as number; }
+    set linearAccelMin(v: number) { _C(this, 12251, 3, v); }
+
+    /**
+     * Maximum linear acceleration.
+     */
+    get linearAccelMax(): number { return _C(this, 5811, 3) as number; }
+    set linearAccelMax(v: number) { _C(this, 12250, 3, v); }
+
+    /**
+     * Each particle's linear acceleration will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get linearAccelCurve(): Curve { return _C(this, 5810, 3) as Curve; }
+    set linearAccelCurve(v: Curve) { _C(this, 12249, 3, v); }
+
+    /**
+     * Minimum radial acceleration.
+     */
+    get radialAccelMin(): number { return _C(this, 5812, 4) as number; }
+    set radialAccelMin(v: number) { _C(this, 12251, 4, v); }
+
+    /**
+     * Maximum radial acceleration.
+     */
+    get radialAccelMax(): number { return _C(this, 5811, 4) as number; }
+    set radialAccelMax(v: number) { _C(this, 12250, 4, v); }
+
+    /**
+     * Each particle's radial acceleration will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get radialAccelCurve(): Curve { return _C(this, 5810, 4) as Curve; }
+    set radialAccelCurve(v: Curve) { _C(this, 12249, 4, v); }
+
+    /**
+     * Minimum tangent acceleration.
+     */
+    get tangentialAccelMin(): number { return _C(this, 5812, 5) as number; }
+    set tangentialAccelMin(v: number) { _C(this, 12251, 5, v); }
+
+    /**
+     * Maximum tangent acceleration.
+     */
+    get tangentialAccelMax(): number { return _C(this, 5811, 5) as number; }
+    set tangentialAccelMax(v: number) { _C(this, 12250, 5, v); }
+
+    /**
+     * Each particle's tangential acceleration will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get tangentialAccelCurve(): Curve { return _C(this, 5810, 5) as Curve; }
+    set tangentialAccelCurve(v: Curve) { _C(this, 12249, 5, v); }
+
+    /**
+     * Minimum damping.
+     */
+    get dampingMin(): number { return _C(this, 5812, 6) as number; }
+    set dampingMin(v: number) { _C(this, 12251, 6, v); }
+
+    /**
+     * Maximum damping.
+     */
+    get dampingMax(): number { return _C(this, 5811, 6) as number; }
+    set dampingMax(v: number) { _C(this, 12250, 6, v); }
+
+    /**
+     * Damping will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get dampingCurve(): Curve { return _C(this, 5810, 6) as Curve; }
+    set dampingCurve(v: Curve) { _C(this, 12249, 6, v); }
+
+    /**
+     * Minimum angle.
+     */
+    get angleMin(): number { return _C(this, 5812, 7) as number; }
+    set angleMin(v: number) { _C(this, 12251, 7, v); }
+
+    /**
+     * Maximum angle.
+     */
+    get angleMax(): number { return _C(this, 5811, 7) as number; }
+    set angleMax(v: number) { _C(this, 12250, 7, v); }
+
+    /**
+     * Each particle's rotation will be animated along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get angleCurve(): Curve { return _C(this, 5810, 7) as Curve; }
+    set angleCurve(v: Curve) { _C(this, 12249, 7, v); }
+
+    /**
+     * Minimum scale.
+     */
+    get scaleAmountMin(): number { return _C(this, 5812, 8) as number; }
+    set scaleAmountMin(v: number) { _C(this, 12251, 8, v); }
+
+    /**
+     * Maximum scale.
+     */
+    get scaleAmountMax(): number { return _C(this, 5811, 8) as number; }
+    set scaleAmountMax(v: number) { _C(this, 12250, 8, v); }
+
+    /**
+     * Each particle's scale will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get scaleAmountCurve(): Curve { return _C(this, 5810, 8) as Curve; }
+    set scaleAmountCurve(v: Curve) { _C(this, 12249, 8, v); }
+
+    /**
+     * If set to `true`, three different scale curves can be specified, one per scale axis.
+     */
+    get splitScale(): boolean { return _C(this, 6501) as boolean; }
+    set splitScale(v: boolean) { _C(this, 12844, v); }
+
+    /**
+     * Curve for the scale over life, along the x axis.
+     */
+    get scaleCurveX(): Curve { return _C(this, 6240) as Curve; }
+    set scaleCurveX(v: Curve) { _C(this, 12612, v); }
+
+    /**
+     * Curve for the scale over life, along the y axis.
+     */
+    get scaleCurveY(): Curve { return _C(this, 6241) as Curve; }
+    set scaleCurveY(v: Curve) { _C(this, 12613, v); }
+
+    /**
+     * Curve for the scale over life, along the z axis.
+     */
+    get scaleCurveZ(): Curve { return _C(this, 6242) as Curve; }
+    set scaleCurveZ(v: Curve) { _C(this, 12614, v); }
+
+    /**
+     * Each particle's initial color.
+     * **Note:** {@link color} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertexColorUseAsAlbedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link color} will have no visible effect.
+     */
+    get color(): Color { return _C(this, 4219) as Color; }
+    set color(v: Color) { _C(this, 10905, v); }
+
+    /**
+     * Each particle's color will vary along this {@link Gradient} over its lifetime (multiplied with {@link color}).
+     * **Note:** {@link colorRamp} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertexColorUseAsAlbedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link colorRamp} will have no visible effect.
+     */
+    get colorRamp(): Gradient { return _C(this, 4228) as Gradient; }
+    set colorRamp(v: Gradient) { _C(this, 10912, v); }
+
+    /**
+     * Each particle's initial color will vary along this {@link Gradient} (multiplied with {@link color}).
+     * **Note:** {@link colorInitialRamp} multiplies the particle mesh's vertex colors. To have a visible effect on a {@link BaseMaterial3D}, {@link BaseMaterial3D.vertexColorUseAsAlbedo} *must* be `true`. For a {@link ShaderMaterial}, `ALBEDO *= COLOR.rgb;` must be inserted in the shader's `fragment()` function. Otherwise, {@link colorInitialRamp} will have no visible effect.
+     */
+    get colorInitialRamp(): Gradient { return _C(this, 4223) as Gradient; }
+    set colorInitialRamp(v: Gradient) { _C(this, 10909, v); }
+
+    /**
+     * Minimum hue variation.
+     */
+    get hueVariationMin(): number { return _C(this, 5812, 9) as number; }
+    set hueVariationMin(v: number) { _C(this, 12251, 9, v); }
+
+    /**
+     * Maximum hue variation.
+     */
+    get hueVariationMax(): number { return _C(this, 5811, 9) as number; }
+    set hueVariationMax(v: number) { _C(this, 12250, 9, v); }
+
+    /**
+     * Each particle's hue will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get hueVariationCurve(): Curve { return _C(this, 5810, 9) as Curve; }
+    set hueVariationCurve(v: Curve) { _C(this, 12249, 9, v); }
+
+    /**
+     * Minimum particle animation speed.
+     */
+    get animSpeedMin(): number { return _C(this, 5812, 10) as number; }
+    set animSpeedMin(v: number) { _C(this, 12251, 10, v); }
+
+    /**
+     * Maximum particle animation speed.
+     */
+    get animSpeedMax(): number { return _C(this, 5811, 10) as number; }
+    set animSpeedMax(v: number) { _C(this, 12250, 10, v); }
+
+    /**
+     * Each particle's animation speed will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get animSpeedCurve(): Curve { return _C(this, 5810, 10) as Curve; }
+    set animSpeedCurve(v: Curve) { _C(this, 12249, 10, v); }
+
+    /**
+     * Minimum animation offset.
+     */
+    get animOffsetMin(): number { return _C(this, 5812, 11) as number; }
+    set animOffsetMin(v: number) { _C(this, 12251, 11, v); }
+
+    /**
+     * Maximum animation offset.
+     */
+    get animOffsetMax(): number { return _C(this, 5811, 11) as number; }
+    set animOffsetMax(v: number) { _C(this, 12250, 11, v); }
+
+    /**
+     * Each particle's animation offset will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     */
+    get animOffsetCurve(): Curve { return _C(this, 5810, 11) as Curve; }
+    set animOffsetCurve(v: Curve) { _C(this, 12249, 11, v); }
+
+    /**
+     * Emitted when all active particles have finished processing. When {@link oneShot} is disabled, particles will process continuously, so this is never emitted.
+     */
+    get finished(): Signal<() => void> { return _G(this, 3310) as Signal<() => void>; }
+    set finished(v: (() => void) | null) { _G(this, 3310, v); }
+
+    static readonly name = _R(163, CPUParticles3D);
+}
+
+export const DrawOrder = {
+    /**
+     * Particles are drawn in the order emitted.
+     */
+    DRAW_ORDER_INDEX: 0,
+    /**
+     * Particles are drawn in order of remaining lifetime. In other words, the particle with the highest lifetime is drawn at the front.
+     */
+    DRAW_ORDER_LIFETIME: 1,
+    /**
+     * Particles are drawn in order of depth.
+     */
+    DRAW_ORDER_VIEW_DEPTH: 2,
+} as const;
+
+export type DrawOrder = (typeof DrawOrder)[keyof typeof DrawOrder];
+
+export const Parameter = {
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set initial velocity properties.
+     */
+    PARAM_INITIAL_LINEAR_VELOCITY: 0,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set angular velocity properties.
+     */
+    PARAM_ANGULAR_VELOCITY: 1,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set orbital velocity properties.
+     */
+    PARAM_ORBIT_VELOCITY: 2,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set linear acceleration properties.
+     */
+    PARAM_LINEAR_ACCEL: 3,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set radial acceleration properties.
+     */
+    PARAM_RADIAL_ACCEL: 4,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set tangential acceleration properties.
+     */
+    PARAM_TANGENTIAL_ACCEL: 5,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set damping properties.
+     */
+    PARAM_DAMPING: 6,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set angle properties.
+     */
+    PARAM_ANGLE: 7,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set scale properties.
+     */
+    PARAM_SCALE: 8,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set hue variation properties.
+     */
+    PARAM_HUE_VARIATION: 9,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set animation speed properties.
+     */
+    PARAM_ANIM_SPEED: 10,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamCurve} to set animation offset properties.
+     */
+    PARAM_ANIM_OFFSET: 11,
+    /**
+     * Represents the size of the {@link Parameter} enum.
+     */
+    PARAM_MAX: 12,
+} as const;
+
+export type Parameter = (typeof Parameter)[keyof typeof Parameter];
+
+export const ParticleFlags = {
+    /**
+     * Use with {@link setParticleFlag} to set {@link particleFlagAlignY}.
+     */
+    PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY: 0,
+    /**
+     * Use with {@link setParticleFlag} to set {@link particleFlagRotateY}.
+     */
+    PARTICLE_FLAG_ROTATE_Y: 1,
+    /**
+     * Use with {@link setParticleFlag} to set {@link particleFlagDisableZ}.
+     */
+    PARTICLE_FLAG_DISABLE_Z: 2,
+    /**
+     * Represents the size of the {@link ParticleFlags} enum.
+     */
+    PARTICLE_FLAG_MAX: 3,
+} as const;
+
+export type ParticleFlags = (typeof ParticleFlags)[keyof typeof ParticleFlags];
+
+export const EmissionShape = {
+    /**
+     * All particles will be emitted from a single point.
+     */
+    EMISSION_SHAPE_POINT: 0,
+    /**
+     * Particles will be emitted in the volume of a sphere.
+     */
+    EMISSION_SHAPE_SPHERE: 1,
+    /**
+     * Particles will be emitted on the surface of a sphere.
+     */
+    EMISSION_SHAPE_SPHERE_SURFACE: 2,
+    /**
+     * Particles will be emitted in the volume of a box.
+     */
+    EMISSION_SHAPE_BOX: 3,
+    /**
+     * Particles will be emitted at a position chosen randomly among {@link emissionPoints}. Particle color will be modulated by {@link emissionColors}.
+     */
+    EMISSION_SHAPE_POINTS: 4,
+    /**
+     * Particles will be emitted at a position chosen randomly among {@link emissionPoints}. Particle velocity and rotation will be set based on {@link emissionNormals}. Particle color will be modulated by {@link emissionColors}.
+     */
+    EMISSION_SHAPE_DIRECTED_POINTS: 5,
+    /**
+     * Particles will be emitted in a ring or cylinder.
+     */
+    EMISSION_SHAPE_RING: 6,
+    /**
+     * Represents the size of the {@link EmissionShape} enum.
+     */
+    EMISSION_SHAPE_MAX: 7,
+} as const;
+
+export type EmissionShape = (typeof EmissionShape)[keyof typeof EmissionShape];
+

package/gen/classes/CSGBox3D.ts

@@ -0,0 +1,29 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CSGPrimitive3D } from './CSGPrimitive3D.ts';
+import type { Vector3 } from '../value-types/index.ts';
+import type { Material } from './Material.ts';
+
+/**
+ * This node allows you to create a box for use with the CSG system.
+ * **Note:** CSG nodes are intended to be used for level prototyping. Creating CSG nodes has a significant CPU cost compared to creating a {@link MeshInstance3D} with a {@link PrimitiveMesh}. Moving a CSG node within another CSG node also has a significant CPU cost, so it should be avoided during gameplay.
+ */
+export class CSGBox3D extends CSGPrimitive3D {
+    constructor(name = 164) { super(name); }
+
+    /**
+     * The box's width, height and depth.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    /**
+     * The material used to render the box.
+     */
+    get material(): Material { return _C(this, 5452) as Material; }
+    set material(v: Material) { _C(this, 11978, v); }
+
+    static readonly name = _R(164, CSGBox3D);
+}

package/gen/classes/CSGCombiner3D.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CSGShape3D } from './CSGShape3D.ts';
+
+/**
+ * For complex arrangements of shapes, it is sometimes needed to add structure to your CSG nodes. The CSGCombiner3D node allows you to create this structure. The node encapsulates the result of the CSG operations of its children. In this way, it is possible to do operations on one set of shapes that are children of one CSGCombiner3D node, and a set of separate operations on a second set of shapes that are children of a second CSGCombiner3D node, and then do an operation that takes the two end results as its input to create the final shape.
+ * **Note:** CSG nodes are intended to be used for level prototyping. Creating CSG nodes has a significant CPU cost compared to creating a {@link MeshInstance3D} with a {@link PrimitiveMesh}. Moving a CSG node within another CSG node also has a significant CPU cost, so it should be avoided during gameplay.
+ */
+export class CSGCombiner3D extends CSGShape3D {
+    constructor(name = 165) { super(name); }
+
+    static readonly name = _R(165, CSGCombiner3D);
+}