typescript-to-gdscript 0.1.0

package/typings/classes/GPUParticles2D.d.ts

@@ -0,0 +1,220 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D particle emitter. */
+declare class GPUParticles2D extends Node2D {
+  /**
+   * 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 amount_ratio} is decreased.
+   * **Note:** Changing this value will cause the particle system to restart. To avoid this, change {@link amount_ratio} instead.
+   */
+  amount: int;
+  /**
+   * 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 amount_ratio} while emitting does not affect already-emitted particles and doesn't cause the particle system to restart. {@link amount_ratio} can be used to create effects that make the number of emitted particles vary over time.
+   * **Note:** Reducing the {@link amount_ratio} has no performance benefit, since resources need to be allocated and processed for the total {@link amount} of particles regardless of the {@link amount_ratio}. If you don't intend to change the number of particles emitted while the particles are emitting, make sure {@link amount_ratio} is set to `1` and change {@link amount} to your liking instead.
+   */
+  amount_ratio: float;
+  /**
+   * 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.collision_mode} is {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT}.
+   * **Note:** Particles always have a spherical collision shape.
+   */
+  collision_base_size: float;
+  /** Particle draw order. */
+  draw_order: int;
+  /**
+   * If `true`, particles are being emitted. {@link emitting} can be used to start and stop particles from emitting. However, if {@link one_shot} 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 one_shot} 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 one_shot} emitter needs to immediately restart emitting particles once {@link finished} signal is received, consider calling {@link restart} instead of setting {@link emitting}.
+   */
+  emitting: boolean;
+  /**
+   * 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.
+   */
+  explosiveness: float;
+  /**
+   * 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.
+   */
+  fixed_fps: int;
+  /** If `true`, results in fractional delta calculation which has a smoother particles display effect. */
+  fract_delta: boolean;
+  /**
+   * 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.
+   */
+  interp_to_end: float;
+  /**
+   * Enables particle interpolation, which makes the particle movement smoother when their {@link fixed_fps} is lower than the screen refresh rate.
+   */
+  interpolate: boolean;
+  /**
+   * The amount of time each particle will exist (in seconds). The effective emission rate is `(amount * amount_ratio) / lifetime` particles per second.
+   */
+  lifetime: float;
+  /**
+   * 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.
+   */
+  local_coords: boolean;
+  /**
+   * If `true`, only one emission cycle occurs. If set `true` during a cycle, emission will stop at the cycle's end.
+   */
+  one_shot: boolean;
+  /**
+   * 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 fixed_fps} (or 30, if {@link fixed_fps} 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.
+   */
+  preprocess: float;
+  /**
+   * {@link Material} for processing particles. Can be a {@link ParticleProcessMaterial} or a {@link ShaderMaterial}.
+   */
+  process_material: Material | null;
+  /** Emission lifetime randomness ratio. */
+  randomness: float;
+  /**
+   * Sets the random seed used by the particle system. Only effective if {@link use_fixed_seed} is `true`.
+   */
+  seed: int;
+  /** Particle system's running speed scaling ratio. A value of `0` can be used to pause the particles. */
+  speed_scale: float;
+  /**
+   * Path to another {@link GPUParticles2D} node that will be used as a subemitter (see {@link ParticleProcessMaterial.sub_emitter_mode}). Subemitters can be used to achieve effects such as fireworks, sparks on collision, bubbles popping into water drops, and more.
+   * **Note:** When {@link sub_emitter} is set, the target {@link GPUParticles2D} node will no longer emit particles on its own.
+   */
+  sub_emitter: NodePath;
+  /**
+   * 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.particles_animation} and set {@link CanvasItemMaterial.particles_anim_h_frames}, {@link CanvasItemMaterial.particles_anim_v_frames}, and {@link CanvasItemMaterial.particles_anim_loop} to match the flipbook texture.
+   */
+  texture: Texture2D | null;
+  /**
+   * 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 trail_sections} and {@link trail_section_subdivisions} properties.
+   */
+  trail_enabled: boolean;
+  /**
+   * The amount of time the particle's trail should represent (in seconds). Only effective if {@link trail_enabled} is `true`.
+   */
+  trail_lifetime: float;
+  /**
+   * 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 trail_sections}. Only effective if {@link trail_enabled} is `true`.
+   */
+  trail_section_subdivisions: int;
+  /**
+   * 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 trail_section_subdivisions}. Only effective if {@link trail_enabled} is `true`.
+   */
+  trail_sections: int;
+  /**
+   * 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.
+   */
+  use_fixed_seed: boolean;
+  /**
+   * 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.
+   */
+  visibility_rect: Rect2;
+  set_amount(value: int): void;
+  get_amount(): int;
+  set_amount_ratio(value: float): void;
+  get_amount_ratio(): float;
+  set_collision_base_size(value: float): void;
+  get_collision_base_size(): float;
+  set_draw_order(value: int): void;
+  get_draw_order(): int;
+  set_emitting(value: boolean): void;
+  is_emitting(): boolean;
+  set_explosiveness_ratio(value: float): void;
+  get_explosiveness_ratio(): float;
+  set_fixed_fps(value: int): void;
+  get_fixed_fps(): int;
+  set_fractional_delta(value: boolean): void;
+  get_fractional_delta(): boolean;
+  set_interp_to_end(value: float): void;
+  get_interp_to_end(): float;
+  set_interpolate(value: boolean): void;
+  get_interpolate(): boolean;
+  set_lifetime(value: float): void;
+  get_lifetime(): float;
+  set_use_local_coordinates(value: boolean): void;
+  get_use_local_coordinates(): boolean;
+  set_one_shot(value: boolean): void;
+  get_one_shot(): boolean;
+  set_pre_process_time(value: float): void;
+  get_pre_process_time(): float;
+  set_process_material(value: Material | null): void;
+  get_process_material(): Material | null;
+  set_randomness_ratio(value: float): void;
+  get_randomness_ratio(): float;
+  set_seed(value: int): void;
+  get_seed(): int;
+  set_speed_scale(value: float): void;
+  get_speed_scale(): float;
+  set_sub_emitter(value: NodePath | string): void;
+  get_sub_emitter(): NodePath;
+  set_texture(value: Texture2D | null): void;
+  get_texture(): Texture2D | null;
+  set_trail_enabled(value: boolean): void;
+  is_trail_enabled(): boolean;
+  set_trail_lifetime(value: float): void;
+  get_trail_lifetime(): float;
+  set_trail_section_subdivisions(value: int): void;
+  get_trail_section_subdivisions(): int;
+  set_trail_sections(value: int): void;
+  get_trail_sections(): int;
+  set_use_fixed_seed(value: boolean): void;
+  get_use_fixed_seed(): boolean;
+  set_visibility_rect(value: Rect2 | Rect2i): void;
+  get_visibility_rect(): Rect2;
+
+  /**
+   * 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.
+   */
+  capture_rect(): Rect2;
+  /** Sets this node's properties to match a given {@link CPUParticles2D} node. */
+  convert_from_particles(particles: Node): void;
+  /**
+   * 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 emit_particle} is only supported on the Forward+ and Mobile rendering methods, not Compatibility.
+   */
+  emit_particle(xform: Transform2D, velocity: Vector2 | Vector2i, color: Color, custom: Color, flags: int): void;
+  /**
+   * Requests the particles to process for extra process time during a single frame.
+   * Useful for particle playback, if used in combination with {@link use_fixed_seed} or by calling {@link restart} with parameter `keep_seed` set to `true`.
+   */
+  request_particles_process(process_time: float): void;
+  /**
+   * 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 one_shot} emitters.
+   * If `keep_seed` is `true`, the current random seed will be preserved. Useful for seeking and playback.
+   */
+  restart(keep_seed?: boolean): void;
+
+  /**
+   * Emitted when all active particles have finished processing. To immediately restart the emission cycle, call {@link restart}.
+   * This signal is never emitted when {@link one_shot} is disabled, as particles will be emitted and processed continuously.
+   * **Note:** For {@link one_shot} 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}.
+   */
+  finished: Signal<[]>;
+
+  // enum DrawOrder
+  /** Particles are drawn in the order emitted. */
+  static readonly DRAW_ORDER_INDEX: int;
+  /**
+   * Particles are drawn in order of remaining lifetime. In other words, the particle with the highest lifetime is drawn at the front.
+   */
+  static readonly DRAW_ORDER_LIFETIME: int;
+  /**
+   * Particles are drawn in reverse order of remaining lifetime. In other words, the particle with the lowest lifetime is drawn at the front.
+   */
+  static readonly DRAW_ORDER_REVERSE_LIFETIME: int;
+  // enum EmitFlags
+  /** Particle starts at the specified position. */
+  static readonly EMIT_FLAG_POSITION: int;
+  /** Particle starts with specified rotation and scale. */
+  static readonly EMIT_FLAG_ROTATION_SCALE: int;
+  /** Particle starts with the specified velocity vector, which defines the emission direction and speed. */
+  static readonly EMIT_FLAG_VELOCITY: int;
+  /** Particle starts with specified color. */
+  static readonly EMIT_FLAG_COLOR: int;
+  /** Particle starts with specified `CUSTOM` data. */
+  static readonly EMIT_FLAG_CUSTOM: int;
+}

