Index · Object → RefCounted → Resource → Material → ParticleProcessMaterial

ParticleProcessMaterial

Holds a particle configuration for GPUParticles2D or GPUParticles3D nodes.

Class Description

ParticleProcessMaterial defines particle properties and behavior. It is used in the process_material of the GPUParticles2D and GPUParticles3D nodes. Some of this material's properties are applied to each particle when emitted, while others can have a CurveTexture or a GradientTexture1D applied to vary numerical or color values over the lifetime of the particle.

Properties

var alpha_curve: Texture2D

The alpha value of each particle's color will be multiplied by this CurveTexture over its lifetime.

Note: alpha_curve multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALPHA *= COLOR.a; must be inserted in the shader's fragment() function. Otherwise, alpha_curve will have no visible effect.

var angle_curve: Texture2D

Each particle's rotation will be animated along this CurveTexture.

var angle_max: float = 0.0

Maximum initial rotation applied to each particle, in degrees.

Only applied when particle_flag_disable_z or particle_flag_rotate_y are true or the BaseMaterial3D being used to draw the particle is using BaseMaterial3D.BILLBOARD_PARTICLES.

var angle_min: float = 0.0

Minimum equivalent of angle_max.

var angular_velocity_curve: Texture2D

Each particle's angular velocity (rotation speed) will vary along this CurveTexture over its lifetime.

var angular_velocity_max: float = 0.0

Maximum initial angular velocity (rotation speed) applied to each particle in degrees per second.

Only applied when particle_flag_disable_z or particle_flag_rotate_y are true or the BaseMaterial3D being used to draw the particle is using BaseMaterial3D.BILLBOARD_PARTICLES.

var angular_velocity_min: float = 0.0

Minimum equivalent of angular_velocity_max.

var anim_offset_curve: Texture2D

Each particle's animation offset will vary along this CurveTexture.

var anim_offset_max: float = 0.0

Maximum animation offset that corresponds to frame index in the texture. 0 is the first frame, 1 is the last one. See CanvasItemMaterial.particles_animation.

var anim_offset_min: float = 0.0

Minimum equivalent of anim_offset_max.

var anim_speed_curve: Texture2D

Each particle's animation speed will vary along this CurveTexture.

var anim_speed_max: float = 0.0

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 CanvasItemMaterial.particles_anim_loop property if you want the animation to repeat.

var anim_speed_min: float = 0.0

Minimum equivalent of anim_speed_max.

var attractor_interaction_enabled: bool = true

If true, interaction with particle attractors is enabled. In 3D, attraction only occurs within the area defined by the GPUParticles3D node's GPUParticles3D.visibility_aabb.

var collision_bounce: float

The particles' bounciness. Values range from 0 (no bounce) to 1 (full bounciness). Only effective if collision_mode is COLLISION_RIGID.

var collision_friction: float

The particles' friction. Values range from 0 (frictionless) to 1 (maximum friction). Only effective if collision_mode is COLLISION_RIGID.

var collision_mode: ParticleProcessMaterial.CollisionMode = 0

The particles' collision mode.

Note: 3D Particles can only collide with GPUParticlesCollision3D nodes, not PhysicsBody3D nodes. To make particles collide with various objects, you can add GPUParticlesCollision3D nodes as children of PhysicsBody3D nodes. In 3D, collisions only occur within the area defined by the GPUParticles3D node's GPUParticles3D.visibility_aabb.

Note: 2D Particles can only collide with LightOccluder2D nodes, not PhysicsBody2D nodes.

var collision_use_scale: bool = false

If true, GPUParticles3D.collision_base_size is multiplied by the particle's effective scale (see scale_min, scale_max, scale_curve, and scale_over_velocity_curve).

var color: Color = Color(1, 1, 1, 1)

Each particle's initial color. If the GPUParticles2D's texture is defined, it will be multiplied by this color.

Note: color multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, color will have no visible effect.

var color_initial_ramp: Texture2D

Each particle's initial color will vary along this GradientTexture1D (multiplied with color).

Note: color_initial_ramp multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, color_initial_ramp will have no visible effect.

var color_ramp: Texture2D

