@ringozz/godot 0.1.0

package/gen/classes/ParticleProcessMaterial.ts

@@ -0,0 +1,949 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Material } from './Material.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Color, Vector2, Vector3 } from '../value-types/index.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * {@link ParticleProcessMaterial} defines particle properties and behavior. It is used in the `process_material` of the {@link GPUParticles2D} and {@link GPUParticles3D} nodes. Some of this material's properties are applied to each particle when emitted, while others can have a {@link CurveTexture} or a {@link GradientTexture1D} applied to vary numerical or color values over the lifetime of the particle.
+ */
+export class ParticleProcessMaterial extends Material {
+    constructor(name = 549) { super(name); }
+
+    /**
+     * Particle lifetime randomness ratio. The equation for the lifetime of a particle is `lifetime * (1.0 - randf() * lifetime_randomness)`. For example, a {@link lifetimeRandomness} of `0.4` scales the lifetime between `0.6` to `1.0` of its original value.
+     */
+    get lifetimeRandomness(): number { return _C(this, 5336) as number; }
+    set lifetimeRandomness(v: number) { _C(this, 11893, 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); }
+
+    /**
+     * Changes the behavior of the damping properties from a linear deceleration to a deceleration based on speed percentage.
+     */
+    get particleFlagDampingAsFriction(): boolean { return _C(this, 5832, 3) as boolean; }
+    set particleFlagDampingAsFriction(v: boolean) { _C(this, 12263, 3, v); }
+
+    /**
+     * If `true`, particles will inherit the scale of the emitter.
+     * **Note:** This has no effect when {@link GPUParticles3D.localCoords} is `true`, since particles in local space are already affected by the emitter's scale.
+     */
+    get particleFlagInheritEmitterScale(): boolean { return _C(this, 5832, 4) as boolean; }
+    set particleFlagInheritEmitterScale(v: boolean) { _C(this, 12263, 4, v); }
+
+    /**
+     * The offset for the {@link emissionShape}, in local space.
+     */
+    get emissionShapeOffset(): Vector3 { return _C(this, 4636) as Vector3; }
+    set emissionShapeOffset(v: Vector3) { _C(this, 11253, v); }
+
+    /**
+     * The scale of the {@link emissionShape}, in local space.
+     */
+    get emissionShapeScale(): Vector3 { return _C(this, 4637) as Vector3; }
+    set emissionShapeScale(v: Vector3) { _C(this, 11254, 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 box's extents if {@link emissionShape} is set to {@link EMISSION_SHAPE_BOX}.
+     * **Note:** {@link emissionBoxExtents} starts from the center point and applies the X, Y, and Z values in both directions. The size is twice the area of the extents.
+     */
+    get emissionBoxExtents(): Vector3 { return _C(this, 4616) as Vector3; }
+    set emissionBoxExtents(v: Vector3) { _C(this, 11233, v); }
+
+    /**
+     * Particles will be emitted at positions determined by sampling this texture at a random position. Used with {@link EMISSION_SHAPE_POINTS} and {@link EMISSION_SHAPE_DIRECTED_POINTS}. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar.
+     */
+    get emissionPointTexture(): Texture2D { return _C(this, 4627) as Texture2D; }
+    set emissionPointTexture(v: Texture2D) { _C(this, 11244, v); }
+
+    /**
+     * Particle velocity and rotation will be set by sampling this texture at the same point as the {@link emissionPointTexture}. Used only in {@link EMISSION_SHAPE_DIRECTED_POINTS}. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar.
+     */
+    get emissionNormalTexture(): Texture2D { return _C(this, 4623) as Texture2D; }
+    set emissionNormalTexture(v: Texture2D) { _C(this, 11240, v); }
+
+    /**
+     * Particle color will be modulated by color determined by sampling this texture at the same point as the {@link emissionPointTexture}.
+     * **Note:** {@link emissionColorTexture} 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 emissionColorTexture} will have no visible effect.
+     */
+    get emissionColorTexture(): Texture2D { return _C(this, 4617) as Texture2D; }
+    set emissionColorTexture(v: Texture2D) { _C(this, 11234, v); }
+
+    /**
+     * The number of emission points if {@link emissionShape} is set to {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
+     */
+    get emissionPointCount(): number { return _C(this, 4626) as number; }
+    set emissionPointCount(v: number) { _C(this, 11243, 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); }
+
+    get angle(): Vector2 { return _C(this, 5809, 7) as Vector2; }
+    set angle(v: Vector2) { _C(this, 12248, 7, v); }
+
+    /**
+     * Minimum equivalent of {@link angleMax}.
+     */
+    get angleMin(): number { return _C(this, 5812, 7) as number; }
+    set angleMin(v: number) { _C(this, 12251, 7, v); }
+
+    /**
+     * Maximum initial rotation applied to each particle, in degrees.
+     * Only applied when {@link particleFlagDisableZ} or {@link particleFlagRotateY} are `true` or the {@link BaseMaterial3D} being used to draw the particle is using {@link BaseMaterial3D.BILLBOARD_PARTICLES}.
+     */
+    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 CurveTexture}.
+     */
+    get angleCurve(): Texture2D { return _C(this, 5813, 7) as Texture2D; }
+    set angleCurve(v: Texture2D) { _C(this, 12252, 7, v); }
+
+    /**
+     * Enable the usage of {@link rotation3dMin} and {@link rotation3dMax}.
+     */
+    get useRotation3d(): boolean { return _C(this, 8416) as boolean; }
+    set useRotation3d(v: boolean) { _C(this, 13235, v); }
+
+    /**
+     * The minimum 3D orientation, in degrees. Works only in 3D and if {@link useRotation3d} is enabled.
+     */
+    get rotation3dMin(): Vector3 { return _C(this, 6206) as Vector3; }
+    set rotation3dMin(v: Vector3) { _C(this, 12579, v); }
+
+    /**
+     * The maximum 3D orientation, in degrees. Works only in 3D and if {@link useRotation3d} is enabled.
+     */
+    get rotation3dMax(): Vector3 { return _C(this, 6205) as Vector3; }
+    set rotation3dMax(v: Vector3) { _C(this, 12578, v); }
+
+    /**
+     * Percentage of the velocity of the respective {@link GPUParticles2D} or {@link GPUParticles3D} inherited by each particle when spawning.
+     */
+    get inheritVelocityRatio(): number { return _C(this, 5098) as number; }
+    set inheritVelocityRatio(v: number) { _C(this, 11699, v); }
+
+    /**
+     * A pivot point used to calculate radial and orbital velocity of particles.
+     */
+    get velocityPivot(): Vector3 { return _C(this, 7039) as Vector3; }
+    set velocityPivot(v: Vector3) { _C(this, 13283, 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.
+     */
+    get spread(): number { return _C(this, 6502) as number; }
+    set spread(v: number) { _C(this, 12845, v); }
+
+    /**
+     * Amount of {@link spread} along the Y axis.
+     */
+    get flatness(): number { return _C(this, 4808) as number; }
+    set flatness(v: number) { _C(this, 11414, v); }
+
+    get initialVelocity(): Vector2 { return _C(this, 5809, 0) as Vector2; }
+    set initialVelocity(v: Vector2) { _C(this, 12248, 0, v); }
+
+    /**
+     * Minimum equivalent of {@link initialVelocityMax}.
+     */
+    get initialVelocityMin(): number { return _C(this, 5812, 0) as number; }
+    set initialVelocityMin(v: number) { _C(this, 12251, 0, v); }
+
+    /**
+     * Maximum initial velocity magnitude for each particle. Direction comes from {@link direction} and {@link spread}.
+     */
+    get initialVelocityMax(): number { return _C(this, 5811, 0) as number; }
+    set initialVelocityMax(v: number) { _C(this, 12250, 0, v); }
+
+    get angularVelocity(): Vector2 { return _C(this, 5809, 1) as Vector2; }
+    set angularVelocity(v: Vector2) { _C(this, 12248, 1, v); }
+
+    /**
+     * Minimum equivalent of {@link angularVelocityMax}.
+     */
+    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.
+     * Only applied when {@link particleFlagDisableZ} or {@link particleFlagRotateY} are `true` or the {@link BaseMaterial3D} being used to draw the particle is using {@link BaseMaterial3D.BILLBOARD_PARTICLES}.
+     */
+    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 CurveTexture} over its lifetime.
+     */
+    get angularVelocityCurve(): Texture2D { return _C(this, 5813, 1) as Texture2D; }
+    set angularVelocityCurve(v: Texture2D) { _C(this, 12252, 1, v); }
+
+    get directionalVelocity(): Vector2 { return _C(this, 5809, 16) as Vector2; }
+    set directionalVelocity(v: Vector2) { _C(this, 12248, 16, v); }
+
+    /**
+     * Minimum directional velocity value, which is multiplied by {@link directionalVelocityCurve}.
+     * **Note:** Animated velocities will not be affected by damping, use {@link velocityLimitCurve} instead.
+     */
+    get directionalVelocityMin(): number { return _C(this, 5812, 16) as number; }
+    set directionalVelocityMin(v: number) { _C(this, 12251, 16, v); }
+
+    /**
+     * Maximum directional velocity value, which is multiplied by {@link directionalVelocityCurve}.
+     * **Note:** Animated velocities will not be affected by damping, use {@link velocityLimitCurve} instead.
+     */
+    get directionalVelocityMax(): number { return _C(this, 5811, 16) as number; }
+    set directionalVelocityMax(v: number) { _C(this, 12250, 16, v); }
+
+    /**
+     * A curve that specifies the velocity along each of the axes of the particle system along its lifetime.
+     * **Note:** Animated velocities will not be affected by damping, use {@link velocityLimitCurve} instead.
+     */
+    get directionalVelocityCurve(): Texture2D { return _C(this, 5813, 16) as Texture2D; }
+    set directionalVelocityCurve(v: Texture2D) { _C(this, 12252, 16, v); }
+
+    get orbitVelocity(): Vector2 { return _C(this, 5809, 2) as Vector2; }
+    set orbitVelocity(v: Vector2) { _C(this, 12248, 2, v); }
+
+    /**
+     * Minimum equivalent of {@link orbitVelocityMax}.
+     * **Note:** Animated velocities will not be affected by damping, use {@link velocityLimitCurve} instead.
+     */
+    get orbitVelocityMin(): number { return _C(this, 5812, 2) as number; }
+    set orbitVelocityMin(v: number) { _C(this, 12251, 2, v); }
+
+    /**
+     * Maximum orbital velocity applied to each particle. Makes the particles circle around origin. Specified in number of full rotations around origin per second.
+     * **Note:** Animated velocities will not be affected by damping, use {@link velocityLimitCurve} instead.
+     */
+    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 CurveTexture}.
+     * **Note:** For 3D orbital velocity, use a {@link CurveXYZTexture}.
+     * **Note:** Animated velocities will not be affected by damping, use {@link velocityLimitCurve} instead.
+     */
+    get orbitVelocityCurve(): Texture2D { return _C(this, 5813, 2) as Texture2D; }
+    set orbitVelocityCurve(v: Texture2D) { _C(this, 12252, 2, v); }
+
+    get radialVelocity(): Vector2 { return _C(this, 5809, 15) as Vector2; }
+    set radialVelocity(v: Vector2) { _C(this, 12248, 15, v); }
+
+    /**
+     * Minimum radial velocity applied to each particle. Makes particles move away from the {@link velocityPivot}, or toward it if negative.
+     * **Note:** Animated velocities will not be affected by damping, use {@link velocityLimitCurve} instead.
+     */
+    get radialVelocityMin(): number { return _C(this, 5812, 15) as number; }
+    set radialVelocityMin(v: number) { _C(this, 12251, 15, v); }
+
+    /**
+     * Maximum radial velocity applied to each particle. Makes particles move away from the {@link velocityPivot}, or toward it if negative.
+     * **Note:** Animated velocities will not be affected by damping, use {@link velocityLimitCurve} instead.
+     */
+    get radialVelocityMax(): number { return _C(this, 5811, 15) as number; }
+    set radialVelocityMax(v: number) { _C(this, 12250, 15, v); }
+
+    /**
+     * A {@link CurveTexture} that defines the velocity over the particle's lifetime away (or toward) the {@link velocityPivot}.
+     * **Note:** Animated velocities will not be affected by damping, use {@link velocityLimitCurve} instead.
+     */
+    get radialVelocityCurve(): Texture2D { return _C(this, 5813, 15) as Texture2D; }
+    set radialVelocityCurve(v: Texture2D) { _C(this, 12252, 15, v); }
+
+    /**
+     * A {@link CurveTexture} that defines the maximum velocity of a particle during its lifetime.
+     */
+    get velocityLimitCurve(): Texture2D { return _C(this, 7038) as Texture2D; }
+    set velocityLimitCurve(v: Texture2D) { _C(this, 13282, v); }
+
+    /**
+     * Enable 3D rotation velocity.
+     */
+    get useRotationVelocity3d(): boolean { return _C(this, 8417) as boolean; }
+    set useRotationVelocity3d(v: boolean) { _C(this, 13249, v); }
+
+    /**
+     * Minimum 3D rotation velocity on the particle's local axis. Enable {@link useRotationVelocity3d} to use this.
+     */
+    get rotationVelocity3dMin(): Vector3 { return _C(this, 6218) as Vector3; }
+    set rotationVelocity3dMin(v: Vector3) { _C(this, 12592, v); }
+
+    /**
+     * Maximum 3D rotation velocity on the particle's local axis. Enable {@link useRotationVelocity3d} to use this.
+     */
+    get rotationVelocity3dMax(): Vector3 { return _C(this, 6217) as Vector3; }
+    set rotationVelocity3dMax(v: Vector3) { _C(this, 12591, v); }
+
+    /**
+     * Rotation velocity curve over lifetime, per-axis. Enable {@link useRotationVelocity3d} to use this.
+     */
+    get rotationVelocity3dCurve(): Texture2D { return _C(this, 6216) as Texture2D; }
+    set rotationVelocity3dCurve(v: Texture2D) { _C(this, 12590, v); }
+
+    /**
+     * Gravity applied to every particle.
+     */
+    get gravity(): Vector3 { return _C(this, 4971) as Vector3; }
+    set gravity(v: Vector3) { _C(this, 11553, v); }
+
+    get linearAccel(): Vector2 { return _C(this, 5809, 3) as Vector2; }
+    set linearAccel(v: Vector2) { _C(this, 12248, 3, v); }
+
+    /**
+     * Minimum equivalent of {@link linearAccelMax}.
+     */
+    get linearAccelMin(): number { return _C(this, 5812, 3) as number; }
+    set linearAccelMin(v: number) { _C(this, 12251, 3, v); }
+
+    /**
+     * Maximum linear acceleration applied to each particle in the direction of motion.
+     */
+    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 CurveTexture}.
+     */
+    get linearAccelCurve(): Texture2D { return _C(this, 5813, 3) as Texture2D; }
+    set linearAccelCurve(v: Texture2D) { _C(this, 12252, 3, v); }
+
+    get radialAccel(): Vector2 { return _C(this, 5809, 4) as Vector2; }
+    set radialAccel(v: Vector2) { _C(this, 12248, 4, v); }
+
+    /**
+     * Minimum equivalent of {@link radialAccelMax}.
+     */
+    get radialAccelMin(): number { return _C(this, 5812, 4) as number; }
+    set radialAccelMin(v: number) { _C(this, 12251, 4, v); }
+
+    /**
+     * Maximum radial acceleration applied to each particle. Makes particle accelerate away from the origin or towards it if negative.
+     */
+    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 CurveTexture}.
+     */
+    get radialAccelCurve(): Texture2D { return _C(this, 5813, 4) as Texture2D; }
+    set radialAccelCurve(v: Texture2D) { _C(this, 12252, 4, v); }
+
+    get tangentialAccel(): Vector2 { return _C(this, 5809, 5) as Vector2; }
+    set tangentialAccel(v: Vector2) { _C(this, 12248, 5, v); }
+
+    /**
+     * Minimum equivalent of {@link tangentialAccelMax}.
+     */
+    get tangentialAccelMin(): number { return _C(this, 5812, 5) as number; }
+    set tangentialAccelMin(v: number) { _C(this, 12251, 5, v); }
+
+    /**
+     * Maximum tangential acceleration applied to each particle. Tangential acceleration is perpendicular to the particle's velocity giving the particles a swirling motion.
+     */
+    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 CurveTexture}.
+     */
+    get tangentialAccelCurve(): Texture2D { return _C(this, 5813, 5) as Texture2D; }
+    set tangentialAccelCurve(v: Texture2D) { _C(this, 12252, 5, v); }
+
+    get damping(): Vector2 { return _C(this, 5809, 6) as Vector2; }
+    set damping(v: Vector2) { _C(this, 12248, 6, v); }
+
+    /**
+     * Minimum equivalent of {@link dampingMax}.
+     */
+    get dampingMin(): number { return _C(this, 5812, 6) as number; }
+    set dampingMin(v: number) { _C(this, 12251, 6, v); }
+
+    /**
+     * The maximum rate at which particles lose velocity. For example value of `100` means that the particle will go from `100` velocity to `0` in `1` second.
+     */
+    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 CurveTexture}.
+     */
+    get dampingCurve(): Texture2D { return _C(this, 5813, 6) as Texture2D; }
+    set dampingCurve(v: Texture2D) { _C(this, 12252, 6, v); }
+
+    /**
+     * If `true`, interaction with particle attractors is enabled. In 3D, attraction only occurs within the area defined by the {@link GPUParticles3D} node's {@link GPUParticles3D.visibilityAabb}.
+     */
+    get attractorInteractionEnabled(): boolean { return _C(this, 7767) as boolean; }
+    set attractorInteractionEnabled(v: boolean) { _C(this, 10554, v); }
+
+    /**
+     * Enable the usage of {@link scale3dMin} and {@link scale3dMax}.
+     */
+    get useScale3d(): boolean { return _C(this, 8419) as boolean; }
+    set useScale3d(v: boolean) { _C(this, 13237, v); }
+
+    /**
+     * The minimum value of the random scale vector for each particle.
+     * Works only if {@link useScale3d} is enabled.
+     */
+    get scale3dMin(): Vector3 { return _C(this, 6238) as Vector3; }
+    set scale3dMin(v: Vector3) { _C(this, 12610, v); }
+
+    /**
+     * The maximum value of the random scale vector for each particle.
+     * Works only if {@link useScale3d} is enabled.
+     */
+    get scale3dMax(): Vector3 { return _C(this, 6237) as Vector3; }
+    set scale3dMax(v: Vector3) { _C(this, 12609, v); }
+
+    get scale(): Vector2 { return _C(this, 5809, 8) as Vector2; }
+    set scale(v: Vector2) { _C(this, 12248, 8, v); }
+
+    /**
+     * Minimum equivalent of {@link scaleMax}.
+     */
+    get scaleMin(): number { return _C(this, 5812, 8) as number; }
+    set scaleMin(v: number) { _C(this, 12251, 8, v); }
+
+    /**
+     * Maximum initial scale applied to each particle.
+     */
+    get scaleMax(): number { return _C(this, 5811, 8) as number; }
+    set scaleMax(v: number) { _C(this, 12250, 8, v); }
+
+    /**
+     * Each particle's scale will vary along this {@link CurveTexture} over its lifetime. If a {@link CurveXYZTexture} is supplied instead, the scale will be separated per-axis.
+     */
+    get scaleCurve(): Texture2D { return _C(this, 5813, 8) as Texture2D; }
+    set scaleCurve(v: Texture2D) { _C(this, 12252, 8, v); }
+
+    get scaleOverVelocity(): Vector2 { return _C(this, 5809, 17) as Vector2; }
+    set scaleOverVelocity(v: Vector2) { _C(this, 12248, 17, v); }
+
+    /**
+     * Minimum velocity value reference for {@link scaleOverVelocityCurve}.
+     * {@link scaleOverVelocityCurve} will be interpolated between {@link scaleOverVelocityMin} and {@link scaleOverVelocityMax}.
+     */
+    get scaleOverVelocityMin(): number { return _C(this, 5812, 17) as number; }
+    set scaleOverVelocityMin(v: number) { _C(this, 12251, 17, v); }
+
+    /**
+     * Maximum velocity value reference for {@link scaleOverVelocityCurve}.
+     * {@link scaleOverVelocityCurve} will be interpolated between {@link scaleOverVelocityMin} and {@link scaleOverVelocityMax}.
+     */
+    get scaleOverVelocityMax(): number { return _C(this, 5811, 17) as number; }
+    set scaleOverVelocityMax(v: number) { _C(this, 12250, 17, v); }
+
+    /**
+     * Either a {@link CurveTexture} or a {@link CurveXYZTexture} that scales each particle based on its velocity.
+     */
+    get scaleOverVelocityCurve(): Texture2D { return _C(this, 5813, 17) as Texture2D; }
+    set scaleOverVelocityCurve(v: Texture2D) { _C(this, 12252, 17, v); }
+
+    /**
+     * Each particle's initial color. If the {@link GPUParticles2D}'s `texture` is defined, it will be multiplied by this 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 GradientTexture1D} 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(): Texture2D { return _C(this, 4228) as Texture2D; }
+    set colorRamp(v: Texture2D) { _C(this, 10912, v); }
+
+    /**
+     * Each particle's initial color will vary along this {@link GradientTexture1D} (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(): Texture2D { return _C(this, 4223) as Texture2D; }
+    set colorInitialRamp(v: Texture2D) { _C(this, 10909, v); }
+
+    /**
+     * The alpha value of each particle's color will be multiplied by this {@link CurveTexture} over its lifetime.
+     * **Note:** {@link alphaCurve} 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}, `ALPHA *= COLOR.a;` must be inserted in the shader's `fragment()` function. Otherwise, {@link alphaCurve} will have no visible effect.
+     */
+    get alphaCurve(): Texture2D { return _C(this, 3726) as Texture2D; }
+    set alphaCurve(v: Texture2D) { _C(this, 10467, v); }
+
+    /**
+     * Each particle's color will be multiplied by this {@link CurveTexture} over its lifetime.
+     * **Note:** {@link emissionCurve} 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 emissionCurve} will have no visible effect.
+     */
+    get emissionCurve(): Texture2D { return _C(this, 4619) as Texture2D; }
+    set emissionCurve(v: Texture2D) { _C(this, 11236, v); }
+
+    get hueVariation(): Vector2 { return _C(this, 5809, 9) as Vector2; }
+    set hueVariation(v: Vector2) { _C(this, 12248, 9, v); }
+
+    /**
+     * Minimum equivalent of {@link hueVariationMax}.
+     */
+    get hueVariationMin(): number { return _C(this, 5812, 9) as number; }
+    set hueVariationMin(v: number) { _C(this, 12251, 9, v); }
+
+    /**
+     * Maximum initial hue variation applied to each particle. It will shift the particle color's hue.
+     */
+    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 CurveTexture}.
+     */
+    get hueVariationCurve(): Texture2D { return _C(this, 5813, 9) as Texture2D; }
+    set hueVariationCurve(v: Texture2D) { _C(this, 12252, 9, v); }
+
+    get animSpeed(): Vector2 { return _C(this, 5809, 10) as Vector2; }
+    set animSpeed(v: Vector2) { _C(this, 12248, 10, v); }
+
+    /**
+     * Minimum equivalent of {@link animSpeedMax}.
+     */
+    get animSpeedMin(): number { return _C(this, 5812, 10) as number; }
+    set animSpeedMin(v: number) { _C(this, 12251, 10, v); }
+
+    /**
+     * Maximum particle animation speed. Animation speed of `1` means that the particles will make full `0` to `1` offset cycle during lifetime, `2` means `2` cycles etc.
+     * With animation speed greater than `1`, remember to enable {@link CanvasItemMaterial.particlesAnimLoop} property if you want the animation to repeat.
+     */
+    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 CurveTexture}.
+     */
+    get animSpeedCurve(): Texture2D { return _C(this, 5813, 10) as Texture2D; }
+    set animSpeedCurve(v: Texture2D) { _C(this, 12252, 10, v); }
+
+    get animOffset(): Vector2 { return _C(this, 5809, 11) as Vector2; }
+    set animOffset(v: Vector2) { _C(this, 12248, 11, v); }
+
+    /**
+     * Minimum equivalent of {@link animOffsetMax}.
+     */
+    get animOffsetMin(): number { return _C(this, 5812, 11) as number; }
+    set animOffsetMin(v: number) { _C(this, 12251, 11, v); }
+
+    /**
+     * Maximum animation offset that corresponds to frame index in the texture. `0` is the first frame, `1` is the last one. See {@link CanvasItemMaterial.particlesAnimation}.
+     */
+    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 CurveTexture}.
+     */
+    get animOffsetCurve(): Texture2D { return _C(this, 5813, 11) as Texture2D; }
+    set animOffsetCurve(v: Texture2D) { _C(this, 12252, 11, v); }
+
+    /**
+     * If `true`, enables turbulence for the particle system. Turbulence can be used to vary particle movement according to its position (based on a 3D noise pattern). In 3D, {@link GPUParticlesAttractorVectorField3D} with {@link NoiseTexture3D} can be used as an alternative to turbulence that works in world space and with multiple particle systems reacting in the same way.
+     * **Note:** Enabling turbulence has a high performance cost on the GPU. Only enable turbulence on a few particle systems at once at most, and consider disabling it when targeting mobile/web platforms.
+     */
+    get turbulenceEnabled(): boolean { return _C(this, 6915) as boolean; }
+    set turbulenceEnabled(v: boolean) { _C(this, 13155, v); }
+
+    /**
+     * The turbulence noise strength. Increasing this will result in a stronger, more contrasting, flow pattern.
+     */
+    get turbulenceNoiseStrength(): number { return _C(this, 6919) as number; }
+    set turbulenceNoiseStrength(v: number) { _C(this, 13159, v); }
+
+    /**
+     * This value controls the overall scale/frequency of the turbulence noise pattern.
+     * A small scale will result in smaller features with more detail while a high scale will result in smoother noise with larger features.
+     */
+    get turbulenceNoiseScale(): number { return _C(this, 6916) as number; }
+    set turbulenceNoiseScale(v: number) { _C(this, 13156, v); }
+
+    /**
+     * A scrolling velocity for the turbulence field. This sets a directional trend for the pattern to move in over time.
+     * The default value of `Vector3(0, 0, 0)` turns off the scrolling.
+     */
+    get turbulenceNoiseSpeed(): Vector3 { return _C(this, 6917) as Vector3; }
+    set turbulenceNoiseSpeed(v: Vector3) { _C(this, 13157, v); }
+
+    /**
+     * The in-place rate of change of the turbulence field. This defines how quickly the noise pattern varies over time.
+     * A value of 0.0 will result in a fixed pattern.
+     */
+    get turbulenceNoiseSpeedRandom(): number { return _C(this, 6918) as number; }
+    set turbulenceNoiseSpeedRandom(v: number) { _C(this, 13158, v); }
+
+    get turbulenceInfluence(): Vector2 { return _C(this, 5809, 13) as Vector2; }
+    set turbulenceInfluence(v: Vector2) { _C(this, 12248, 13, v); }
+
+    /**
+     * Minimum turbulence influence on each particle.
+     * The actual amount of turbulence influence on each particle is calculated as a random value between {@link turbulenceInfluenceMin} and {@link turbulenceInfluenceMax} and multiplied by the amount of turbulence influence from {@link turbulenceInfluenceOverLife}.
+     */
+    get turbulenceInfluenceMin(): number { return _C(this, 5812, 13) as number; }
+    set turbulenceInfluenceMin(v: number) { _C(this, 12251, 13, v); }
+
+    /**
+     * Maximum turbulence influence on each particle.
+     * The actual amount of turbulence influence on each particle is calculated as a random value between {@link turbulenceInfluenceMin} and {@link turbulenceInfluenceMax} and multiplied by the amount of turbulence influence from {@link turbulenceInfluenceOverLife}.
+     */
+    get turbulenceInfluenceMax(): number { return _C(this, 5811, 13) as number; }
+    set turbulenceInfluenceMax(v: number) { _C(this, 12250, 13, v); }
+
+    get turbulenceInitialDisplacement(): Vector2 { return _C(this, 5809, 14) as Vector2; }
+    set turbulenceInitialDisplacement(v: Vector2) { _C(this, 12248, 14, v); }
+
+    /**
+     * Minimum displacement of each particle's spawn position by the turbulence.
+     * The actual amount of displacement will be a factor of the underlying turbulence multiplied by a random value between {@link turbulenceInitialDisplacementMin} and {@link turbulenceInitialDisplacementMax}.
+     */
+    get turbulenceInitialDisplacementMin(): number { return _C(this, 5812, 14) as number; }
+    set turbulenceInitialDisplacementMin(v: number) { _C(this, 12251, 14, v); }
+
+    /**
+     * Maximum displacement of each particle's spawn position by the turbulence.
+     * The actual amount of displacement will be a factor of the underlying turbulence multiplied by a random value between {@link turbulenceInitialDisplacementMin} and {@link turbulenceInitialDisplacementMax}.
+     */
+    get turbulenceInitialDisplacementMax(): number { return _C(this, 5811, 14) as number; }
+    set turbulenceInitialDisplacementMax(v: number) { _C(this, 12250, 14, v); }
+
+    /**
+     * Each particle's amount of turbulence will be influenced along this {@link CurveTexture} over its life time.
+     */
+    get turbulenceInfluenceOverLife(): Texture2D { return _C(this, 5813, 12) as Texture2D; }
+    set turbulenceInfluenceOverLife(v: Texture2D) { _C(this, 12252, 12, v); }
+
+    /**
+     * The particles' collision mode.
+     * **Note:** 3D Particles can only collide with {@link GPUParticlesCollision3D} nodes, not {@link PhysicsBody3D} nodes. To make particles collide with various objects, you can add {@link GPUParticlesCollision3D} nodes as children of {@link PhysicsBody3D} nodes. In 3D, collisions only occur within the area defined by the {@link GPUParticles3D} node's {@link GPUParticles3D.visibilityAabb}.
+     * **Note:** 2D Particles can only collide with {@link LightOccluder2D} nodes, not {@link PhysicsBody2D} nodes.
+     */
+    get collisionMode(): CollisionMode { return _C(this, 4207) as CollisionMode; }
+    set collisionMode(v: CollisionMode) { _C(this, 10896, v); }
+
+    /**
+     * The particles' friction. Values range from `0` (frictionless) to `1` (maximum friction). Only effective if {@link collisionMode} is {@link COLLISION_RIGID}.
+     */
+    get collisionFriction(): number { return _C(this, 4201) as number; }
+    set collisionFriction(v: number) { _C(this, 10891, v); }
+
+    /**
+     * The particles' bounciness. Values range from `0` (no bounce) to `1` (full bounciness). Only effective if {@link collisionMode} is {@link COLLISION_RIGID}.
+     */
+    get collisionBounce(): number { return _C(this, 4196) as number; }
+    set collisionBounce(v: number) { _C(this, 10888, v); }
+
+    /**
+     * If `true`, {@link GPUParticles3D.collisionBaseSize} is multiplied by the particle's effective scale (see {@link scaleMin}, {@link scaleMax}, {@link scaleCurve}, and {@link scaleOverVelocityCurve}).
+     */
+    get collisionUseScale(): boolean { return _C(this, 7845) as boolean; }
+    set collisionUseScale(v: boolean) { _C(this, 10903, v); }
+
+    /**
+     * The particle subemitter mode (see {@link GPUParticles2D.subEmitter} and {@link GPUParticles3D.subEmitter}).
+     */
+    get subEmitterMode(): SubEmitterMode { return _C(this, 6596) as SubEmitterMode; }
+    set subEmitterMode(v: SubEmitterMode) { _C(this, 12922, v); }
+
+    /**
+     * The frequency at which particles should be emitted from the subemitter node. One particle will be spawned every {@link subEmitterFrequency} seconds.
+     * **Note:** This value shouldn't exceed {@link GPUParticles2D.amount} or {@link GPUParticles3D.amount} defined on the *subemitter node* (not the main node), relative to the subemitter's particle lifetime. If the number of particles is exceeded, no new particles will spawn from the subemitter until enough particles have expired.
+     */
+    get subEmitterFrequency(): number { return _C(this, 6594) as number; }
+    set subEmitterFrequency(v: number) { _C(this, 12920, v); }
+
+    /**
+     * The amount of particles to spawn from the subemitter node when the particle expires.
+     * **Note:** This value shouldn't exceed {@link GPUParticles2D.amount} or {@link GPUParticles3D.amount} defined on the *subemitter node* (not the main node), relative to the subemitter's particle lifetime. If the number of particles is exceeded, no new particles will spawn from the subemitter until enough particles have expired.
+     */
+    get subEmitterAmountAtEnd(): number { return _C(this, 6592) as number; }
+    set subEmitterAmountAtEnd(v: number) { _C(this, 12918, v); }
+
+    /**
+     * The amount of particles to spawn from the subemitter node when a collision occurs. When combined with {@link COLLISION_HIDE_ON_CONTACT} on the main particles material, this can be used to achieve effects such as raindrops hitting the ground.
+     * **Note:** This value shouldn't exceed {@link GPUParticles2D.amount} or {@link GPUParticles3D.amount} defined on the *subemitter node* (not the main node), relative to the subemitter's particle lifetime. If the number of particles is exceeded, no new particles will spawn from the subemitter until enough particles have expired.
+     */
+    get subEmitterAmountAtCollision(): number { return _C(this, 6591) as number; }
+    set subEmitterAmountAtCollision(v: number) { _C(this, 12917, v); }
+
+    /**
+     * The amount of particles to spawn from the subemitter node when the particle spawns.
+     * **Note:** This value shouldn't exceed {@link GPUParticles2D.amount} or {@link GPUParticles3D.amount} defined on the *subemitter node* (not the main node), relative to the subemitter's particle lifetime. If the number of particles is exceeded, no new particles will spawn from the subemitter until enough particles have expired.
+     */
+    get subEmitterAmountAtStart(): number { return _C(this, 6593) as number; }
+    set subEmitterAmountAtStart(v: number) { _C(this, 12919, v); }
+
+    /**
+     * If `true`, the subemitter inherits the parent particle's velocity when it spawns.
+     */
+    get subEmitterKeepVelocity(): boolean { return _C(this, 6595) as boolean; }
+    set subEmitterKeepVelocity(v: boolean) { _C(this, 12921, v); }
+
+    /**
+     * Emitted when this material's emission shape is changed in any way. This includes changes to {@link emissionShape}, {@link emissionShapeScale}, or {@link emissionSphereRadius}, and any other property that affects the emission shape's offset, size, scale, or orientation.
+     * **Note:** This signal is only emitted inside the editor for performance reasons.
+     */
+    get emissionShapeChanged(): Signal<() => void> { return _G(this, 3040) as Signal<() => void>; }
+    set emissionShapeChanged(v: (() => void) | null) { _G(this, 3040, v); }
+
+    static readonly name = _R(549, ParticleProcessMaterial);
+}
+
+export const Parameter = {
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set initial velocity properties.
+     */
+    PARAM_INITIAL_LINEAR_VELOCITY: 0,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set angular velocity properties.
+     */
+    PARAM_ANGULAR_VELOCITY: 1,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set orbital velocity properties.
+     */
+    PARAM_ORBIT_VELOCITY: 2,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set linear acceleration properties.
+     */
+    PARAM_LINEAR_ACCEL: 3,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set radial acceleration properties.
+     */
+    PARAM_RADIAL_ACCEL: 4,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set tangential acceleration properties.
+     */
+    PARAM_TANGENTIAL_ACCEL: 5,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set damping properties.
+     */
+    PARAM_DAMPING: 6,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set angle properties.
+     */
+    PARAM_ANGLE: 7,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set scale properties.
+     */
+    PARAM_SCALE: 8,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set hue variation properties.
+     */
+    PARAM_HUE_VARIATION: 9,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set animation speed properties.
+     */
+    PARAM_ANIM_SPEED: 10,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set animation offset properties.
+     */
+    PARAM_ANIM_OFFSET: 11,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set radial velocity properties.
+     */
+    PARAM_RADIAL_VELOCITY: 15,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set directional velocity properties.
+     */
+    PARAM_DIRECTIONAL_VELOCITY: 16,
+    /**
+     * Use with {@link setParamMin}, {@link setParamMax}, and {@link setParamTexture} to set scale over velocity properties.
+     */
+    PARAM_SCALE_OVER_VELOCITY: 17,
+    /**
+     * Represents the size of the {@link Parameter} enum.
+     */
+    PARAM_MAX: 18,
+    /**
+     * Use with {@link setParamMin} and {@link setParamMax} to set the turbulence minimum und maximum influence on each particles velocity.
+     */
+    PARAM_TURB_VEL_INFLUENCE: 13,
+    /**
+     * Use with {@link setParamMin} and {@link setParamMax} to set the turbulence minimum and maximum displacement of the particles spawn position.
+     */
+    PARAM_TURB_INIT_DISPLACEMENT: 14,
+    /**
+     * Use with {@link setParamTexture} to set the turbulence influence over the particles life time.
+     */
+    PARAM_TURB_INFLUENCE_OVER_LIFE: 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,
+    PARTICLE_FLAG_DAMPING_AS_FRICTION: 3,
+    PARTICLE_FLAG_INHERIT_EMITTER_SCALE: 4,
+    /**
+     * Represents the size of the {@link ParticleFlags} enum.
+     */
+    PARTICLE_FLAG_MAX: 5,
+} 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 determined by sampling a random point on the {@link emissionPointTexture}. Particle color will be modulated by {@link emissionColorTexture}.
+     */
+    EMISSION_SHAPE_POINTS: 4,
+    /**
+     * Particles will be emitted at a position determined by sampling a random point on the {@link emissionPointTexture}. Particle velocity and rotation will be set based on {@link emissionNormalTexture}. Particle color will be modulated by {@link emissionColorTexture}.
+     */
+    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];
+
+export const SubEmitterMode = {
+    /**
+     * The subemitter is disabled.
+     */
+    SUB_EMITTER_DISABLED: 0,
+    /**
+     * The submitter is emitted on the constant interval defined by {@link subEmitterFrequency}.
+     */
+    SUB_EMITTER_CONSTANT: 1,
+    /**
+     * The subemitter is emitted at the end of the particle's lifetime.
+     */
+    SUB_EMITTER_AT_END: 2,
+    /**
+     * The subemitter is emitted when the particle collides.
+     */
+    SUB_EMITTER_AT_COLLISION: 3,
+    /**
+     * The subemitter is emitted when the particle spawns.
+     */
+    SUB_EMITTER_AT_START: 4,
+    /**
+     * Represents the size of the {@link SubEmitterMode} enum.
+     */
+    SUB_EMITTER_MAX: 5,
+} as const;
+
+export type SubEmitterMode = (typeof SubEmitterMode)[keyof typeof SubEmitterMode];
+
+export const CollisionMode = {
+    /**
+     * No collision for particles. Particles will go through {@link GPUParticlesCollision3D} nodes.
+     */
+    COLLISION_DISABLED: 0,
+    /**
+     * {@link RigidBody3D}-style collision for particles using {@link GPUParticlesCollision3D} nodes.
+     */
+    COLLISION_RIGID: 1,
+    /**
+     * Hide particles instantly when colliding with a {@link GPUParticlesCollision3D} node. This can be combined with a subemitter that uses the {@link COLLISION_RIGID} collision mode to "replace" the parent particle with the subemitter on impact.
+     */
+    COLLISION_HIDE_ON_CONTACT: 2,
+    /**
+     * Represents the size of the {@link CollisionMode} enum.
+     */
+    COLLISION_MAX: 3,
+} as const;
+
+export type CollisionMode = (typeof CollisionMode)[keyof typeof CollisionMode];
+