package/typings/classes/GPUParticles3D.d.ts

@@ -0,0 +1,239 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D particle emitter. */
+declare class GPUParticles3D extends GeometryInstance3D {
+  /**
+   * 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 amount_ratio} is decreased.
+   * **Note:** Changing this value will cause the particle system to restart. To avoid this, change {@link amount_ratio} instead.
+   */
+  amount: int;
+  /**
+   * 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 amount_ratio} while emitting does not affect already-emitted particles and doesn't cause the particle system to restart. {@link amount_ratio} can be used to create effects that make the number of emitted particles vary over time.
+   * **Note:** Reducing the {@link amount_ratio} has no performance benefit, since resources need to be allocated and processed for the total {@link amount} of particles regardless of the {@link amount_ratio}. If you don't intend to change the number of particles emitted while the particles are emitting, make sure {@link amount_ratio} is set to `1` and change {@link amount} to your liking instead.
+   */
+  amount_ratio: float;
+  /**
+   * 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.collision_mode} is {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT}.
+   * **Note:** Particles always have a spherical collision shape.
+   */
+  collision_base_size: float;
+  /**
+   * 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.
+   */
+  draw_order: int;
+  /** {@link Mesh} that is drawn for the first draw pass. */
+  draw_pass_1: Mesh | null;
+  /** {@link Mesh} that is drawn for the second draw pass. */
+  draw_pass_2: Mesh | null;
+  /** {@link Mesh} that is drawn for the third draw pass. */
+  draw_pass_3: Mesh | null;
+  /** {@link Mesh} that is drawn for the fourth draw pass. */
+  draw_pass_4: Mesh | null;
+  /** The number of draw passes when rendering particles. */
+  draw_passes: int;
+  draw_skin: Skin | null;
+  /**
+   * If `true`, particles are being emitted. {@link emitting} can be used to start and stop particles from emitting. However, if {@link one_shot} 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 one_shot} 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 one_shot} emitter needs to immediately restart emitting particles once {@link finished} signal is received, consider calling {@link restart} instead of setting {@link emitting}.
+   */
+  emitting: boolean;
+  /**
+   * Time ratio between each emission. If `0`, particles are emitted continuously. If `1`, all particles are emitted simultaneously.
+   */
+  explosiveness: float;
+  /**
+   * 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.
+   */
+  fixed_fps: int;
+  /** If `true`, results in fractional delta calculation which has a smoother particles display effect. */
+  fract_delta: boolean;
+  /**
+   * 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.
+   */
+  interp_to_end: float;
+  /**
+   * Enables particle interpolation, which makes the particle movement smoother when their {@link fixed_fps} is lower than the screen refresh rate.
+   */
+  interpolate: boolean;
+  /**
+   * The amount of time each particle will exist (in seconds). The effective emission rate is `(amount * amount_ratio) / lifetime` particles per second.
+   */
+  lifetime: float;
+  /**
+   * 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.
+   */
+  local_coords: boolean;
+  /** If `true`, only the number of particles equal to {@link amount} will be emitted. */
+  one_shot: boolean;
+  /**
+   * 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 fixed_fps} (or 30, if {@link fixed_fps} 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.
+   */
+  preprocess: float;
+  /**
+   * {@link Material} for processing particles. Can be a {@link ParticleProcessMaterial} or a {@link ShaderMaterial}.
+   */
+  process_material: Material | null;
+  /** Emission randomness ratio. */
+  randomness: float;
+  /**
+   * Sets the random seed used by the particle system. Only effective if {@link use_fixed_seed} is `true`.
+   */
+  seed: int;
+  /** Speed scaling ratio. A value of `0` can be used to pause the particles. */
+  speed_scale: float;
+  /**
+   * Path to another {@link GPUParticles3D} node that will be used as a subemitter (see {@link ParticleProcessMaterial.sub_emitter_mode}). Subemitters can be used to achieve effects such as fireworks, sparks on collision, bubbles popping into water drops, and more.
+   * **Note:** When {@link sub_emitter} is set, the target {@link GPUParticles3D} node will no longer emit particles on its own.
+   */
+  sub_emitter: NodePath;
+  /**
+   * If `true`, enables particle trails using a mesh skinning system. Designed to work with {@link RibbonTrailMesh} and {@link TubeTrailMesh}.
+   * **Note:** {@link BaseMaterial3D.use_particle_trails} must also be enabled on the particle mesh's material. Otherwise, setting {@link trail_enabled} 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.
+   */
+  trail_enabled: boolean;
+  /**
+   * The amount of time the particle's trail should represent (in seconds). Only effective if {@link trail_enabled} is `true`.
+   */
+  trail_lifetime: float;
+  transform_align: int;
+  /**
+   * 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.
+   */
+  use_fixed_seed: boolean;
+  /**
+   * 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.extra_cull_margin} 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 visibility_aabb} is overridden by {@link GeometryInstance3D.custom_aabb} if that property is set to a non-default value.
+   */
+  visibility_aabb: AABB;
+  set_amount(value: int): void;
+  get_amount(): int;
+  set_amount_ratio(value: float): void;
+  get_amount_ratio(): float;
+  set_collision_base_size(value: float): void;
+  get_collision_base_size(): float;
+  set_draw_order(value: int): void;
+  get_draw_order(): int;
+  set_draw_passes(value: int): void;
+  get_draw_passes(): int;
+  set_skin(value: Skin | null): void;
+  get_skin(): Skin | null;
+  set_emitting(value: boolean): void;
+  is_emitting(): boolean;
+  set_explosiveness_ratio(value: float): void;
+  get_explosiveness_ratio(): float;
+  set_fixed_fps(value: int): void;
+  get_fixed_fps(): int;
+  set_fractional_delta(value: boolean): void;
+  get_fractional_delta(): boolean;
+  set_interp_to_end(value: float): void;
+  get_interp_to_end(): float;
+  set_interpolate(value: boolean): void;
+  get_interpolate(): boolean;
+  set_lifetime(value: float): void;
+  get_lifetime(): float;
+  set_use_local_coordinates(value: boolean): void;
+  get_use_local_coordinates(): boolean;
+  set_one_shot(value: boolean): void;
+  get_one_shot(): boolean;
+  set_pre_process_time(value: float): void;
+  get_pre_process_time(): float;
+  set_process_material(value: Material | null): void;
+  get_process_material(): Material | null;
+  set_randomness_ratio(value: float): void;
+  get_randomness_ratio(): float;
+  set_seed(value: int): void;
+  get_seed(): int;
+  set_speed_scale(value: float): void;
+  get_speed_scale(): float;
+  set_sub_emitter(value: NodePath | string): void;
+  get_sub_emitter(): NodePath;
+  set_trail_enabled(value: boolean): void;
+  is_trail_enabled(): boolean;
+  set_trail_lifetime(value: float): void;
+  get_trail_lifetime(): float;
+  set_transform_align(value: int): void;
+  get_transform_align(): int;
+  set_use_fixed_seed(value: boolean): void;
+  get_use_fixed_seed(): boolean;
+  set_visibility_aabb(value: AABB): void;
+  get_visibility_aabb(): AABB;
+
+  /**
+   * Returns the axis-aligned bounding box that contains all the particles that are active in the current frame.
+   */
+  capture_aabb(): AABB;
+  /** Sets this node's properties to match a given {@link CPUParticles3D} node. */
+  convert_from_particles(particles: Node): void;
+  /**
+   * 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 emit_particle} is only supported on the Forward+ and Mobile rendering methods, not Compatibility.
+   */
+  emit_particle(xform: Transform3D | Projection, velocity: Vector3 | Vector3i, color: Color, custom: Color, flags: int): void;
+  /** Returns the {@link Mesh} that is drawn at index `pass`. */
+  get_draw_pass_mesh(pass: int): Mesh | null;
+  /**
+   * Requests the particles to process for extra process time during a single frame.
+   * Useful for particle playback, if used in combination with {@link use_fixed_seed} or by calling {@link restart} with parameter `keep_seed` set to `true`.
+   */
+  request_particles_process(process_time: float): void;
+  /**
+   * 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 one_shot} emitters.
+   * If `keep_seed` is `true`, the current random seed will be preserved. Useful for seeking and playback.
+   */
+  restart(keep_seed?: boolean): void;
+  /** Sets the {@link Mesh} that is drawn at index `pass`. */
+  set_draw_pass_mesh(pass: int, mesh: Mesh): void;
+
+  /**
+   * Emitted when all active particles have finished processing. To immediately restart the emission cycle, call {@link restart}.
+   * This signal is never emitted when {@link one_shot} is disabled, as particles will be emitted and processed continuously.
+   * **Note:** For {@link one_shot} 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}.
+   */
+  finished: Signal<[]>;
+
+  // enum DrawOrder
+  /** Particles are drawn in the order emitted. */
+  static readonly DRAW_ORDER_INDEX: int;
+  /**
+   * Particles are drawn in order of remaining lifetime. In other words, the particle with the highest lifetime is drawn at the front.
+   */
+  static readonly DRAW_ORDER_LIFETIME: int;
+  /**
+   * Particles are drawn in reverse order of remaining lifetime. In other words, the particle with the lowest lifetime is drawn at the front.
+   */
+  static readonly DRAW_ORDER_REVERSE_LIFETIME: int;
+  /** Particles are drawn in order of depth. */
+  static readonly DRAW_ORDER_VIEW_DEPTH: int;
+  // enum EmitFlags
+  /** Particle starts at the specified position. */
+  static readonly EMIT_FLAG_POSITION: int;
+  /** Particle starts with specified rotation and scale. */
+  static readonly EMIT_FLAG_ROTATION_SCALE: int;
+  /** Particle starts with the specified velocity vector, which defines the emission direction and speed. */
+  static readonly EMIT_FLAG_VELOCITY: int;
+  /** Particle starts with specified color. */
+  static readonly EMIT_FLAG_COLOR: int;
+  /** Particle starts with specified `CUSTOM` data. */
+  static readonly EMIT_FLAG_CUSTOM: int;
+  // enum TransformAlign
+  /** Do not align particle transforms relative to the camera or velocity. */
+  static readonly TRANSFORM_ALIGN_DISABLED: int;
+  /** Align each particle's Z axis to face the camera. */
+  static readonly TRANSFORM_ALIGN_Z_BILLBOARD: int;
+  /** Align each particle's Y axis to the velocity vector. */
+  static readonly TRANSFORM_ALIGN_Y_TO_VELOCITY: int;
+  /** Align each particle's Z axis to face the camera and Y axis to the velocity vector. */
+  static readonly TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY: int;
+
+  /** Maximum number of draw passes supported. */
+  static readonly MAX_DRAW_PASSES: int;
+}