Each particle's color will vary along this GradientTexture1D over its lifetime (multiplied with color).

Note: color_ramp multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, color_ramp will have no visible effect.

var damping_curve: Texture2D

Damping will vary along this CurveTexture.

var damping_max: float = 0.0

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.

var damping_min: float = 0.0

Minimum equivalent of damping_max.

var direction: Vector3 = Vector3(1, 0, 0)

Unit vector specifying the particles' emission direction.

var directional_velocity_curve: Texture2D

A curve that specifies the velocity along each of the axes of the particle system along its lifetime.

Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.

var directional_velocity_max: float

Maximum directional velocity value, which is multiplied by directional_velocity_curve.

Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.

var directional_velocity_min: float

Minimum directional velocity value, which is multiplied by directional_velocity_curve.

Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.

var emission_box_extents: Vector3

The box's extents if emission_shape is set to EMISSION_SHAPE_BOX.

Note: emission_box_extents starts from the center point and applies the X, Y, and Z values in both directions. The size is twice the area of the extents.

var emission_color_texture: Texture2D

Particle color will be modulated by color determined by sampling this texture at the same point as the emission_point_texture.

Note: emission_color_texture multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, emission_color_texture will have no visible effect.

var emission_curve: Texture2D

Each particle's color will be multiplied by this CurveTexture over its lifetime.

Note: emission_curve multiplies the particle mesh's vertex colors. To have a visible effect on a BaseMaterial3D, BaseMaterial3D.vertex_color_use_as_albedo must be true. For a ShaderMaterial, ALBEDO *= COLOR.rgb; must be inserted in the shader's fragment() function. Otherwise, emission_curve will have no visible effect.

var emission_normal_texture: Texture2D

Particle velocity and rotation will be set by sampling this texture at the same point as the emission_point_texture. Used only in EMISSION_SHAPE_DIRECTED_POINTS. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar.

var emission_point_count: int

The number of emission points if emission_shape is set to EMISSION_SHAPE_POINTS or EMISSION_SHAPE_DIRECTED_POINTS.

var emission_point_texture: Texture2D

Particles will be emitted at positions determined by sampling this texture at a random position. Used with EMISSION_SHAPE_POINTS and EMISSION_SHAPE_DIRECTED_POINTS. Can be created automatically from mesh or node by selecting "Create Emission Points from Mesh/Node" under the "Particles" tool in the toolbar.

var emission_ring_axis: Vector3

The axis of the ring when using the emitter EMISSION_SHAPE_RING.

var emission_ring_cone_angle: float

The angle of the cone when using the emitter EMISSION_SHAPE_RING. The default angle of 90 degrees results in a ring, while an angle of 0 degrees results in a cone. Intermediate values will result in a ring where one end is larger than the other.

Note: Depending on emission_ring_height, the angle may be clamped if the ring's end is reached to form a perfect cone.

var emission_ring_height: float

The height of the ring when using the emitter EMISSION_SHAPE_RING.

var emission_ring_inner_radius: float

The inner radius of the ring when using the emitter EMISSION_SHAPE_RING.

var emission_ring_radius: float

The radius of the ring when using the emitter EMISSION_SHAPE_RING.

var emission_shape: ParticleProcessMaterial.EmissionShape = 0

Particles will be emitted inside this region.

var emission_shape_offset: Vector3 = Vector3(0, 0, 0)

The offset for the emission_shape, in local space.

var emission_shape_scale: Vector3 = Vector3(1, 1, 1)

The scale of the emission_shape, in local space.

var emission_sphere_radius: float

The sphere's radius if emission_shape is set to EMISSION_SHAPE_SPHERE.

var flatness: float = 0.0

Amount of spread along the Y axis.

var gravity: Vector3 = Vector3(0, -9.8, 0)

Gravity applied to every particle.

var hue_variation_curve: Texture2D

Each particle's hue will vary along this CurveTexture.

var hue_variation_max: float = 0.0

Maximum initial hue variation applied to each particle. It will shift the particle color's hue.

var hue_variation_min: float = 0.0

Minimum equivalent of hue_variation_max.

var inherit_velocity_ratio: float = 0.0

