@ringozz/godot 0.1.0

package/gen/classes/GPUParticles2D.ts

@@ -0,0 +1,270 @@
+// 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 { NodePath, Signal } from '../heap-types/index.ts';
+import type { Color, Rect2, Transform2D, Vector2 } from '../value-types/index.ts';
+import type { Material } from './Material.ts';
+import type { Node } from './Node.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * 2D particle node used to create a variety of particle systems and effects. {@link GPUParticles2D} features an emitter that generates some number of particles at a given rate.
+ * Use the {@link processMaterial} property to add a {@link ParticleProcessMaterial} to configure particle appearance and behavior. Alternatively, you can add a {@link ShaderMaterial} which will be applied to all particles.
+ * 2D particles can optionally collide with {@link LightOccluder2D}, but they don't collide with {@link PhysicsBody2D} nodes.
+ */
+export class GPUParticles2D extends Node2D {
+    constructor(name = 298) { 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 */): void { _C(this, 10055, processTime, processTimeResidual); }
+
+    /**
+     * Returns a rectangle containing the positions of all existing particles.
+     * **Note:** When using threaded rendering this method synchronizes the rendering thread. Calling it often may have a negative impact on performance.
+     */
+    captureRect(): Rect2 { return _C(this, 2138) as Rect2; }
+
+    /**
+     * Restarts the particle emission cycle, clearing existing particles. To avoid particles vanishing from the viewport, wait for the {@link finished} signal before calling.
+     * **Note:** The {@link finished} signal is only emitted by {@link oneShot} emitters.
+     * 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); }
+
+    /**
+     * Emits a single particle. Whether `xform`, `velocity`, `color` and `custom` are applied depends on the value of `flags`. See {@link EmitFlags}.
+     * The default ParticleProcessMaterial will overwrite `color` and use the contents of `custom` as `(rotation, age, animation, lifetime)`.
+     * **Note:** {@link emitParticle} is only supported on the Forward+ and Mobile rendering methods, not Compatibility.
+     */
+    emitParticle(xform: Transform2D, velocity: Vector2, color: Color, custom: Color, flags: number /* uint32 */): void { _C(this, 3047, xform, velocity, color, custom, flags); }
+
+    /**
+     * Sets this node's properties to match a given {@link CPUParticles2D} node.
+     */
+    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 unless all active particles have finished processing. Use the {@link finished} signal to be notified once all active particles finish processing.
+     * **Note:** For {@link oneShot} emitters, due to the particles being computed on the GPU, there may be a short period after receiving the {@link finished} signal during which setting this to `true` will not restart the emission cycle.
+     * **Tip:** If your {@link oneShot} emitter needs to immediately restart emitting particles once {@link finished} signal is received, consider calling {@link restart} instead of setting {@link emitting}.
+     */
+    get emitting(): boolean { return _C(this, 7929) as boolean; }
+    set emitting(v: boolean) { _C(this, 11256, v); }
+
+    /**
+     * The number of particles to emit in one emission cycle. The effective emission rate is `(amount * amount_ratio) / lifetime` particles per second. Higher values will increase GPU requirements, even if not all particles are visible at a given time or if {@link amountRatio} is decreased.
+     * **Note:** Changing this value will cause the particle system to restart. To avoid this, change {@link amountRatio} instead.
+     */
+    get amount(): number { return _C(this, 3741) as number; }
+    set amount(v: number) { _C(this, 10482, v); }
+
+    /**
+     * The ratio of particles that should actually be emitted. If set to a value lower than `1.0`, this will set the amount of emitted particles throughout the lifetime to `amount * amount_ratio`. Unlike changing {@link amount}, changing {@link amountRatio} while emitting does not affect already-emitted particles and doesn't cause the particle system to restart. {@link amountRatio} can be used to create effects that make the number of emitted particles vary over time.
+     * **Note:** Reducing the {@link amountRatio} has no performance benefit, since resources need to be allocated and processed for the total {@link amount} of particles regardless of the {@link amountRatio}. If you don't intend to change the number of particles emitted while the particles are emitting, make sure {@link amountRatio} is set to `1` and change {@link amount} to your liking instead.
+     */
+    get amountRatio(): number { return _C(this, 3742) as number; }
+    set amountRatio(v: number) { _C(this, 10483, v); }
+
+    /**
+     * Path to another {@link GPUParticles2D} node that will be used as a subemitter (see {@link ParticleProcessMaterial.subEmitterMode}). Subemitters can be used to achieve effects such as fireworks, sparks on collision, bubbles popping into water drops, and more.
+     * **Note:** When {@link subEmitter} is set, the target {@link GPUParticles2D} node will no longer emit particles on its own.
+     */
+    get subEmitter(): NodePath { return _C(this, 6590) as NodePath; }
+    set subEmitter(v: NodePath) { _C(this, 12916, v); }
+
+    /**
+     * Particle texture. If `null`, particles will be squares with a size of 1×1 pixels.
+     * **Note:** To use a flipbook texture, assign a new {@link CanvasItemMaterial} to the {@link GPUParticles2D}'s {@link CanvasItem.material} property, then enable {@link CanvasItemMaterial.particlesAnimation} and set {@link CanvasItemMaterial.particlesAnimHFrames}, {@link CanvasItemMaterial.particlesAnimVFrames}, and {@link CanvasItemMaterial.particlesAnimLoop} to match the flipbook texture.
+     */
+    get texture(): Texture2D { return _C(this, 6726) as Texture2D; }
+    set texture(v: Texture2D) { _C(this, 13024, v); }
+
+    /**
+     * The amount of time each particle will exist (in seconds). The effective emission rate is `(amount * amount_ratio) / lifetime` particles per second.
+     */
+    get lifetime(): number { return _C(this, 5335) as number; }
+    set lifetime(v: number) { _C(this, 11892, v); }
+
+    /**
+     * Causes all the particles in this node to interpolate towards the end of their lifetime.
+     * **Note:** This only works when used with a {@link ParticleProcessMaterial}. It needs to be manually implemented for custom process shaders.
+     */
+    get interpToEnd(): number { return _C(this, 5152) as number; }
+    set interpToEnd(v: number) { _C(this, 11740, 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.
+     * **Note:** This can be very expensive if set to a high number as it requires running the particle shader a number of times equal to the {@link fixedFps} (or 30, if {@link fixedFps} is 0) for every second. In extreme cases it can even lead to a GPU crash due to the volume of work done in a single frame.
+     */
+    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); }
+
+    /**
+     * 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); }
+
+    /**
+     * Enables particle interpolation, which makes the particle movement smoother when their {@link fixedFps} is lower than the screen refresh rate.
+     */
+    get interpolate(): boolean { return _C(this, 5153) as boolean; }
+    set interpolate(v: boolean) { _C(this, 11741, 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); }
+
+    /**
+     * Multiplier for particle's collision radius. `1.0` corresponds to the size of the sprite. If particles appear to sink into the ground when colliding, increase this value. If particles appear to float when colliding, decrease this value. Only effective if {@link ParticleProcessMaterial.collisionMode} is {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT}.
+     * **Note:** Particles always have a spherical collision shape.
+     */
+    get collisionBaseSize(): number { return _C(this, 4195) as number; }
+    set collisionBaseSize(v: number) { _C(this, 10887, v); }
+
+    /**
+     * The {@link Rect2} that determines the node's region which needs to be visible on screen for the particle system to be active.
+     * Grow the rect if particles suddenly appear/disappear when the node enters/exits the screen. The {@link Rect2} can be grown via code or with the **Particles → Generate Visibility Rect** editor tool.
+     */
+    get visibilityRect(): Rect2 { return _C(this, 7100) as Rect2; }
+    set visibilityRect(v: Rect2) { _C(this, 13329, 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 GPUParticles2D} 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 GPUParticles2D} 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); }
+
+    /**
+     * If `true`, enables particle trails using a mesh skinning system.
+     * **Note:** Unlike {@link GPUParticles3D}, the number of trail sections and subdivisions is set with the {@link trailSections} and {@link trailSectionSubdivisions} properties.
+     */
+    get trailEnabled(): boolean { return _C(this, 8370) as boolean; }
+    set trailEnabled(v: boolean) { _C(this, 13127, v); }
+
+    /**
+     * The amount of time the particle's trail should represent (in seconds). Only effective if {@link trailEnabled} is `true`.
+     */
+    get trailLifetime(): number { return _C(this, 6869) as number; }
+    set trailLifetime(v: number) { _C(this, 13128, v); }
+
+    /**
+     * The number of sections to use for the particle trail rendering. Higher values can result in smoother trail curves, at the cost of performance due to increased mesh complexity. See also {@link trailSectionSubdivisions}. Only effective if {@link trailEnabled} is `true`.
+     */
+    get trailSections(): number { return _C(this, 6871) as number; }
+    set trailSections(v: number) { _C(this, 13130, v); }
+
+    /**
+     * The number of subdivisions to use for the particle trail rendering. Higher values can result in smoother trail curves, at the cost of performance due to increased mesh complexity. See also {@link trailSections}. Only effective if {@link trailEnabled} is `true`.
+     */
+    get trailSectionSubdivisions(): number { return _C(this, 6870) as number; }
+    set trailSectionSubdivisions(v: number) { _C(this, 13129, v); }
+
+    /**
+     * {@link Material} for processing particles. Can be a {@link ParticleProcessMaterial} or a {@link ShaderMaterial}.
+     */
+    get processMaterial(): Material { return _C(this, 6025) as Material; }
+    set processMaterial(v: Material) { _C(this, 12426, v); }
+
+    /**
+     * Emitted when all active particles have finished processing. To immediately restart the emission cycle, call {@link restart}.
+     * This signal is never emitted when {@link oneShot} is disabled, as particles will be emitted and processed continuously.
+     * **Note:** For {@link oneShot} emitters, due to the particles being computed on the GPU, there may be a short period after receiving the signal during which setting {@link emitting} to `true` will not restart the emission cycle. This delay is avoided by instead calling {@link restart}.
+     */
+    get finished(): Signal<() => void> { return _G(this, 3310) as Signal<() => void>; }
+    set finished(v: (() => void) | null) { _G(this, 3310, v); }
+
+    static readonly name = _R(298, GPUParticles2D);
+}
+
+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 reverse order of remaining lifetime. In other words, the particle with the lowest lifetime is drawn at the front.
+     */
+    DRAW_ORDER_REVERSE_LIFETIME: 2,
+} as const;
+
+export type DrawOrder = (typeof DrawOrder)[keyof typeof DrawOrder];
+
+export const EmitFlags = {
+    /**
+     * Particle starts at the specified position.
+     */
+    EMIT_FLAG_POSITION: 1,
+    /**
+     * Particle starts with specified rotation and scale.
+     */
+    EMIT_FLAG_ROTATION_SCALE: 2,
+    /**
+     * Particle starts with the specified velocity vector, which defines the emission direction and speed.
+     */
+    EMIT_FLAG_VELOCITY: 4,
+    /**
+     * Particle starts with specified color.
+     */
+    EMIT_FLAG_COLOR: 8,
+    /**
+     * Particle starts with specified `CUSTOM` data.
+     */
+    EMIT_FLAG_CUSTOM: 16,
+} as const;
+
+export type EmitFlags = (typeof EmitFlags)[keyof typeof EmitFlags];
+

