ParticleProcessMaterial

Conformances

• protocol CustomStringConvertible

  A type with a customized textual representation.

• protocol Equatable

  A type that can be compared for value equality.

• protocol Hashable

  A type that can be hashed into a Hasher to produce an integer hash value.

• protocol Identifiable<ID>

  A class of types whose instances hold the value of an entity with stable identity.

• protocol VariantRepresentable

  Types that conform to VariantRepresentable can be stored directly in Variant with no conversion. These include all of the Variant types from Godot (for example GString, Rect, Plane), Godot objects (those that subclass SwiftGodot.Object) as well as the built-in Swift types UInt8, Int64 and Double.

• protocol VariantStorable

  Types that conform to VariantStorable can be stored in a Variant and can be extracted back out of a Variant.

Types

• enum CollisionMode
• enum EmissionShape
• enum Parameter
• enum ParticleFlags
• enum SubEmitterMode

Type members

• class var godotClassName: StringName

Instance members

• var alphaCurve: Texture2D?

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

• var angle: Vector2
• var angleCurve: Texture2D?

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

• var angleMax: Double

  Maximum initial rotation applied to each particle, in degrees.

• var angleMin: Double

  Minimum equivalent of angleMax.

• var angularVelocity: Vector2
• var angularVelocityCurve: Texture2D?

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

• var angularVelocityMax: Double

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

• var angularVelocityMin: Double

  Minimum equivalent of angularVelocityMax.

• var animOffset: Vector2
• var animOffsetCurve: Texture2D?

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

• var animOffsetMax: Double

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

• var animOffsetMin: Double

  Minimum equivalent of animOffsetMax.

• var animSpeed: Vector2
• var animSpeedCurve: Texture2D?

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

• var animSpeedMax: Double

  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.

• var animSpeedMin: Double

  Minimum equivalent of animSpeedMax.

• var attractorInteractionEnabled: Bool

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

• var collisionBounce: Double

  The particles’ bounciness. Values range from 0 (no bounce) to 1 (full bounciness). Only effective if collisionMode is .collisionRigid.

• var collisionFriction: Double

  The particles’ friction. Values range from 0 (frictionless) to 1 (maximum friction). Only effective if collisionMode is .collisionRigid.

• var collisionMode: ParticleProcessMaterial.CollisionMode

  The particles’ collision mode.

• var collisionUseScale: Bool

  If true, collisionBaseSize is multiplied by the particle’s effective scale (see scaleMin, scaleMax, scaleCurve, and scaleOverVelocityCurve).

• var color: Color

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

• var colorInitialRamp: Texture2D?

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

• var colorRamp: Texture2D?

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

• var damping: Vector2
• var dampingCurve: Texture2D?

  Damping will vary along this CurveTexture.

• var dampingMax: Double

  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 dampingMin: Double

  Minimum equivalent of dampingMax.

• var direction: Vector3

  Unit vector specifying the particles’ emission direction.

• var directionalVelocity: Vector2
• var directionalVelocityCurve: Texture2D?

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

• var directionalVelocityMax: Double

  Maximum directional velocity value, which is multiplied by directionalVelocityCurve.

• var directionalVelocityMin: Double

  Minimum directional velocity value, which is multiplied by directionalVelocityCurve.

• var emissionBoxExtents: Vector3

  The box’s extents if emissionShape is set to .box.

• var emissionColorTexture: Texture2D?

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

• var emissionCurve: Texture2D?

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

• var emissionNormalTexture: Texture2D?

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

• var emissionPointCount: Int32

  The number of emission points if emissionShape is set to .points or .directedPoints.

• var emissionPointTexture: Texture2D?

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

• var emissionRingAxis: Vector3

  The axis of the ring when using the emitter .ring.

• var emissionRingHeight: Double

  The height of the ring when using the emitter .ring.

• var emissionRingInnerRadius: Double

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

• var emissionRingRadius: Double

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