Percentage of the velocity of the respective GPUParticles2D or GPUParticles3D inherited by each particle when spawning.

var initial_velocity_max: float = 0.0

Maximum initial velocity magnitude for each particle. Direction comes from direction and spread.

var initial_velocity_min: float = 0.0

Minimum equivalent of initial_velocity_max.

var lifetime_randomness: float = 0.0

Particle lifetime randomness ratio. The equation for the lifetime of a particle is lifetime * (1.0 - randf() * lifetime_randomness). For example, a lifetime_randomness of 0.4 scales the lifetime between 0.6 to 1.0 of its original value.

var linear_accel_curve: Texture2D

Each particle's linear acceleration will vary along this CurveTexture.

var linear_accel_max: float = 0.0

Maximum linear acceleration applied to each particle in the direction of motion.

var linear_accel_min: float = 0.0

Minimum equivalent of linear_accel_max.

var orbit_velocity_curve: Texture2D

Each particle's orbital velocity will vary along this CurveTexture.

Note: For 3D orbital velocity, use a CurveXYZTexture.

Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.

var orbit_velocity_max: float = 0.0

Maximum orbital velocity applied to each particle. Makes the particles circle around origin. Specified in number of full rotations around origin per second.

Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.

var orbit_velocity_min: float = 0.0

Minimum equivalent of orbit_velocity_max.

Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.

var particle_flag_align_y: bool = false

Align Y axis of particle with the direction of its velocity.

var particle_flag_damping_as_friction: bool = false

Changes the behavior of the damping properties from a linear deceleration to a deceleration based on speed percentage.

var particle_flag_disable_z: bool = false

If true, particles will not move on the z axis.

var particle_flag_inherit_emitter_scale: bool = false

If true, particles will inherit the scale of the emitter.

Note: This has no effect when GPUParticles3D.local_coords is true, since particles in local space are already affected by the emitter's scale.

var particle_flag_rotate_y: bool = false

If true, particles rotate around Y axis by angle_min.

var radial_accel_curve: Texture2D

Each particle's radial acceleration will vary along this CurveTexture.

var radial_accel_max: float = 0.0

Maximum radial acceleration applied to each particle. Makes particle accelerate away from the origin or towards it if negative.

var radial_accel_min: float = 0.0

Minimum equivalent of radial_accel_max.

var radial_velocity_curve: Texture2D

A CurveTexture that defines the velocity over the particle's lifetime away (or toward) the velocity_pivot.

Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.

var radial_velocity_max: float = 0.0

Maximum radial velocity applied to each particle. Makes particles move away from the velocity_pivot, or toward it if negative.

Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.

var radial_velocity_min: float = 0.0

Minimum radial velocity applied to each particle. Makes particles move away from the velocity_pivot, or toward it if negative.

Note: Animated velocities will not be affected by damping, use velocity_limit_curve instead.

var rotation_3d_max: Vector3

The maximum 3D orientation, in degrees. Works only in 3D and if use_rotation_3d is enabled.

var rotation_3d_min: Vector3

The minimum 3D orientation, in degrees. Works only in 3D and if use_rotation_3d is enabled.

var rotation_velocity_3d_curve: Texture2D

Rotation velocity curve over lifetime, per-axis. Enable use_rotation_velocity_3d to use this.

var rotation_velocity_3d_max: Vector3

Maximum 3D rotation velocity on the particle's local axis. Enable use_rotation_velocity_3d to use this.

var rotation_velocity_3d_min: Vector3

Minimum 3D rotation velocity on the particle's local axis. Enable use_rotation_velocity_3d to use this.

var scale_3d_max: Vector3

The maximum value of the random scale vector for each particle.

Works only if use_scale_3d is enabled.

var scale_3d_min: Vector3

The minimum value of the random scale vector for each particle.

Works only if use_scale_3d is enabled.

var scale_curve: Texture2D

Each particle's scale will vary along this CurveTexture over its lifetime. If a CurveXYZTexture is supplied instead, the scale will be separated per-axis.

var scale_max: float = 1.0

Maximum initial scale applied to each particle.

var scale_min: float = 1.0

Minimum equivalent of scale_max.