package/typings/classes/GPUParticlesAttractor3D.d.ts

@@ -0,0 +1,33 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for 3D particle attractors. */
+declare class GPUParticlesAttractor3D extends VisualInstance3D {
+  /**
+   * 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.
+   */
+  attenuation: float;
+  /**
+   * 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.attractor_interaction_enabled} on the {@link GPUParticles3D} node.
+   */
+  cull_mask: int;
+  /**
+   * 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.
+   */
+  directionality: float;
+  /**
+   * 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`.
+   */
+  strength: float;
+  set_attenuation(value: float): void;
+  get_attenuation(): float;
+  set_cull_mask(value: int): void;
+  get_cull_mask(): int;
+  set_directionality(value: float): void;
+  get_directionality(): float;
+  set_strength(value: float): void;
+  get_strength(): float;
+}

package/typings/classes/GPUParticlesAttractorBox3D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A box-shaped attractor that influences particles from {@link GPUParticles3D} nodes. */
+declare class GPUParticlesAttractorBox3D extends GPUParticlesAttractor3D {
+  /** The attractor box's size in 3D units. */
+  size: Vector3;
+  set_size(value: Vector3 | Vector3i): void;
+  get_size(): Vector3;
+}

package/typings/classes/GPUParticlesAttractorSphere3D.d.ts