package/gen/classes/GPUParticles3D.ts

@@ -0,0 +1,339 @@
+// 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 { NodePath, Signal } from '../heap-types/index.ts';
+import type { AABB, Color, Transform3D, Vector3 } from '../value-types/index.ts';
+import type { Material } from './Material.ts';
+import type { Mesh } from './Mesh.ts';
+import type { Node } from './Node.ts';
+import type { ParticlesTransformAlignAxis, ParticlesTransformAlignCustomSrc } from './RenderingServer.ts';
+import type { Skin } from './Skin.ts';
+
+/**
+ * 3D particle node used to create a variety of particle systems and effects. {@link GPUParticles3D} features an emitter that generates some number of particles at a given rate.
+ * Use {@link processMaterial} to add a {@link ParticleProcessMaterial} to configure particle appearance and behavior. Alternatively, you can add a {@link ShaderMaterial} which will be applied to all particles.
+ */
+export class GPUParticles3D extends GeometryInstance3D {
+    constructor(name = 299) { super(name); }
+
+    /**
+     * Restarts the particle emission cycle, clearing existing particles. To avoid particles vanishing from the viewport, wait for the {@link finished} signal before calling.
+     * **Note:** The {@link finished} signal is only emitted by {@link oneShot} emitters.
+     * 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); }
+
+    /**
+     * 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; }
+
+    /**
+     * Emits a single particle. Whether `xform`, `velocity`, `color` and `custom` are applied depends on the value of `flags`. See {@link EmitFlags}.
+     * The default ParticleProcessMaterial will overwrite `color` and use the contents of `custom` as `(rotation, age, animation, lifetime)`.
+     * **Note:** {@link emitParticle} is only supported on the Forward+ and Mobile rendering methods, not Compatibility.
+     */
+    emitParticle(xform: Transform3D, velocity: Vector3, color: Color, custom: Color, flags: number /* uint32 */): void { _C(this, 3047, xform, velocity, color, custom, flags); }
+
+    /**
+     * Sets this node's properties to match a given {@link CPUParticles3D} node.
+     */
+    convertFromParticles(particles: Node): void { _C(this, 2479, particles); }
+
+    /**
+     * 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); }
+
+    /**
+     * 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 unless all active particles have finished processing. Use the {@link finished} signal to be notified once all active particles finish processing.
+     * **Note:** For {@link oneShot} emitters, due to the particles being computed on the GPU, there may be a short period after receiving the {@link finished} signal during which setting this to `true` will not restart the emission cycle.
+     * **Tip:** If your {@link oneShot} emitter needs to immediately restart emitting particles once {@link finished} signal is received, consider calling {@link restart} instead of setting {@link emitting}.
+     */
+    get emitting(): boolean { return _C(this, 7929) as boolean; }
+    set emitting(v: boolean) { _C(this, 11256, v); }
+
+    /**
+     * The number of particles to emit in one emission cycle. The effective emission rate is `(amount * amount_ratio) / lifetime` particles per second. Higher values will increase GPU requirements, even if not all particles are visible at a given time or if {@link amountRatio} is decreased.
+     * **Note:** Changing this value will cause the particle system to restart. To avoid this, change {@link amountRatio} instead.
+     */
+    get amount(): number { return _C(this, 3741) as number; }
+    set amount(v: number) { _C(this, 10482, v); }
+
+    /**
+     * The ratio of particles that should actually be emitted. If set to a value lower than `1.0`, this will set the amount of emitted particles throughout the lifetime to `amount * amount_ratio`. Unlike changing {@link amount}, changing {@link amountRatio} while emitting does not affect already-emitted particles and doesn't cause the particle system to restart. {@link amountRatio} can be used to create effects that make the number of emitted particles vary over time.
+     * **Note:** Reducing the {@link amountRatio} has no performance benefit, since resources need to be allocated and processed for the total {@link amount} of particles regardless of the {@link amountRatio}. If you don't intend to change the number of particles emitted while the particles are emitting, make sure {@link amountRatio} is set to `1` and change {@link amount} to your liking instead.
+     */
+    get amountRatio(): number { return _C(this, 3742) as number; }
+    set amountRatio(v: number) { _C(this, 10483, v); }
+
+    /**
+     * Path to another {@link GPUParticles3D} node that will be used as a subemitter (see {@link ParticleProcessMaterial.subEmitterMode}). Subemitters can be used to achieve effects such as fireworks, sparks on collision, bubbles popping into water drops, and more.
+     * **Note:** When {@link subEmitter} is set, the target {@link GPUParticles3D} node will no longer emit particles on its own.
+     */
+    get subEmitter(): NodePath { return _C(this, 6590) as NodePath; }
+    set subEmitter(v: NodePath) { _C(this, 12916, v); }
+
+    /**
+     * The amount of time each particle will exist (in seconds). The effective emission rate is `(amount * amount_ratio) / lifetime` particles per second.
+     */
+    get lifetime(): number { return _C(this, 5335) as number; }
+    set lifetime(v: number) { _C(this, 11892, v); }
+
+    /**
+     * Causes all the particles in this node to interpolate towards the end of their lifetime.
+     * **Note:** This only works when used with a {@link ParticleProcessMaterial}. It needs to be manually implemented for custom process shaders.
+     */
+    get interpToEnd(): number { return _C(this, 5152) as number; }
+    set interpToEnd(v: number) { _C(this, 11740, v); }
+
+    /**
+     * If `true`, only the number of particles equal to {@link amount} will be emitted.
+     */
+    get oneShot(): boolean { return _C(this, 5718) as boolean; }
+    set oneShot(v: boolean) { _C(this, 12185, v); }
+
+    /**
+     * Amount of time to preprocess the particles before animation starts. Lets you start the animation some time after particles have started emitting.
+     * **Note:** This can be very expensive if set to a high number as it requires running the particle shader a number of times equal to the {@link fixedFps} (or 30, if {@link fixedFps} is 0) for every second. In extreme cases it can even lead to a GPU crash due to the volume of work done in a single frame.
+     */
+    get preprocess(): number { return _C(this, 5984) as number; }
+    set preprocess(v: number) { _C(this, 12392, v); }
+
+    /**
+     * 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); }
+
+    /**
+     * Time ratio between each emission. If `0`, particles are emitted continuously. If `1`, all particles are emitted simultaneously.
+     */
+    get explosiveness(): number { return _C(this, 4708) as number; }
+    set explosiveness(v: number) { _C(this, 11328, v); }
+
+    /**
+     * Emission 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); }
+
+    /**
+     * 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); }
+
+    /**
+     * Enables particle interpolation, which makes the particle movement smoother when their {@link fixedFps} is lower than the screen refresh rate.
+     */
+    get interpolate(): boolean { return _C(this, 5153) as boolean; }
+    set interpolate(v: boolean) { _C(this, 11741, 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 base diameter for particle collision in meters. If particles appear to sink into the ground when colliding, increase this value. If particles appear to float when colliding, decrease this value. Only effective if {@link ParticleProcessMaterial.collisionMode} is {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT}.
+     * **Note:** Particles always have a spherical collision shape.
+     */
+    get collisionBaseSize(): number { return _C(this, 4195) as number; }
+    set collisionBaseSize(v: number) { _C(this, 10887, v); }
+
+    /**
+     * The {@link AABB} that determines the node's region which needs to be visible on screen for the particle system to be active. {@link GeometryInstance3D.extraCullMargin} is added on each of the AABB's axes. Particle collisions and attraction will only occur within this area.
+     * 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.
+     * **Note:** {@link visibilityAabb} is overridden by {@link GeometryInstance3D.customAabb} if that property is set to a non-default value.
+     */
+    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 GPUParticles3D} 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 GPUParticles3D} 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.
+     * **Note:** {@link DRAW_ORDER_INDEX} is the only option that supports motion vectors for effects like TAA. It is suggested to use this draw order if the particles are opaque to fix ghosting artifacts.
+     */
+    get drawOrder(): DrawOrder { return _C(this, 4568) as DrawOrder; }
+    set drawOrder(v: DrawOrder) { _C(this, 11193, v); }
+
+    /**
+     * The alignment of particles. Use this for billboarding and aligning to velocity.
+     */
+    get transformAlign(): TransformAlign { return _C(this, 6875) as TransformAlign; }
+    set transformAlign(v: TransformAlign) { _C(this, 13135, v); }
+
+    /**
+     * When using transform align local billboard, which axis to use for the billboarding. Supports only X or Y.
+     */
+    get transformAlignAxis(): ParticlesTransformAlignAxis { return _C(this, 6876) as ParticlesTransformAlignAxis; }
+    set transformAlignAxis(v: ParticlesTransformAlignAxis) { _C(this, 13136, v); }
+
+    /**
+     * In the case of billboarded particles, which custom channel to read from to calculate their angle.
+     */
+    get transformAlignChannelFilter(): ParticlesTransformAlignCustomSrc { return _C(this, 6877) as ParticlesTransformAlignCustomSrc; }
+    set transformAlignChannelFilter(v: ParticlesTransformAlignCustomSrc) { _C(this, 13137, v); }
+
+    /**
+     * If `true`, enables particle trails using a mesh skinning system. Designed to work with {@link RibbonTrailMesh} and {@link TubeTrailMesh}.
+     * **Note:** {@link BaseMaterial3D.useParticleTrails} must also be enabled on the particle mesh's material. Otherwise, setting {@link trailEnabled} to `true` will have no effect.
+     * **Note:** Unlike {@link GPUParticles2D}, the number of trail sections and subdivisions is set in the {@link RibbonTrailMesh} or the {@link TubeTrailMesh}'s properties.
+     */
+    get trailEnabled(): boolean { return _C(this, 8370) as boolean; }
+    set trailEnabled(v: boolean) { _C(this, 13127, v); }
+
+    /**
+     * The amount of time the particle's trail should represent (in seconds). Only effective if {@link trailEnabled} is `true`.
+     */
+    get trailLifetime(): number { return _C(this, 6869) as number; }
+    set trailLifetime(v: number) { _C(this, 13128, v); }
+
+    /**
+     * {@link Material} for processing particles. Can be a {@link ParticleProcessMaterial} or a {@link ShaderMaterial}.
+     */
+    get processMaterial(): Material { return _C(this, 6025) as Material; }
+    set processMaterial(v: Material) { _C(this, 12426, v); }
+
+    /**
+     * The number of draw passes when rendering particles.
+     */
+    get drawPasses(): number { return _C(this, 4570) as number; }
+    set drawPasses(v: number) { _C(this, 11195, v); }
+
+    /**
+     * {@link Mesh} that is drawn for the first draw pass.
+     */
+    get drawPass1(): Mesh { return _C(this, 4569, 0) as Mesh; }
+    set drawPass1(v: Mesh) { _C(this, 11194, 0, v); }
+
+    /**
+     * {@link Mesh} that is drawn for the second draw pass.
+     */
+    get drawPass2(): Mesh { return _C(this, 4569, 1) as Mesh; }
+    set drawPass2(v: Mesh) { _C(this, 11194, 1, v); }
+
+    /**
+     * {@link Mesh} that is drawn for the third draw pass.
+     */
+    get drawPass3(): Mesh { return _C(this, 4569, 2) as Mesh; }
+    set drawPass3(v: Mesh) { _C(this, 11194, 2, v); }
+
+    /**
+     * {@link Mesh} that is drawn for the fourth draw pass.
+     */
+    get drawPass4(): Mesh { return _C(this, 4569, 3) as Mesh; }
+    set drawPass4(v: Mesh) { _C(this, 11194, 3, v); }
+
+    get drawSkin(): Skin { return _C(this, 6413) as Skin; }
+    set drawSkin(v: Skin) { _C(this, 12763, v); }
+
+    /**
+     * Maximum number of draw passes supported.
+     */
+    static readonly MAX_DRAW_PASSES = 4;
+
+    /**
+     * Emitted when all active particles have finished processing. To immediately restart the emission cycle, call {@link restart}.
+     * This signal is never emitted when {@link oneShot} is disabled, as particles will be emitted and processed continuously.
+     * **Note:** For {@link oneShot} emitters, due to the particles being computed on the GPU, there may be a short period after receiving the signal during which setting {@link emitting} to `true` will not restart the emission cycle. This delay is avoided by instead calling {@link restart}.
+     */
+    get finished(): Signal<() => void> { return _G(this, 3310) as Signal<() => void>; }
+    set finished(v: (() => void) | null) { _G(this, 3310, v); }
+
+    static readonly name = _R(299, GPUParticles3D);
+}
+
+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 reverse order of remaining lifetime. In other words, the particle with the lowest lifetime is drawn at the front.
+     */
+    DRAW_ORDER_REVERSE_LIFETIME: 2,
+    /**
+     * Particles are drawn in order of depth.
+     */
+    DRAW_ORDER_VIEW_DEPTH: 3,
+} as const;
+
+export type DrawOrder = (typeof DrawOrder)[keyof typeof DrawOrder];
+
+export const EmitFlags = {
+    /**
+     * Particle starts at the specified position.
+     */
+    EMIT_FLAG_POSITION: 1,
+    /**
+     * Particle starts with specified rotation and scale.
+     */
+    EMIT_FLAG_ROTATION_SCALE: 2,
+    /**
+     * Particle starts with the specified velocity vector, which defines the emission direction and speed.
+     */
+    EMIT_FLAG_VELOCITY: 4,
+    /**
+     * Particle starts with specified color.
+     */
+    EMIT_FLAG_COLOR: 8,
+    /**
+     * Particle starts with specified `CUSTOM` data.
+     */
+    EMIT_FLAG_CUSTOM: 16,
+} as const;
+
+export type EmitFlags = (typeof EmitFlags)[keyof typeof EmitFlags];
+
+export const TransformAlign = {
+    /**
+     * Do not align particle transforms relative to the camera or velocity.
+     */
+    TRANSFORM_ALIGN_DISABLED: 0,
+    /**
+     * Align each particle's Z axis to face the camera.
+     */
+    TRANSFORM_ALIGN_Z_BILLBOARD: 1,
+    /**
+     * Align each particle's Y axis to the velocity vector.
+     */
+    TRANSFORM_ALIGN_Y_TO_VELOCITY: 2,
+    /**
+     * Align each particle's Z axis to face the camera and Y axis to the velocity vector.
+     */
+    TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY: 3,
+    /**
+     * Align each particle's Z axis to face the camera, while preserving a given axis (X or Y).
+     */
+    TRANSFORM_ALIGN_LOCAL_BILLBOARD: 4,
+} as const;
+
+export type TransformAlign = (typeof TransformAlign)[keyof typeof TransformAlign];
+