var scale_over_velocity_curve: Texture2D

Either a CurveTexture or a CurveXYZTexture that scales each particle based on its velocity.

var scale_over_velocity_max: float = 0.0

Maximum velocity value reference for scale_over_velocity_curve.

scale_over_velocity_curve will be interpolated between scale_over_velocity_min and scale_over_velocity_max.

var scale_over_velocity_min: float = 0.0

Minimum velocity value reference for scale_over_velocity_curve.

scale_over_velocity_curve will be interpolated between scale_over_velocity_min and scale_over_velocity_max.

var spread: float = 45.0

Each particle's initial direction range from +spread to -spread degrees.

var sub_emitter_amount_at_collision: int

The amount of particles to spawn from the subemitter node when a collision occurs. When combined with COLLISION_HIDE_ON_CONTACT on the main particles material, this can be used to achieve effects such as raindrops hitting the ground.

Note: This value shouldn't exceed GPUParticles2D.amount or GPUParticles3D.amount defined on the subemitter node (not the main node), relative to the subemitter's particle lifetime. If the number of particles is exceeded, no new particles will spawn from the subemitter until enough particles have expired.

var sub_emitter_amount_at_end: int

The amount of particles to spawn from the subemitter node when the particle expires.

Note: This value shouldn't exceed GPUParticles2D.amount or GPUParticles3D.amount defined on the subemitter node (not the main node), relative to the subemitter's particle lifetime. If the number of particles is exceeded, no new particles will spawn from the subemitter until enough particles have expired.

var sub_emitter_amount_at_start: int

The amount of particles to spawn from the subemitter node when the particle spawns.

Note: This value shouldn't exceed GPUParticles2D.amount or GPUParticles3D.amount defined on the subemitter node (not the main node), relative to the subemitter's particle lifetime. If the number of particles is exceeded, no new particles will spawn from the subemitter until enough particles have expired.

var sub_emitter_frequency: float

The frequency at which particles should be emitted from the subemitter node. One particle will be spawned every sub_emitter_frequency seconds.

Note: This value shouldn't exceed GPUParticles2D.amount or GPUParticles3D.amount defined on the subemitter node (not the main node), relative to the subemitter's particle lifetime. If the number of particles is exceeded, no new particles will spawn from the subemitter until enough particles have expired.

var sub_emitter_keep_velocity: bool = false

If true, the subemitter inherits the parent particle's velocity when it spawns.

var sub_emitter_mode: ParticleProcessMaterial.SubEmitterMode = 0

The particle subemitter mode (see GPUParticles2D.sub_emitter and GPUParticles3D.sub_emitter).

var tangential_accel_curve: Texture2D

Each particle's tangential acceleration will vary along this CurveTexture.

var tangential_accel_max: float = 0.0

Maximum tangential acceleration applied to each particle. Tangential acceleration is perpendicular to the particle's velocity giving the particles a swirling motion.

var tangential_accel_min: float = 0.0

Minimum equivalent of tangential_accel_max.

var turbulence_enabled: bool = false

If true, enables turbulence for the particle system. Turbulence can be used to vary particle movement according to its position (based on a 3D noise pattern). In 3D, GPUParticlesAttractorVectorField3D with NoiseTexture3D can be used as an alternative to turbulence that works in world space and with multiple particle systems reacting in the same way.

Note: Enabling turbulence has a high performance cost on the GPU. Only enable turbulence on a few particle systems at once at most, and consider disabling it when targeting mobile/web platforms.

var turbulence_influence_max: float = 0.1

Maximum turbulence influence on each particle.

The actual amount of turbulence influence on each particle is calculated as a random value between turbulence_influence_min and turbulence_influence_max and multiplied by the amount of turbulence influence from turbulence_influence_over_life.

var turbulence_influence_min: float = 0.1

Minimum turbulence influence on each particle.

The actual amount of turbulence influence on each particle is calculated as a random value between turbulence_influence_min and turbulence_influence_max and multiplied by the amount of turbulence influence from turbulence_influence_over_life.

var turbulence_influence_over_life: Texture2D

Each particle's amount of turbulence will be influenced along this CurveTexture over its life time.