@@ -0,0 +1,13 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A spheroid-shaped attractor that influences particles from {@link GPUParticles3D} nodes. */
+declare class GPUParticlesAttractorSphere3D extends GPUParticlesAttractor3D {
+  /**
+   * The attractor sphere's radius in 3D units.
+   * **Note:** Stretched ellipses can be obtained by using non-uniform scaling on the {@link GPUParticlesAttractorSphere3D} node.
+   */
+  radius: float;
+  set_radius(value: float): void;
+  get_radius(): float;
+}

package/typings/classes/GPUParticlesAttractorVectorField3D.d.ts

@@ -0,0 +1,19 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A box-shaped attractor with varying directions and strengths defined in it that influences particles from {@link GPUParticles3D} nodes.
+ */
+declare class GPUParticlesAttractorVectorField3D extends GPUParticlesAttractor3D {
+  /** The size of the vector field box in 3D units. */
+  size: Vector3;
+  /**
+   * The 3D texture to be used. Values are linearly interpolated between the texture's pixels.
+   * **Note:** To get better performance, the 3D texture's resolution should reflect the {@link size} of the attractor. Since particle attraction is usually low-frequency data, the texture can be kept at a low resolution such as 64×64×64.
+   */
+  texture: Texture3D | null;
+  set_size(value: Vector3 | Vector3i): void;
+  get_size(): Vector3;
+  set_texture(value: Texture3D | null): void;
+  get_texture(): Texture3D | null;
+}