package/gen/classes/GPUParticlesAttractor3D.ts

@@ -0,0 +1,43 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualInstance3D } from './VisualInstance3D.ts';
+
+/**
+ * Particle attractors can be used to attract particles towards the attractor's origin, or to push them away from the attractor's origin.
+ * Particle attractors work in real-time and can be moved, rotated and scaled during gameplay. Unlike collision shapes, non-uniform scaling of attractors is also supported.
+ * Attractors can be temporarily disabled by hiding them, or by setting their {@link strength} to `0.0`.
+ * **Note:** Particle attractors only affect {@link GPUParticles3D}, not {@link CPUParticles3D}.
+ */
+export class GPUParticlesAttractor3D extends VisualInstance3D {
+
+    /**
+     * Adjusts the strength of the attractor. If {@link strength} is negative, particles will be pushed in the opposite direction. Particles will be pushed *away* from the attractor's origin if {@link directionality} is `0.0`, or towards local +Z if {@link directionality} is greater than `0.0`.
+     */
+    get strength(): number { return _C(this, 6567) as number; }
+    set strength(v: number) { _C(this, 12904, v); }
+
+    /**
+     * The particle attractor's attenuation. Higher values result in more gradual pushing of particles as they come closer to the attractor's origin. Zero or negative values will cause particles to be pushed very fast as soon as the touch the attractor's edges.
+     */
+    get attenuation(): number { return _C(this, 3809) as number; }
+    set attenuation(v: number) { _C(this, 10550, v); }
+
+    /**
+     * Adjusts how directional the attractor is. At `0.0`, the attractor is not directional at all: it will attract particles towards its center. At `1.0`, the attractor is fully directional: particles will always be pushed towards local -Z (or +Z if {@link strength} is negative).
+     * **Note:** If {@link directionality} is greater than `0.0`, the direction in which particles are pushed can be changed by rotating the {@link GPUParticlesAttractor3D} node.
+     */
+    get directionality(): number { return _C(this, 4507) as number; }
+    set directionality(v: number) { _C(this, 11114, v); }
+
+    /**
+     * The particle rendering layers ({@link VisualInstance3D.layers}) that will be affected by the attractor. By default, all particles are affected by an attractor.
+     * After configuring particle nodes accordingly, specific layers can be unchecked to prevent certain particles from being affected by attractors. For example, this can be used if you're using an attractor as part of a spell effect but don't want the attractor to affect unrelated weather particles at the same position.
+     * Particle attraction can also be disabled on a per-process material basis by setting {@link ParticleProcessMaterial.attractorInteractionEnabled} on the {@link GPUParticles3D} node.
+     */
+    get cullMask(): number { return _C(this, 4339) as number; }
+    set cullMask(v: number) { _C(this, 10981, v); }
+
+    static readonly name = _R(300, GPUParticlesAttractor3D);
+}