var turbulence_initial_displacement_max: float = 0.0

Maximum displacement of each particle's spawn position by the turbulence.

The actual amount of displacement will be a factor of the underlying turbulence multiplied by a random value between turbulence_initial_displacement_min and turbulence_initial_displacement_max.

var turbulence_initial_displacement_min: float = 0.0

Minimum displacement of each particle's spawn position by the turbulence.

The actual amount of displacement will be a factor of the underlying turbulence multiplied by a random value between turbulence_initial_displacement_min and turbulence_initial_displacement_max.

var turbulence_noise_scale: float = 9.0

This value controls the overall scale/frequency of the turbulence noise pattern.

A small scale will result in smaller features with more detail while a high scale will result in smoother noise with larger features.

var turbulence_noise_speed: Vector3 = Vector3(0, 0, 0)

A scrolling velocity for the turbulence field. This sets a directional trend for the pattern to move in over time.

The default value of Vector3(0, 0, 0) turns off the scrolling.

var turbulence_noise_speed_random: float = 0.2

The in-place rate of change of the turbulence field. This defines how quickly the noise pattern varies over time.

A value of 0.0 will result in a fixed pattern.

var turbulence_noise_strength: float = 1.0

The turbulence noise strength. Increasing this will result in a stronger, more contrasting, flow pattern.

var use_rotation_3d: bool = false

Enable the usage of rotation_3d_min and rotation_3d_max.

var use_rotation_velocity_3d: bool = false

Enable 3D rotation velocity.

var use_scale_3d: bool = false

Enable the usage of scale_3d_min and scale_3d_max.

var velocity_limit_curve: Texture2D

A CurveTexture that defines the maximum velocity of a particle during its lifetime.

var velocity_pivot: Vector3 = Vector3(0, 0, 0)

A pivot point used to calculate radial and orbital velocity of particles.

Inherited from Material (2)
Inherited from Resource (4)

Methods

func get_param(param: ParticleProcessMaterial.Parameter) -> Vector2

Returns the minimum and maximum values of the given param as a vector.

The x component of the returned vector corresponds to minimum and the y component corresponds to maximum.

func get_param_max(param: ParticleProcessMaterial.Parameter) -> float

Returns the maximum value range for the given parameter.

func get_param_min(param: ParticleProcessMaterial.Parameter) -> float

Returns the minimum value range for the given parameter.

func get_param_texture(param: ParticleProcessMaterial.Parameter) -> Texture2D

Returns the Texture2D used by the specified parameter.

func get_particle_flag(particle_flag: ParticleProcessMaterial.ParticleFlags) -> bool

Returns true if the specified particle flag is enabled.

func set_param(param: ParticleProcessMaterial.Parameter, value: Vector2) -> void

Sets the minimum and maximum values of the given param.

The x component of the argument vector corresponds to minimum and the y component corresponds to maximum.

func set_param_max(param: ParticleProcessMaterial.Parameter, value: float) -> void

Sets the maximum value range for the given parameter.

func set_param_min(param: ParticleProcessMaterial.Parameter, value: float) -> void

Sets the minimum value range for the given parameter.

func set_param_texture(param: ParticleProcessMaterial.Parameter, texture: Texture2D) -> void

Sets the Texture2D for the specified Parameter.

func set_particle_flag(particle_flag: ParticleProcessMaterial.ParticleFlags, enable: bool) -> void

Sets the particle_flag to enable.