package/typings/classes/GPUParticlesCollision3D.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for 3D particle collision shapes affecting {@link GPUParticles3D} nodes. */
+declare class GPUParticlesCollision3D extends VisualInstance3D {
+  /**
+   * The particle rendering layers ({@link VisualInstance3D.layers}) that will be affected by the collision shape. By default, all particles that have {@link ParticleProcessMaterial.collision_mode} set to {@link ParticleProcessMaterial.COLLISION_RIGID} or {@link ParticleProcessMaterial.COLLISION_HIDE_ON_CONTACT} will be affected by a collision shape.
+   * After configuring particle nodes accordingly, specific layers can be unchecked to prevent certain particles from being affected by colliders. For example, this can be used if you're using a collider as part of a spell effect but don't want the collider to affect unrelated weather particles at the same position.
+   * Particle collision can also be disabled on a per-process material basis by setting {@link ParticleProcessMaterial.collision_mode} on the {@link GPUParticles3D} node.
+   */
+  cull_mask: int;
+  set_cull_mask(value: int): void;
+  get_cull_mask(): int;
+}

package/typings/classes/GPUParticlesCollisionBox3D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A box-shaped 3D particle collision shape affecting {@link GPUParticles3D} nodes. */
+declare class GPUParticlesCollisionBox3D extends GPUParticlesCollision3D {
+  /** The collision box's size in 3D units. */
+  size: Vector3;
+  set_size(value: Vector3 | Vector3i): void;
+  get_size(): Vector3;
+}

