@ringozz/godot 0.1.0

package/gen/classes/CPUParticles2D.ts

@@ -0,0 +1,590 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { PackedColorArray, PackedVector2Array, Signal } from '../heap-types/index.ts';
+import type { Color, Vector2 } from '../value-types/index.ts';
+import type { Curve } from './Curve.ts';
+import type { Gradient } from './Gradient.ts';
+import type { Node } from './Node.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * CPU-based 2D particle node used to create a variety of particle systems and effects.
+ * See also {@link GPUParticles2D}, which provides the same functionality with hardware acceleration, but may not run on older devices.
+ */
+export class CPUParticles2D extends Node2D {
+    constructor(name = 162) { super(name); }
+
+    /**
+     * 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); }
+
+    /**
+     * 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); }
+
+    /**
+     * Sets this node's properties to match a given {@link GPUParticles2D} 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); }
+
+    /**
+     * Particle texture. If `null`, particles will be squares.
+     */
+    get texture(): Texture2D { return _C(this, 6726) as Texture2D; }
+    set texture(v: Texture2D) { _C(this, 13024, 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 simulation of 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); }
+
+    /**
+     * 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 CPUParticles2D} 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 CPUParticles2D} 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); }
+
+    /**
+     * 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_RECTANGLE}.
+     */
+    get emissionRectExtents(): Vector2 { return _C(this, 4629) as Vector2; }
+    set emissionRectExtents(v: Vector2) { _C(this, 11246, v); }
+
+    /**
+     * Sets the initial positions to spawn particles when using {@link EMISSION_SHAPE_POINTS} or {@link EMISSION_SHAPE_DIRECTED_POINTS}.
+     */
+    get emissionPoints(): PackedVector2Array { return _C(this, 4628) as PackedVector2Array; }
+    set emissionPoints(v: PackedVector2Array) { _C(this, 11245, v); }
+
+    /**
+     * Sets the direction the particles will be emitted in when using {@link EMISSION_SHAPE_DIRECTED_POINTS}.
+     */
+    get emissionNormals(): PackedVector2Array { return _C(this, 4624) as PackedVector2Array; }
+    set emissionNormals(v: PackedVector2Array) { _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}.
+     */
+    get emissionColors(): PackedColorArray { return _C(this, 4618) as PackedColorArray; }
+    set emissionColors(v: PackedColorArray) { _C(this, 11235, v); }
+
+    /**
+     * The ring's inner radius if {@link emissionShape} is set to {@link EMISSION_SHAPE_RING}.
+     */
+    get emissionRingInnerRadius(): number { return _C(this, 4633) as number; }
+    set emissionRingInnerRadius(v: number) { _C(this, 11250, v); }
+
+    /**
+     * The ring's outer radius if {@link emissionShape} is set to {@link EMISSION_SHAPE_RING}.
+     */
+    get emissionRingRadius(): number { return _C(this, 4634) as number; }
+    set emissionRingRadius(v: number) { _C(this, 11251, 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); }
+
+    /**
+     * Unit vector specifying the particles' emission direction.
+     */
+    get direction(): Vector2 { return _C(this, 4506) as Vector2; }
+    set direction(v: Vector2) { _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); }
+
+    /**
+     * Gravity applied to every particle.
+     */
+    get gravity(): Vector2 { return _C(this, 4971) as Vector2; }
+    set gravity(v: Vector2) { _C(this, 11553, 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); }
+
+    /**
+     * 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.
+     */
+    get angularVelocityMax(): number { return _C(this, 5811, 1) as number; }
+    set angularVelocityMax(v: number) { _C(this, 12250, 1, v); }
+
+    /**
+     * Each particle's angular velocity will vary along this {@link Curve}. 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 equivalent of {@link orbitVelocityMax}.
+     */
+    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.
+     */
+    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 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 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 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 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 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 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 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 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 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.
+     */
+    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 equivalent of {@link scaleAmountMax}.
+     */
+    get scaleAmountMin(): number { return _C(this, 5812, 8) as number; }
+    set scaleAmountMin(v: number) { _C(this, 12251, 8, v); }
+
+    /**
+     * Maximum initial scale applied to each particle.
+     */
+    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 `true`, the scale curve will be split into x and y components. See {@link scaleCurveX} and {@link scaleCurveY}.
+     */
+    get splitScale(): boolean { return _C(this, 6501) as boolean; }
+    set splitScale(v: boolean) { _C(this, 12844, v); }
+
+    /**
+     * Each particle's horizontal scale will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     * {@link splitScale} must be enabled.
+     */
+    get scaleCurveX(): Curve { return _C(this, 6240) as Curve; }
+    set scaleCurveX(v: Curve) { _C(this, 12612, v); }
+
+    /**
+     * Each particle's vertical scale will vary along this {@link Curve}. Should be a unit {@link Curve}.
+     * {@link splitScale} must be enabled.
+     */
+    get scaleCurveY(): Curve { return _C(this, 6241) as Curve; }
+    set scaleCurveY(v: Curve) { _C(this, 12613, v); }
+
+    /**
+     * Each particle's initial color. If {@link texture} is defined, it will be multiplied by this color.
+     */
+    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}).
+     */
+    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}).
+     */
+    get colorInitialRamp(): Gradient { return _C(this, 4223) as Gradient; }
+    set colorInitialRamp(v: Gradient) { _C(this, 10909, 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 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 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 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 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 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(162, CPUParticles2D);
+}
+
+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,
+} 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,
+    /**
+     * Present for consistency with 3D particle nodes, not used in 2D.
+     */
+    PARTICLE_FLAG_ROTATE_Y: 1,
+    /**
+     * Present for consistency with 3D particle nodes, not used in 2D.
+     */
+    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 flattened to two dimensions.
+     */
+    EMISSION_SHAPE_SPHERE: 1,
+    /**
+     * Particles will be emitted on the surface of a sphere flattened to two dimensions.
+     */
+    EMISSION_SHAPE_SPHERE_SURFACE: 2,
+    /**
+     * Particles will be emitted in the area of a rectangle.
+     */
+    EMISSION_SHAPE_RECTANGLE: 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 the area of a ring parameterized by its outer and inner radius.
+     */
+    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];
+