Inherited from Material (6)
Inherited from Resource (18)
func _get_rid() -> RID
func _reset_state() -> void
func _set_path_cache(path: String) -> void
func _setup_local_to_scene() -> void
func copy_from_resource(resource: Resource) -> Error
func duplicate(deep: bool = false) -> Resource
func duplicate_deep(deep_subresources_mode: Resource.DeepDuplicateMode = 1) -> Resource
func emit_changed() -> void
func get_rid() -> RID
func is_built_in() -> bool
func reset_state() -> void
func set_id_for_path(path: String, id: String) -> void
func set_path_cache(path: String) -> void
func setup_local_to_scene() -> void
func take_over_path(path: String) -> void
Inherited from RefCounted (4)
func init_ref() -> bool
func reference() -> bool
func unreference() -> bool
Inherited from Object (62)
func _get(property: StringName) -> Variant
func _get_property_list() -> Dictionary[]
func _init() -> void
func _iter_get(iter: Variant) -> Variant
func _iter_init(iter: Array) -> bool
func _iter_next(iter: Array) -> bool
func _notification(what: int) -> void
func _set(property: StringName, value: Variant) -> bool
func _to_string() -> String
func _validate_property(property: Dictionary) -> void
func add_user_signal(signal: String, arguments: Array = []) -> void
func call(method: StringName) -> Variant
func callv(method: StringName, arg_array: Array) -> Variant
func cancel_free() -> void
func connect(signal: StringName, callable: Callable, flags: int = 0) -> Error
func disconnect(signal: StringName, callable: Callable) -> void
func emit_signal(signal: StringName) -> Error
func free() -> void
func get(property: StringName) -> Variant
func get_class() -> String
func get_incoming_connections() -> Dictionary[]
func get_indexed(property_path: NodePath) -> Variant
func get_meta(name: StringName, default: Variant = null) -> Variant
func get_meta_list() -> StringName[]
func get_method_list() -> Dictionary[]
func get_property_list() -> Dictionary[]
func get_signal_connection_list(signal: StringName) -> Dictionary[]
func get_signal_list() -> Dictionary[]
func has_meta(name: StringName) -> bool
func has_method(method: StringName) -> bool
func has_signal(signal: StringName) -> bool
func is_class(class: StringName) -> bool
func is_connected(signal: StringName, callable: Callable) -> bool
func notification(what: int, reversed: bool = false) -> void
func remove_meta(name: StringName) -> void
func remove_user_signal(signal: StringName) -> void
func set(property: StringName, value: Variant) -> void
func set_block_signals(enable: bool) -> void
func set_deferred(property: StringName, value: Variant) -> void
func set_indexed(property_path: NodePath, value: Variant) -> void
func set_message_translation(enable: bool) -> void
func set_meta(name: StringName, value: Variant) -> void
func set_script(script: Variant) -> void
func set_translation_domain(domain: StringName) -> void
func to_string() -> String
func tr(message: StringName, context: StringName = &"") -> String
func tr_n(message: StringName, plural_message: StringName, n: int, context: StringName = &"") -> String

Signals

signal emission_shape_changed()

Emitted when this material's emission shape is changed in any way. This includes changes to emission_shape, emission_shape_scale, or emission_sphere_radius, and any other property that affects the emission shape's offset, size, scale, or orientation.

Note: This signal is only emitted inside the editor for performance reasons.

Inherited from Resource (2)
signal changed()
Inherited from Object (2)

Enums & Constants

enum Parameter
PARAM_INITIAL_LINEAR_VELOCITY = 0

Use with set_param_min(), set_param_max(), and set_param_texture() to set initial velocity properties.

PARAM_ANGULAR_VELOCITY = 1

Use with set_param_min(), set_param_max(), and set_param_texture() to set angular velocity properties.

PARAM_ORBIT_VELOCITY = 2

Use with set_param_min(), set_param_max(), and set_param_texture() to set orbital velocity properties.

PARAM_LINEAR_ACCEL = 3

Use with set_param_min(), set_param_max(), and set_param_texture() to set linear acceleration properties.

PARAM_RADIAL_ACCEL = 4

Use with set_param_min(), set_param_max(), and set_param_texture() to set radial acceleration properties.

PARAM_TANGENTIAL_ACCEL = 5

Use with set_param_min(), set_param_max(), and set_param_texture() to set tangential acceleration properties.

PARAM_DAMPING = 6

Use with set_param_min(), set_param_max(), and set_param_texture() to set damping properties.

PARAM_ANGLE = 7

Use with set_param_min(), set_param_max(), and set_param_texture() to set angle properties.

PARAM_SCALE = 8

Use with set_param_min(), set_param_max(), and set_param_texture() to set scale properties.

PARAM_HUE_VARIATION = 9

Use with set_param_min(), set_param_max(), and set_param_texture() to set hue variation properties.