package/typings/classes/GPUParticlesCollisionHeightField3D.d.ts

@@ -0,0 +1,75 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A real-time heightmap-shaped 3D particle collision shape affecting {@link GPUParticles3D} nodes. */
+declare class GPUParticlesCollisionHeightField3D extends GPUParticlesCollision3D {
+  /**
+   * If `true`, the {@link GPUParticlesCollisionHeightField3D} will follow the current camera in global space. The {@link GPUParticlesCollisionHeightField3D} does not need to be a child of the {@link Camera3D} node for this to work.
+   * Following the camera has a performance cost, as it will force the heightmap to update whenever the camera moves. Consider lowering {@link resolution} to improve performance if {@link follow_camera_enabled} is `true`.
+   */
+  follow_camera_enabled: boolean;
+  /**
+   * The visual layers to account for when updating the heightmap. Only {@link MeshInstance3D}s whose {@link VisualInstance3D.layers} match with this {@link heightfield_mask} will be included in the heightmap collision update. By default, all 20 user-visible layers are taken into account for updating the heightmap collision.
+   * **Note:** Since the {@link heightfield_mask} allows for 32 layers to be stored in total, there are an additional 12 layers that are only used internally by the engine and aren't exposed in the editor. Setting {@link heightfield_mask} using a script allows you to toggle those reserved layers, which can be useful for editor plugins.
+   * To adjust {@link heightfield_mask} more easily using a script, use {@link get_heightfield_mask_value} and {@link set_heightfield_mask_value}.
+   */
+  heightfield_mask: int;
+  /**
+   * Higher resolutions can represent small details more accurately in large scenes, at the cost of lower performance. If {@link update_mode} is {@link UPDATE_MODE_ALWAYS}, consider using the lowest resolution possible.
+   */
+  resolution: int;
+  /**
+   * The collision heightmap's size in 3D units. To improve heightmap quality, {@link size} should be set as small as possible while covering the parts of the scene you need.
+   */
+  size: Vector3;
+  /** The update policy to use for the generated heightmap. */
+  update_mode: int;
+  set_follow_camera_enabled(value: boolean): void;
+  is_follow_camera_enabled(): boolean;
+  set_heightfield_mask(value: int): void;
+  get_heightfield_mask(): int;
+  set_resolution(value: int): void;
+  get_resolution(): int;
+  set_size(value: Vector3 | Vector3i): void;
+  get_size(): Vector3;
+  set_update_mode(value: int): void;
+  get_update_mode(): int;
+
+  /**
+   * Returns `true` if the specified layer of the {@link heightfield_mask} is enabled, given a `layer_number` between `1` and `20`, inclusive.
+   */
+  get_heightfield_mask_value(layer_number: int): boolean;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link heightfield_mask}, given a `layer_number` between `1` and `20`, inclusive.
+   */
+  set_heightfield_mask_value(layer_number: int, value: boolean): void;
+
+  // enum Resolution
+  /**
+   * Generate a 256×256 heightmap. Intended for small-scale scenes, or larger scenes with no distant particles.
+   */
+  static readonly RESOLUTION_256: int;
+  /**
+   * Generate a 512×512 heightmap. Intended for medium-scale scenes, or larger scenes with no distant particles.
+   */
+  static readonly RESOLUTION_512: int;
+  /** Generate a 1024×1024 heightmap. Intended for large scenes with distant particles. */
+  static readonly RESOLUTION_1024: int;
+  /** Generate a 2048×2048 heightmap. Intended for very large scenes with distant particles. */
+  static readonly RESOLUTION_2048: int;
+  /** Generate a 4096×4096 heightmap. Intended for huge scenes with distant particles. */
+  static readonly RESOLUTION_4096: int;
+  /** Generate a 8192×8192 heightmap. Intended for gigantic scenes with distant particles. */
+  static readonly RESOLUTION_8192: int;
+  /** Represents the size of the {@link Resolution} enum. */
+  static readonly RESOLUTION_MAX: int;
+  // enum UpdateMode
+  /**
+   * Only update the heightmap when the {@link GPUParticlesCollisionHeightField3D} node is moved, or when the camera moves if {@link follow_camera_enabled} is `true`. An update can be forced by slightly moving the {@link GPUParticlesCollisionHeightField3D} in any direction, or by calling {@link RenderingServer.particles_collision_height_field_update}.
+   */
+  static readonly UPDATE_MODE_WHEN_MOVED: int;
+  /**
+   * Update the heightmap every frame. This has a significant performance cost. This update should only be used when geometry that particles can collide with changes significantly during gameplay.
+   */
+  static readonly UPDATE_MODE_ALWAYS: int;
+}