• var emissionShape: ParticleProcessMaterial.EmissionShape

  Particles will be emitted inside this region. Use EmissionShape constants for values.

• var emissionShapeOffset: Vector3

  The offset for the emissionShape, in local space.

• var emissionShapeScale: Vector3

  The scale of the emissionShape, in local space.

• var emissionSphereRadius: Double

  The sphere’s radius if emissionShape is set to .sphere.

• var flatness: Double

  Amount of spread along the Y axis.

• var gravity: Vector3

  Gravity applied to every particle.

• var hueVariation: Vector2
• var hueVariationCurve: Texture2D?

  Each particle’s hue will vary along this CurveTexture.

• var hueVariationMax: Double

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

• var hueVariationMin: Double

  Minimum equivalent of hueVariationMax.

• var inheritVelocityRatio: Double

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

• var initialVelocity: Vector2
• var initialVelocityMax: Double

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

• var initialVelocityMin: Double

  Minimum equivalent of initialVelocityMax.

• var lifetimeRandomness: Double

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

• var linearAccel: Vector2
• var linearAccelCurve: Texture2D?

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

• var linearAccelMax: Double

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

• var linearAccelMin: Double

  Minimum equivalent of linearAccelMax.

• var orbitVelocity: Vector2
• var orbitVelocityCurve: Texture2D?

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

• var orbitVelocityMax: Double

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

• var orbitVelocityMin: Double

  Minimum equivalent of orbitVelocityMax.

• var particleFlagAlignY: Bool

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

• var particleFlagDampingAsFriction: Bool

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

• var particleFlagDisableZ: Bool

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

• var particleFlagRotateY: Bool

  If true, particles rotate around Y axis by angleMin.

• var radialAccel: Vector2
• var radialAccelCurve: Texture2D?

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

• var radialAccelMax: Double

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

• var radialAccelMin: Double

  Minimum equivalent of radialAccelMax.

• var radialVelocity: Vector2
• var radialVelocityCurve: Texture2D?

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

• var radialVelocityMax: Double

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

• var radialVelocityMin: Double

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

• var scale: Vector2
• var scaleCurve: 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 scaleMax: Double

  Maximum initial scale applied to each particle.

• var scaleMin: Double

  Minimum equivalent of scaleMax.

• var scaleOverVelocity: Vector2
• var scaleOverVelocityCurve: Texture2D?

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

• var scaleOverVelocityMax: Double

  Maximum velocity value reference for scaleOverVelocityCurve.

• var scaleOverVelocityMin: Double

  Minimum velocity value reference for scaleOverVelocityCurve.

• var spread: Double

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

• var subEmitterAmountAtCollision: Int32

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

• var subEmitterAmountAtEnd: Int32

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

• var subEmitterFrequency: Double

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

• var subEmitterKeepVelocity: Bool

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

• var subEmitterMode: ParticleProcessMaterial.SubEmitterMode

  The particle subemitter mode (see subEmitter and subEmitter).

• var tangentialAccel: Vector2
• var tangentialAccelCurve: Texture2D?

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

• var tangentialAccelMax: Double

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

• var tangentialAccelMin: Double

  Minimum equivalent of tangentialAccelMax.

• var turbulenceEnabled: Bool

  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.

• var turbulenceInfluence: Vector2
• var turbulenceInfluenceMax: Double

  Maximum turbulence influence on each particle.

• var turbulenceInfluenceMin: Double

  Minimum turbulence influence on each particle.

• var turbulenceInfluenceOverLife: Texture2D?

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

• var turbulenceInitialDisplacement: Vector2
• var turbulenceInitialDisplacementMax: Double

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

• var turbulenceInitialDisplacementMin: Double

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

• var turbulenceNoiseScale: Double

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

• var turbulenceNoiseSpeed: Vector3

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

• var turbulenceNoiseSpeedRandom: Double

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

• var turbulenceNoiseStrength: Double

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

• var velocityLimitCurve: Texture2D?

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

• var velocityPivot: Vector3

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