PARAM_ANIM_SPEED = 10

Use with set_param_min(), set_param_max(), and set_param_texture() to set animation speed properties.

PARAM_ANIM_OFFSET = 11

Use with set_param_min(), set_param_max(), and set_param_texture() to set animation offset properties.

PARAM_RADIAL_VELOCITY = 15

Use with set_param_min(), set_param_max(), and set_param_texture() to set radial velocity properties.

PARAM_DIRECTIONAL_VELOCITY = 16

Use with set_param_min(), set_param_max(), and set_param_texture() to set directional velocity properties.

PARAM_SCALE_OVER_VELOCITY = 17

Use with set_param_min(), set_param_max(), and set_param_texture() to set scale over velocity properties.

PARAM_MAX = 18

Represents the size of the Parameter enum.

PARAM_TURB_VEL_INFLUENCE = 13

Use with set_param_min() and set_param_max() to set the turbulence minimum und maximum influence on each particles velocity.

PARAM_TURB_INIT_DISPLACEMENT = 14

Use with set_param_min() and set_param_max() to set the turbulence minimum and maximum displacement of the particles spawn position.

PARAM_TURB_INFLUENCE_OVER_LIFE = 12

Use with set_param_texture() to set the turbulence influence over the particles life time.

enum ParticleFlags
PARTICLE_FLAG_ALIGN_Y_TO_VELOCITY = 0

Use with set_particle_flag() to set particle_flag_align_y.

PARTICLE_FLAG_ROTATE_Y = 1

Use with set_particle_flag() to set particle_flag_rotate_y.

PARTICLE_FLAG_DISABLE_Z = 2

Use with set_particle_flag() to set particle_flag_disable_z.

PARTICLE_FLAG_DAMPING_AS_FRICTION = 3
PARTICLE_FLAG_INHERIT_EMITTER_SCALE = 4
PARTICLE_FLAG_MAX = 5

Represents the size of the ParticleFlags enum.

enum EmissionShape
EMISSION_SHAPE_POINT = 0

All particles will be emitted from a single point.

EMISSION_SHAPE_SPHERE = 1

Particles will be emitted in the volume of a sphere.

EMISSION_SHAPE_SPHERE_SURFACE = 2

Particles will be emitted on the surface of a sphere.

EMISSION_SHAPE_BOX = 3

Particles will be emitted in the volume of a box.

EMISSION_SHAPE_POINTS = 4

Particles will be emitted at a position determined by sampling a random point on the emission_point_texture. Particle color will be modulated by emission_color_texture.

EMISSION_SHAPE_DIRECTED_POINTS = 5

Particles will be emitted at a position determined by sampling a random point on the emission_point_texture. Particle velocity and rotation will be set based on emission_normal_texture. Particle color will be modulated by emission_color_texture.

EMISSION_SHAPE_RING = 6

Particles will be emitted in a ring or cylinder.

EMISSION_SHAPE_MAX = 7

Represents the size of the EmissionShape enum.

enum SubEmitterMode
SUB_EMITTER_DISABLED = 0

The subemitter is disabled.

SUB_EMITTER_CONSTANT = 1

The submitter is emitted on the constant interval defined by sub_emitter_frequency.

SUB_EMITTER_AT_END = 2

The subemitter is emitted at the end of the particle's lifetime.

SUB_EMITTER_AT_COLLISION = 3

The subemitter is emitted when the particle collides.

SUB_EMITTER_AT_START = 4

The subemitter is emitted when the particle spawns.

SUB_EMITTER_MAX = 5

Represents the size of the SubEmitterMode enum.

enum CollisionMode
COLLISION_DISABLED = 0

No collision for particles. Particles will go through GPUParticlesCollision3D nodes.

COLLISION_RIGID = 1

RigidBody3D-style collision for particles using GPUParticlesCollision3D nodes.

COLLISION_HIDE_ON_CONTACT = 2

Hide particles instantly when colliding with a GPUParticlesCollision3D node. This can be combined with a subemitter that uses the COLLISION_RIGID collision mode to "replace" the parent particle with the subemitter on impact.

COLLISION_MAX = 3

Represents the size of the CollisionMode enum.