ParticleSystem

Enumerations

ParticleAccelerationDirectionMode

How the direction of the continuously added acceleration is computed.

Values:

  • Point = 0 - Added velocity radiates outward from a single point offset.

  • Vector = 1 - Added velocity points along a fixed direction vector.

  • Cone = 2 - Added velocity is distributed within a cone.

ParticleBillboardOrientation

How a billboard particle is oriented relative to the camera and its motion.

Values:

  • Screen = 0 - The billboard always faces the camera screen plane. The standard particle orientation.

  • Camera = 1 - The billboard faces the camera position, pivoting toward the viewer.

  • Velocity = 2 - The billboard is aligned to the particle’s velocity direction, optionally stretching along it.

  • Static = 3 - The billboard is aligned to fixed user-defined up and right vectors.

ParticleBlendMode

How particles are blended with the scene behind them.

Values:

  • AlphaBlend = 0 - Default alpha blending (finalColor = srcColor * srcAlpha + dstColor * (1 - srcAlpha)).

  • Premultiplied = 1 - Premultiplied alpha blending (finalColor = srcColor + dstColor * (1 - srcAlpha)).

  • Additive = 2 - Additive blending (finalColor = srcColor * srcAlpha + dstColor).

  • AlphaTestOpaque = 3 - Opaque rendering with the alpha test threshold equal to 0.5.

ParticleLightingMode

How particles are lit.

Values:

  • Uniform = 0 - Uniform environment lighting.

  • FaceNormal = 1 - Particles are lit using the billboard’s face normal computed in the vertex shader.

  • Sphere = 2 - Particles are lit as spheres, producing volumetric-looking shading suitable for smoke and clouds.

  • NormalMap = 3 - Particles are lit using a normal map sampled from the secondary texture for detailed surface shading.

ParticleRenderShapeKind

The geometry each particle is rendered as.

Values:

  • Billboard = 0 - Each particle renders as an independent camera-facing quad (billboard).

  • Ribbon = 1 - Particles are connected into a continuous ribbon strip, useful for trails, beams and lightning.

ParticleRibbonMode

How the ribbon geometry is built.

Values:

  • SideOnly = 0 - The ribbon is built only from side faces connecting consecutive particles, forming a flat trail.

  • SideAndHead = 1 - The ribbon adds a head cap quad at each particle position in addition to the side faces, forming rounded joints along the ribbon. The head cap is sampled from the secondary texture.

ParticleRibbonUVMapping

How texture coordinates are mapped along the ribbon.

Values:

  • Relative = 0 - Texture coordinates stretch relative to the ribbon length, so the texture spans the whole ribbon regardless of its size.

  • Static = 1 - Texture coordinates are static and tied to particle spacing, so the texture density stays constant as the ribbon grows.

ParticleSpawnEmissionMode

How and when new particles are spawned.

Values:

  • Linear = 0 - Continuously emit particles over time at a given rate. The most common mode for streams like smoke, fire or dust.

  • Burst = 1 - Emit particles in discrete bursts, optionally repeating a fixed number of cycles. Good for explosions, puffs and one-shot effects.

  • Distance = 2 - Emit particles based on how far the emitter has moved, producing evenly-spaced motion trails independent of speed.

  • Fixed = 3 - Emit a fixed number of particles once when the system starts.

ParticleSpawnShapeKind

The shape of the region particles spawn in.

Values:

  • Sphere = 0 - Particles spawn inside a sphere.

  • Cylinder = 1 - Particles spawn inside a cylinder.

  • Cone = 2 - Particles spawn inside a cone.

  • Box = 3 - Particles spawn inside an axis-aligned box.

  • SphereSector = 4 - Particles spawn inside an angular sector of a sphere.

ParticleTransformType

Whether particles live in world space or follow the emitter’s local space.

Values:

  • WorldSpace = 0 - Particles are emitted into world space and stay where they were spawned.

  • LocalSpace = 1 - Particles live in the emitter’s local space, moving with it. Gravity and wind forces are also applied relative to the emitter’s orientation.

ParticleVelocityDirectionMode

How the initial velocity direction is computed.

Values:

  • Point = 0 - Velocity radiates outward from a single point offset, making particles fly away from (or toward) that point.

  • Vector = 1 - Velocity points along a fixed direction vector shared by all particles.

  • StartShape = 2 - Velocity direction is derived from the particle’s spawn position within the shape, making particles spread outward from the shape’s center.

Classes

ParticleSystem : NativeComponent

This component attaches a GPU particle system to a node.

A particle system efficiently simulates a large number of particles, which can be used to create various effects that would be hard to represent as a mesh.

Conceptually it is split into three parts: emission, simulation (particle motion), and rendering. Particle lifetime is configured separately.

Emission creates new particles. Its settings control the region particles spawn in, how they are distributed within that region, and how many spawn and how often.

Simulation (particle motion) controls how particles move over their lifetime. Its settings define the particles’ initial velocity and the forces that alter it as they age.

Rendering controls how particles appear on screen. Its settings define the particles’ shape and orientation, and their appearance: texture, color, and how they blend with the scene.

See the documentation of the individual fields for more detail.

To use this component, add the following line to your project file:

require engine.core_components.particle_system_component // or require engine.core

Usage example:

var node = create_node(NodeData(name = "effect"))
add_component(node, new ParticleSystem())
get_component(node) $(var effect : ParticleSystem?) {
    effect.lifetime.lifeRange = float2(0.5, 1.0)
    effect.spawn.emission.linear.count = 20
    effect.motion.velocity.active = true
    effect.motion.velocity.speedRange = float2(1.0, 2.0)
    effect.render.blendMode = ParticleBlendMode.Additive
    effect.render.shape.radiusRange = float2(0.05, 0.15)
    effect.render.rotation.active = true
    effect.render.rotation.angleRange = float2(-180.0, 180.0)
    effect.render.rotation.spinSpeedRange = float2(-90.0, 90.0)
    effect.render.color.tintFrom = float4(1.0, 0.5, 0.0, 1.0)
    effect.render.color.tintTo = float4(1.0, 1.0, 0.0, 1.0)
    effect.render.emission.active = true
    effect.render.emission.strength = 2.0
    for (key in fixed_array(float2(0.0, 1.0), float2(0.5, 0.75), float2(1.0, 0.25))) {
        var curveKey = effect.render.emission.strengthCurve.push()
        curveKey.pos = key.x
        curveKey.value = key.y
    }
}
Properties:

ParticleSystem.transformType: ParticleTransformType
ParticleSystem.transformType =(value: ParticleTransformType)

Whether particles live in world space or follow the node’s local space. See ParticleTransformType enum description for details.

Arguments:
ParticleSystem.baseTexture: TextureId
ParticleSystem.baseTexture =(value: TextureId)

Main particle color texture.

Arguments:
ParticleSystem.secondaryTexture: TextureId
ParticleSystem.secondaryTexture =(value: TextureId)

Secondary texture, used either for normal mapping or as the source for ribbon’s caps.

Arguments:
ParticleSystem.lifetime: ParticleLifetimeHandle

Particle lifetime settings.

ParticleSystem.spawn: ParticleSpawnHandle

Particle spawn settings. Configure emission rate and spawn shape.

ParticleSystem.motion: ParticleMotionHandle

Particle motion settings. Configure how particles move after spawn.

ParticleSystem.render: ParticleRenderHandle

Particle rendering settings. Configure how particles look and blend with the scene.

Structures

ParticleLifetimeHandle

Handle to the lifetime field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleLifetimeHandle.lifeRange: float2
ParticleLifetimeHandle.lifeRange =(value: float2)

Minimum and maximum lifetime of a particle in seconds. Each particle picks a random value in this range.

Arguments:

  • value : float2

ParticleLifetimeHandle.maxAgeOffset: float
ParticleLifetimeHandle.maxAgeOffset =(value: float)

Maximum random initial age offset as a fraction of the particle’s lifetime, in range [0, 1].

Arguments:

  • value : float

ParticleSpawnHandle

Handle to the spawn field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnHandle.emission: ParticleSpawnEmissionHandle

Controls the spawn rate and number of particles emitted. Currently one particle system can’t contain more than 16384 particles. If you need more, you need to create multiple particle systems.

ParticleSpawnHandle.shape: ParticleSpawnShapeHandle

Controls the shape of the volume particles spawn within.

ParticleSpawnHandle.delay: float
ParticleSpawnHandle.delay =(value: float)

Delay in seconds before the first particle is spawned. Useful for creating compound effects where multiple particle systems are triggered in sequence.

Arguments:

  • value : float

ParticleSpawnEmissionHandle

Handle to the spawn.emission field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnEmissionHandle.mode: ParticleSpawnEmissionMode
ParticleSpawnEmissionHandle.mode =(value: ParticleSpawnEmissionMode)

Emission mode that controls how and when particles are spawned. See ParticleSpawnEmissionMode enum description for details.

Arguments:
ParticleSpawnEmissionHandle.linear: ParticleSpawnEmissionLinearHandle

Parameters used when mode is Linear.

ParticleSpawnEmissionHandle.burst: ParticleSpawnEmissionBurstHandle

Parameters used when mode is Burst.

ParticleSpawnEmissionHandle.distance: ParticleSpawnEmissionDistanceHandle

Parameters used when mode is Distance.

ParticleSpawnEmissionHandle.fixed: ParticleSpawnEmissionFixedHandle

Parameters used when mode is Fixed.

ParticleSpawnEmissionLinearHandle

Handle to the spawn.emission.linear field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnEmissionLinearHandle.count: int
ParticleSpawnEmissionLinearHandle.count =(value: int)

Number of live particles the system sustains. The spawn rate is derived as this count divided by the particle lifetime, so longer-lived particles spawn more slowly for the same count.

Arguments:

  • value : int

ParticleSpawnEmissionLinearHandle.subframeEmission: bool
ParticleSpawnEmissionLinearHandle.subframeEmission =(value: bool)

Enables particles spawn along interpolated sub-frame emitter position. Prevents uneven spawn at emitter’s per-frame position when it moves.

Arguments:

  • value : bool

ParticleSpawnEmissionBurstHandle

Handle to the spawn.emission.burst field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnEmissionBurstHandle.count: int
ParticleSpawnEmissionBurstHandle.count =(value: int)

Number of particles emitted per burst. If the total amount of simultaneously alive particles exceeds the system limit, the burst count is automatically clamped to fit within the limit.

Arguments:

  • value : int

ParticleSpawnEmissionBurstHandle.cycles: int
ParticleSpawnEmissionBurstHandle.cycles =(value: int)

Number of bursts to emit. 0 means emit endlessly, repeating every period.

Arguments:

  • value : int

ParticleSpawnEmissionBurstHandle.period: float
ParticleSpawnEmissionBurstHandle.period =(value: float)

Time in seconds between consecutive bursts.

Arguments:

  • value : float

ParticleSpawnEmissionDistanceHandle

Handle to the spawn.emission.distance field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnEmissionDistanceHandle.maxCount: int
ParticleSpawnEmissionDistanceHandle.maxCount =(value: int)

Maximum number of simultaneously alive particles.

Arguments:

  • value : int

ParticleSpawnEmissionDistanceHandle.spacing: float
ParticleSpawnEmissionDistanceHandle.spacing =(value: float)

World-space distance the emitter must travel to spawn the next particle. Used for evenly-spaced motion trails.

Arguments:

  • value : float

ParticleSpawnEmissionDistanceHandle.idlePeriod: float
ParticleSpawnEmissionDistanceHandle.idlePeriod =(value: float)

If greater than zero, particles are additionally emitted at this interval in seconds while the emitter is stationary.

Arguments:

  • value : float

ParticleSpawnEmissionFixedHandle

Handle to the spawn.emission.fixed field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnEmissionFixedHandle.count: int
ParticleSpawnEmissionFixedHandle.count =(value: int)

Number of particles emitted once when the system starts.

Arguments:

  • value : int

ParticleSpawnShapeHandle

Handle to the spawn.shape field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnShapeHandle.kind: ParticleSpawnShapeKind
ParticleSpawnShapeHandle.kind =(value: ParticleSpawnShapeKind)

Shape of the volume particles spawn within. See ParticleSpawnShapeKind enum description for details.

Arguments:
ParticleSpawnShapeHandle.sphere: ParticleSpawnShapeSphereHandle

Parameters used when kind is Sphere.

ParticleSpawnShapeHandle.cylinder: ParticleSpawnShapeCylinderHandle

Parameters used when kind is Cylinder.

ParticleSpawnShapeHandle.cone: ParticleSpawnShapeConeHandle

Parameters used when kind is Cone.

ParticleSpawnShapeHandle.box: ParticleSpawnShapeBoxHandle

Parameters used when kind is Box.

ParticleSpawnShapeHandle.sphereSector: ParticleSpawnShapeSphereSectorHandle

Parameters used when kind is SphereSector.

ParticleSpawnShapeSphereHandle

Handle to the spawn.shape.sphere field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnShapeSphereHandle.radius: float
ParticleSpawnShapeSphereHandle.radius =(value: float)

Radius of the sphere surface the particles spawn on.

Arguments:

  • value : float

ParticleSpawnShapeSphereHandle.volumeFill: float
ParticleSpawnShapeSphereHandle.volumeFill =(value: float)

Controls whether particles spawn on the shape’s surface or within its volume, in range [0, 1]. At 0 particles spawn on the surface; at 1 they fill the volume.

Arguments:

  • value : float

ParticleSpawnShapeCylinderHandle

Handle to the spawn.shape.cylinder field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnShapeCylinderHandle.direction: float3
ParticleSpawnShapeCylinderHandle.direction =(value: float3)

Axis direction of the cylinder.

Arguments:

  • value : float3

ParticleSpawnShapeCylinderHandle.radius: float
ParticleSpawnShapeCylinderHandle.radius =(value: float)

Cylinder radius.

Arguments:

  • value : float

ParticleSpawnShapeCylinderHandle.height: float
ParticleSpawnShapeCylinderHandle.height =(value: float)

Cylinder height along its axis.

Arguments:

  • value : float

ParticleSpawnShapeCylinderHandle.volumeFill: float
ParticleSpawnShapeCylinderHandle.volumeFill =(value: float)

Controls whether particles spawn on the shape’s surface or within its volume, in range [0, 1]. At 0 particles spawn on the surface; at 1 they fill the volume.

Arguments:

  • value : float

ParticleSpawnShapeConeHandle

Handle to the spawn.shape.cone field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnShapeConeHandle.direction: float3
ParticleSpawnShapeConeHandle.direction =(value: float3)

Axis direction the cone points along.

Arguments:

  • value : float3

ParticleSpawnShapeConeHandle.widthTop: float
ParticleSpawnShapeConeHandle.widthTop =(value: float)

Radius of the cone at its far (top) end.

Arguments:

  • value : float

ParticleSpawnShapeConeHandle.widthBottom: float
ParticleSpawnShapeConeHandle.widthBottom =(value: float)

Radius of the cone at its base (bottom) end.

Arguments:

  • value : float

ParticleSpawnShapeConeHandle.height: float
ParticleSpawnShapeConeHandle.height =(value: float)

Cone height along its axis.

Arguments:

  • value : float

ParticleSpawnShapeConeHandle.volumeFill: float
ParticleSpawnShapeConeHandle.volumeFill =(value: float)

Controls whether particles spawn on the shape’s surface or within its volume, in range [0, 1]. At 0 particles spawn on the surface; at 1 they fill the volume.

Arguments:

  • value : float

ParticleSpawnShapeBoxHandle

Handle to the spawn.shape.box field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnShapeBoxHandle.width: float
ParticleSpawnShapeBoxHandle.width =(value: float)

Box size along the X axis.

Arguments:

  • value : float

ParticleSpawnShapeBoxHandle.height: float
ParticleSpawnShapeBoxHandle.height =(value: float)

Box size along the Y axis.

Arguments:

  • value : float

ParticleSpawnShapeBoxHandle.depth: float
ParticleSpawnShapeBoxHandle.depth =(value: float)

Box size along the Z axis.

Arguments:

  • value : float

ParticleSpawnShapeSphereSectorHandle

Handle to the spawn.shape.sphereSector field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleSpawnShapeSphereSectorHandle.direction: float3
ParticleSpawnShapeSphereSectorHandle.direction =(value: float3)

Central direction of the sphere sector.

Arguments:

  • value : float3

ParticleSpawnShapeSphereSectorHandle.radius: float
ParticleSpawnShapeSphereSectorHandle.radius =(value: float)

Radius of the sphere surface the particles spawn on.

Arguments:

  • value : float

ParticleSpawnShapeSphereSectorHandle.sector: float
ParticleSpawnShapeSphereSectorHandle.sector =(value: float)

Angular spread of the sector in range [0, 1]. At 0 particles are distributed over the full sphere surface; at 0.5 over the hemisphere facing direction; at 1 they are concentrated at a single point in the direction direction.

Arguments:

  • value : float

ParticleSpawnShapeSphereSectorHandle.volumeFill: float
ParticleSpawnShapeSphereSectorHandle.volumeFill =(value: float)

Controls whether particles spawn on the shape’s surface or within its volume, in range [0, 1]. At 0 particles spawn on the surface; at 1 they fill the volume.

Arguments:

  • value : float

ParticleMotionHandle

Handle to the motion field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionHandle.applyGravity: bool
ParticleMotionHandle.applyGravity =(value: bool)

Apply gravity to particles.

Arguments:

  • value : bool

ParticleMotionHandle.addEmitterVelocity: bool
ParticleMotionHandle.addEmitterVelocity =(value: bool)

Adds the emitter’s velocity to particles at spawn.

Arguments:

  • value : bool

ParticleMotionHandle.pinLastParticle: bool
ParticleMotionHandle.pinLastParticle =(value: bool)

Keeps the most recently spawned particle pinned to the emitter position.

Arguments:

  • value : bool

ParticleMotionHandle.velocity: ParticleMotionVelocityHandle

Initial velocity given to particles at spawn.

ParticleMotionHandle.acceleration: ParticleMotionAccelerationHandle

Continuous acceleration added to particles over their life.

ParticleMotionHandle.vortex: ParticleMotionVortexHandle

Vortex-type acceleration that swirls particles around an axis.

ParticleMotionHandle.noise: ParticleMotionNoiseHandle

Random acceleration introducing chaotic motion.

ParticleMotionHandle.wind: ParticleMotionWindHandle

Acceleration from wind. Requires non-zero drag to have an effect.

ParticleMotionHandle.drag: ParticleMotionDragHandle

Air drag force that slows down particles over time.

ParticleMotionVelocityHandle

Handle to the motion.velocity field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionVelocityHandle.active: bool
ParticleMotionVelocityHandle.active =(value: bool)

Enables an initial velocity given to each particle at spawn.

Arguments:

  • value : bool

ParticleMotionVelocityHandle.speedRange: float2
ParticleMotionVelocityHandle.speedRange =(value: float2)

Minimum and maximum initial speed, randomized per particle.

Arguments:

  • value : float2

ParticleMotionVelocityHandle.directionRandom: float
ParticleMotionVelocityHandle.directionRandom =(value: float)

Adds random deviation to the initial velocity direction, in range [0, 1]. At 1 the direction is completely random.

Arguments:

  • value : float

ParticleMotionVelocityHandle.directionMode: ParticleVelocityDirectionMode
ParticleMotionVelocityHandle.directionMode =(value: ParticleVelocityDirectionMode)

How the initial velocity direction is computed. See ParticleVelocityDirectionMode enum description for details.

Arguments:
ParticleMotionVelocityHandle.point: ParticleMotionVelocityPointHandle

Parameters used when directionMode is Point.

ParticleMotionVelocityHandle.vector: ParticleMotionVelocityVectorHandle

Parameters used when directionMode is Vector.

ParticleMotionVelocityPointHandle

Handle to the motion.velocity.point field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionVelocityPointHandle.offset: float3
ParticleMotionVelocityPointHandle.offset =(value: float3)

Point the velocity radiates from, relative to the spawn position. Particles move away from this point.

Arguments:

  • value : float3

ParticleMotionVelocityVectorHandle

Handle to the motion.velocity.vector field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionVelocityVectorHandle.direction: float3
ParticleMotionVelocityVectorHandle.direction =(value: float3)

Velocity direction vector.

Arguments:

  • value : float3

ParticleMotionAccelerationHandle

Handle to the motion.acceleration field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionAccelerationHandle.active: bool
ParticleMotionAccelerationHandle.active =(value: bool)

Enables an additional acceleration continuously added to particles over their life.

Arguments:

  • value : bool

ParticleMotionAccelerationHandle.applyEmitterTransform: bool
ParticleMotionAccelerationHandle.applyEmitterTransform =(value: bool)

Rotate the added acceleration together with the emitter’s transform.

Arguments:

  • value : bool

ParticleMotionAccelerationHandle.strengthRange: float2
ParticleMotionAccelerationHandle.strengthRange =(value: float2)

Minimum and maximum magnitude of the added acceleration, randomized per particle.

Arguments:

  • value : float2

ParticleMotionAccelerationHandle.directionRandom: float
ParticleMotionAccelerationHandle.directionRandom =(value: float)

Adds random deviation to the added acceleration direction, in range [0, 1]. At 1 the direction is completely random.

Arguments:

  • value : float

ParticleMotionAccelerationHandle.directionMode: ParticleAccelerationDirectionMode
ParticleMotionAccelerationHandle.directionMode =(value: ParticleAccelerationDirectionMode)

How the added direction is computed. See ParticleAccelerationDirectionMode enum description for details.

Arguments:
ParticleMotionAccelerationHandle.point: ParticleMotionAccelerationPointHandle

Parameters used when directionMode is Point.

ParticleMotionAccelerationHandle.vector: ParticleMotionAccelerationVectorHandle

Parameters used when directionMode is Vector.

ParticleMotionAccelerationHandle.cone: ParticleMotionAccelerationConeHandle

Parameters used when directionMode is Cone.

ParticleMotionAccelerationPointHandle

Handle to the motion.acceleration.point field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionAccelerationPointHandle.offset: float3
ParticleMotionAccelerationPointHandle.offset =(value: float3)

Point the velocity radiates from, relative to the spawn position. Particles move away from this point.

Arguments:

  • value : float3

ParticleMotionAccelerationVectorHandle

Handle to the motion.acceleration.vector field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionAccelerationVectorHandle.direction: float3
ParticleMotionAccelerationVectorHandle.direction =(value: float3)

Velocity direction vector.

Arguments:

  • value : float3

ParticleMotionAccelerationConeHandle

Handle to the motion.acceleration.cone field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionAccelerationConeHandle.direction: float3
ParticleMotionAccelerationConeHandle.direction =(value: float3)

Axis direction the cone points along.

Arguments:

  • value : float3

ParticleMotionAccelerationConeHandle.offset: float3
ParticleMotionAccelerationConeHandle.offset =(value: float3)

Apex offset of the cone relative to the spawn position.

Arguments:

  • value : float3

ParticleMotionAccelerationConeHandle.widthTop: float
ParticleMotionAccelerationConeHandle.widthTop =(value: float)

Radius of the cone at its far (top) end.

Arguments:

  • value : float

ParticleMotionAccelerationConeHandle.widthBottom: float
ParticleMotionAccelerationConeHandle.widthBottom =(value: float)

Radius of the cone at its base (bottom) end.

Arguments:

  • value : float

ParticleMotionAccelerationConeHandle.height: float
ParticleMotionAccelerationConeHandle.height =(value: float)

Cone height along its axis.

Arguments:

  • value : float

ParticleMotionAccelerationConeHandle.centerPower: float
ParticleMotionAccelerationConeHandle.centerPower =(value: float)

Biases the velocity distribution toward the center of the cone. Higher values concentrate particles along the axis.

Arguments:

  • value : float

ParticleMotionAccelerationConeHandle.borderPower: float
ParticleMotionAccelerationConeHandle.borderPower =(value: float)

Biases the velocity distribution toward the border of the cone. Higher values concentrate particles along the rim.

Arguments:

  • value : float

ParticleMotionVortexHandle

Handle to the motion.vortex field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionVortexHandle.active: bool
ParticleMotionVortexHandle.active =(value: bool)

Enables a vortex that swirls particles around an axis.

Arguments:

  • value : bool

ParticleMotionVortexHandle.direction: float3
ParticleMotionVortexHandle.direction =(value: float3)

Direction of the vortex rotation axis.

Arguments:

  • value : float3

ParticleMotionVortexHandle.directionRandom: float
ParticleMotionVortexHandle.directionRandom =(value: float)

Random deviation applied to the axis direction, in range [0, 1]. At 1 the direction is completely random.

Arguments:

  • value : float

ParticleMotionVortexHandle.center: float3
ParticleMotionVortexHandle.center =(value: float3)

Origin point of the vortex relative to the emitter.

Arguments:

  • value : float3

ParticleMotionVortexHandle.centerRandom: float3
ParticleMotionVortexHandle.centerRandom =(value: float3)

Random offset applied to the vortex center.

Arguments:

  • value : float3

ParticleMotionVortexHandle.rotationStrengthRange: float2
ParticleMotionVortexHandle.rotationStrengthRange =(value: float2)

Minimum and maximum angular acceleration around the vortex axis, randomized per particle. Scales with distance from the axis.

Arguments:

  • value : float2

ParticleMotionVortexHandle.rotationStrengthCurve: ParticleMotionVortexRotationStrengthCurveKeysHandle

Optional curve scaling the rotation strength over particle life. Leave empty to disable.

ParticleMotionVortexHandle.pullStrengthRange: float2
ParticleMotionVortexHandle.pullStrengthRange =(value: float2)

Minimum and maximum pull strength toward the vortex axis, randomized per particle.

Arguments:

  • value : float2

ParticleMotionVortexHandle.pullStrengthCurve: ParticleMotionVortexPullStrengthCurveKeysHandle

Optional curve scaling the pull strength over particle life. Leave empty to disable.

ParticleMotionVortexRotationStrengthCurveKeysHandle

Handle to the motion.vortex.rotationStrengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleMotionVortexRotationStrengthCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleMotionVortexRotationStrengthCurveKeysHandle.push(): ParticleMotionVortexRotationStrengthCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleMotionVortexRotationStrengthCurveKeysHandle.pop()

Removes the last element from the array.

ParticleMotionVortexRotationStrengthCurveKeysHandle.clear()

Removes all elements from the array.

ParticleMotionVortexRotationStrengthCurveKeysHandle.insert(pos: int): ParticleMotionVortexRotationStrengthCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionVortexRotationStrengthCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionVortexRotationStrengthCurveKeysHandle.[](index: int): ParticleMotionVortexRotationStrengthCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleMotionVortexRotationStrengthCurveKeyHandle

Handle to the i-th element of the motion.vortex.rotationStrengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the motion.vortex.rotationStrengthCurve field of the component.

Properties:

ParticleMotionVortexRotationStrengthCurveKeyHandle.pos: float
ParticleMotionVortexRotationStrengthCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleMotionVortexRotationStrengthCurveKeyHandle.value: float
ParticleMotionVortexRotationStrengthCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleMotionVortexPullStrengthCurveKeysHandle

Handle to the motion.vortex.pullStrengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleMotionVortexPullStrengthCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleMotionVortexPullStrengthCurveKeysHandle.push(): ParticleMotionVortexPullStrengthCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleMotionVortexPullStrengthCurveKeysHandle.pop()

Removes the last element from the array.

ParticleMotionVortexPullStrengthCurveKeysHandle.clear()

Removes all elements from the array.

ParticleMotionVortexPullStrengthCurveKeysHandle.insert(pos: int): ParticleMotionVortexPullStrengthCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionVortexPullStrengthCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionVortexPullStrengthCurveKeysHandle.[](index: int): ParticleMotionVortexPullStrengthCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleMotionVortexPullStrengthCurveKeyHandle

Handle to the i-th element of the motion.vortex.pullStrengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the motion.vortex.pullStrengthCurve field of the component.

Properties:

ParticleMotionVortexPullStrengthCurveKeyHandle.pos: float
ParticleMotionVortexPullStrengthCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleMotionVortexPullStrengthCurveKeyHandle.value: float
ParticleMotionVortexPullStrengthCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleMotionNoiseHandle

Handle to the motion.noise field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionNoiseHandle.active: bool
ParticleMotionNoiseHandle.active =(value: bool)

Enables a noise field that perturbs particles.

Arguments:

  • value : bool

ParticleMotionNoiseHandle.frequency: float
ParticleMotionNoiseHandle.frequency =(value: float)

Spatial frequency of the noise pattern. Higher values produce finer, more detailed perturbation.

Arguments:

  • value : float

ParticleMotionNoiseHandle.strengthRange: float2
ParticleMotionNoiseHandle.strengthRange =(value: float2)

Minimum and maximum strength of the noise, randomized per particle.

Arguments:

  • value : float2

ParticleMotionNoiseHandle.strengthCurve: ParticleMotionNoiseStrengthCurveKeysHandle

Optional curve scaling the noise strength over particle life. Leave empty to disable.

ParticleMotionNoiseStrengthCurveKeysHandle

Handle to the motion.noise.strengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleMotionNoiseStrengthCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleMotionNoiseStrengthCurveKeysHandle.push(): ParticleMotionNoiseStrengthCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleMotionNoiseStrengthCurveKeysHandle.pop()

Removes the last element from the array.

ParticleMotionNoiseStrengthCurveKeysHandle.clear()

Removes all elements from the array.

ParticleMotionNoiseStrengthCurveKeysHandle.insert(pos: int): ParticleMotionNoiseStrengthCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionNoiseStrengthCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionNoiseStrengthCurveKeysHandle.[](index: int): ParticleMotionNoiseStrengthCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleMotionNoiseStrengthCurveKeyHandle

Handle to the i-th element of the motion.noise.strengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the motion.noise.strengthCurve field of the component.

Properties:

ParticleMotionNoiseStrengthCurveKeyHandle.pos: float
ParticleMotionNoiseStrengthCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleMotionNoiseStrengthCurveKeyHandle.value: float
ParticleMotionNoiseStrengthCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleMotionWindHandle

Handle to the motion.wind field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionWindHandle.active: bool
ParticleMotionWindHandle.active =(value: bool)

Enables wind force acting on particles.

Arguments:

  • value : bool

ParticleMotionWindHandle.strengthRange: float2
ParticleMotionWindHandle.strengthRange =(value: float2)

Strength range of the steady directional wind. The actual strength is selected randomly on each update step.

Arguments:

  • value : float2

ParticleMotionWindHandle.strengthCurve: ParticleMotionWindStrengthCurveKeysHandle

Optional curve attenuating the wind force over particle life. Leave empty to disable.

ParticleMotionWindHandle.turbulenceStrength: float
ParticleMotionWindHandle.turbulenceStrength =(value: float)

Strength of the chaotic turbulent wind component.

Arguments:

  • value : float

ParticleMotionWindHandle.turbulenceFrequency: float
ParticleMotionWindHandle.turbulenceFrequency =(value: float)

Spatial frequency of the turbulence pattern.

Arguments:

  • value : float

ParticleMotionWindStrengthCurveKeysHandle

Handle to the motion.wind.strengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleMotionWindStrengthCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleMotionWindStrengthCurveKeysHandle.push(): ParticleMotionWindStrengthCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleMotionWindStrengthCurveKeysHandle.pop()

Removes the last element from the array.

ParticleMotionWindStrengthCurveKeysHandle.clear()

Removes all elements from the array.

ParticleMotionWindStrengthCurveKeysHandle.insert(pos: int): ParticleMotionWindStrengthCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionWindStrengthCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionWindStrengthCurveKeysHandle.[](index: int): ParticleMotionWindStrengthCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleMotionWindStrengthCurveKeyHandle

Handle to the i-th element of the motion.wind.strengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the motion.wind.strengthCurve field of the component.

Properties:

ParticleMotionWindStrengthCurveKeyHandle.pos: float
ParticleMotionWindStrengthCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleMotionWindStrengthCurveKeyHandle.value: float
ParticleMotionWindStrengthCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleMotionDragHandle

Handle to the motion.drag field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleMotionDragHandle.active: bool
ParticleMotionDragHandle.active =(value: bool)

Enables a drag force that slows down particles over time.

Arguments:

  • value : bool

ParticleMotionDragHandle.strength: float
ParticleMotionDragHandle.strength =(value: float)

Air drag coefficient. Higher values slow particles down faster but make them more affected by wind.

Arguments:

  • value : float

ParticleMotionDragHandle.strengthCurve: ParticleMotionDragStrengthCurveKeysHandle

Optional curve scaling the drag coefficient over particle life. Leave empty to disable.

ParticleMotionDragHandle.radiusFactor: float
ParticleMotionDragHandle.radiusFactor =(value: float)

How much drag scales with particle radius, in range [0, 1]. At 0 drag ignores size; at 1 larger particles experience proportionally more drag.

Arguments:

  • value : float

ParticleMotionDragStrengthCurveKeysHandle

Handle to the motion.drag.strengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleMotionDragStrengthCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleMotionDragStrengthCurveKeysHandle.push(): ParticleMotionDragStrengthCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleMotionDragStrengthCurveKeysHandle.pop()

Removes the last element from the array.

ParticleMotionDragStrengthCurveKeysHandle.clear()

Removes all elements from the array.

ParticleMotionDragStrengthCurveKeysHandle.insert(pos: int): ParticleMotionDragStrengthCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionDragStrengthCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleMotionDragStrengthCurveKeysHandle.[](index: int): ParticleMotionDragStrengthCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleMotionDragStrengthCurveKeyHandle

Handle to the i-th element of the motion.drag.strengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the motion.drag.strengthCurve field of the component.

Properties:

ParticleMotionDragStrengthCurveKeyHandle.pos: float
ParticleMotionDragStrengthCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleMotionDragStrengthCurveKeyHandle.value: float
ParticleMotionDragStrengthCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleRenderHandle

Handle to the render field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleRenderHandle.blendMode: ParticleBlendMode
ParticleRenderHandle.blendMode =(value: ParticleBlendMode)

How particles blend with the scene. See ParticleBlendMode enum description for details.

Arguments:
ParticleRenderHandle.reverseParticlesOrder: bool
ParticleRenderHandle.reverseParticlesOrder =(value: bool)

Render particles in reverse spawn order.

Arguments:

  • value : bool

ParticleRenderHandle.shape: ParticleRenderShapeHandle

Particle shape and size settings.

ParticleRenderHandle.rotation: ParticleRotationHandle

Particle rotation settings.

ParticleRenderHandle.texture: ParticleTextureHandle

Texture, flipbook animation and color-remap settings.

ParticleRenderHandle.color: ParticleColorHandle

Color tint settings over particle lifetime or index.

ParticleRenderHandle.emission: ParticleRenderEmissionHandle

Color emission settings.

ParticleRenderHandle.lighting: ParticleLightingHandle

Lighting settings.

ParticleRenderHandle.depthMask: ParticleDepthMaskHandle

Soft depth fade settings.

ParticleRenderShapeHandle

Handle to the render.shape field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleRenderShapeHandle.radiusRange: float2
ParticleRenderShapeHandle.radiusRange =(value: float2)

Minimum and maximum particle radius, randomized per particle.

Arguments:

  • value : float2

ParticleRenderShapeHandle.radiusCurve: ParticleRenderShapeRadiusCurveKeysHandle

Optional curve scaling the radius over particle life. Leave empty to disable.

ParticleRenderShapeHandle.kind: ParticleRenderShapeKind
ParticleRenderShapeHandle.kind =(value: ParticleRenderShapeKind)

Whether particles render as individual billboards or as a connected ribbon. See ParticleRenderShapeKind enum description for details.

Arguments:
ParticleRenderShapeHandle.billboard: ParticleRenderShapeBillboardHandle

Parameters used when kind is Billboard.

ParticleRenderShapeHandle.ribbon: ParticleRenderShapeRibbonHandle

Parameters used when kind is Ribbon.

ParticleRenderShapeRadiusCurveKeysHandle

Handle to the render.shape.radiusCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleRenderShapeRadiusCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleRenderShapeRadiusCurveKeysHandle.push(): ParticleRenderShapeRadiusCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleRenderShapeRadiusCurveKeysHandle.pop()

Removes the last element from the array.

ParticleRenderShapeRadiusCurveKeysHandle.clear()

Removes all elements from the array.

ParticleRenderShapeRadiusCurveKeysHandle.insert(pos: int): ParticleRenderShapeRadiusCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleRenderShapeRadiusCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleRenderShapeRadiusCurveKeysHandle.[](index: int): ParticleRenderShapeRadiusCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleRenderShapeRadiusCurveKeyHandle

Handle to the i-th element of the render.shape.radiusCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the render.shape.radiusCurve field of the component.

Properties:

ParticleRenderShapeRadiusCurveKeyHandle.pos: float
ParticleRenderShapeRadiusCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleRenderShapeRadiusCurveKeyHandle.value: float
ParticleRenderShapeRadiusCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleRenderShapeBillboardHandle

Handle to the render.shape.billboard field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleRenderShapeBillboardHandle.aspect: float
ParticleRenderShapeBillboardHandle.aspect =(value: float)

Shape ratio in range [0, 2]. At 1 the quad is square. Below 1 the width is reduced (tall); above 1 the height is reduced (wide).

Arguments:

  • value : float

ParticleRenderShapeBillboardHandle.pivotOffset: float2
ParticleRenderShapeBillboardHandle.pivotOffset =(value: float2)

Shifts the billboard’s pivot in local billboard space. Each unit equals the particle radius in that axis.

Arguments:

  • value : float2

ParticleRenderShapeBillboardHandle.orientation: ParticleBillboardOrientation
ParticleRenderShapeBillboardHandle.orientation =(value: ParticleBillboardOrientation)

How the billboard is oriented relative to the camera. See ParticleBillboardOrientation enum description for details.

Arguments:
ParticleRenderShapeBillboardHandle.staticUpVector: float3
ParticleRenderShapeBillboardHandle.staticUpVector =(value: float3)

Up vector used when orientation is Static.

Arguments:

  • value : float3

ParticleRenderShapeBillboardHandle.staticRightVector: float3
ParticleRenderShapeBillboardHandle.staticRightVector =(value: float3)

Right vector used when orientation is Static.

Arguments:

  • value : float3

ParticleRenderShapeBillboardHandle.crossFadeMul: float
ParticleRenderShapeBillboardHandle.crossFadeMul =(value: float)

Fades alpha when the billboard is seen edge-on. 0 disables the effect; higher values increase the fade amount.

Arguments:

  • value : float

ParticleRenderShapeBillboardHandle.crossFadePow: int
ParticleRenderShapeBillboardHandle.crossFadePow =(value: int)

Power of the edge-on fade curve. Higher values keep the billboard more visible until it becomes nearly edge-on.

Arguments:

  • value : int

ParticleRenderShapeBillboardHandle.crossFadeThreshold: float
ParticleRenderShapeBillboardHandle.crossFadeThreshold =(value: float)

Dot-product threshold above which edge-on fading begins, in range [0, 1].

Arguments:

  • value : float

ParticleRenderShapeBillboardHandle.velocityToLength: float
ParticleRenderShapeBillboardHandle.velocityToLength =(value: float)

Maximum elongation multiplier applied along the velocity direction at full speed, when orientation is Velocity. Above 0.05 the billboard also stretches with speed; at or below 0.05 it only rotates to face the velocity direction.

Arguments:

  • value : float

ParticleRenderShapeBillboardHandle.velocityToLengthRange: float2
ParticleRenderShapeBillboardHandle.velocityToLengthRange =(value: float2)

Particle speed range mapped to the velocity elongation, when orientation is Velocity. Below x there is no stretch; at y and above the stretch reaches the maximum defined by velocityToLength.

Arguments:

  • value : float2

ParticleRenderShapeRibbonHandle

Handle to the render.shape.ribbon field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleRenderShapeRibbonHandle.mode: ParticleRibbonMode
ParticleRenderShapeRibbonHandle.mode =(value: ParticleRibbonMode)

Whether the ribbon has only side faces or also a head cap. See ParticleRibbonMode enum description for details.

Arguments:
ParticleRenderShapeRibbonHandle.uvMapping: ParticleRibbonUVMapping
ParticleRenderShapeRibbonHandle.uvMapping =(value: ParticleRibbonUVMapping)

How texture coordinates are mapped along the ribbon. See ParticleRibbonUVMapping enum description for details.

Arguments:
ParticleRenderShapeRibbonHandle.uvTile: float
ParticleRenderShapeRibbonHandle.uvTile =(value: float)

Number of times the texture repeats along the ribbon.

Arguments:

  • value : float

ParticleRenderShapeRibbonHandle.sideFadeThreshold: float
ParticleRenderShapeRibbonHandle.sideFadeThreshold =(value: float)

Position along the ribbon where the side faces begin to fade, in range [0, 1].

Arguments:

  • value : float

ParticleRenderShapeRibbonHandle.sideFadePow: float
ParticleRenderShapeRibbonHandle.sideFadePow =(value: float)

Power curve applied to the side fade.

Arguments:

  • value : float

ParticleRenderShapeRibbonHandle.headFadeThreshold: float
ParticleRenderShapeRibbonHandle.headFadeThreshold =(value: float)

Position where the head cap begins to fade, in range [0, 1].

Arguments:

  • value : float

ParticleRenderShapeRibbonHandle.headFadePow: float
ParticleRenderShapeRibbonHandle.headFadePow =(value: float)

Power curve applied to the head fade.

Arguments:

  • value : float

ParticleRotationHandle

Handle to the render.rotation field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleRotationHandle.active: bool
ParticleRotationHandle.active =(value: bool)

Enables particle rotation.

Arguments:

  • value : bool

ParticleRotationHandle.angleRange: float2
ParticleRotationHandle.angleRange =(value: float2)

Minimum and maximum initial rotation angle in degrees, randomized per particle.

Arguments:

  • value : float2

ParticleRotationHandle.spinSpeedRange: float2
ParticleRotationHandle.spinSpeedRange =(value: float2)

Minimum and maximum rotation speed in degrees per second, randomized per particle.

Arguments:

  • value : float2

ParticleRotationHandle.spinSpeedCurve: ParticleRotationSpinSpeedCurveKeysHandle

Optional curve scaling the rotation speed over particle life. Leave empty to disable.

ParticleRotationSpinSpeedCurveKeysHandle

Handle to the render.rotation.spinSpeedCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleRotationSpinSpeedCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleRotationSpinSpeedCurveKeysHandle.push(): ParticleRotationSpinSpeedCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleRotationSpinSpeedCurveKeysHandle.pop()

Removes the last element from the array.

ParticleRotationSpinSpeedCurveKeysHandle.clear()

Removes all elements from the array.

ParticleRotationSpinSpeedCurveKeysHandle.insert(pos: int): ParticleRotationSpinSpeedCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleRotationSpinSpeedCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleRotationSpinSpeedCurveKeysHandle.[](index: int): ParticleRotationSpinSpeedCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleRotationSpinSpeedCurveKeyHandle

Handle to the i-th element of the render.rotation.spinSpeedCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the render.rotation.spinSpeedCurve field of the component.

Properties:

ParticleRotationSpinSpeedCurveKeyHandle.pos: float
ParticleRotationSpinSpeedCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleRotationSpinSpeedCurveKeyHandle.value: float
ParticleRotationSpinSpeedCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleTextureHandle

Handle to the render.texture field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleTextureHandle.framesX: int
ParticleTextureHandle.framesX =(value: int)

Number of flipbook columns in the texture atlas.

Arguments:

  • value : int

ParticleTextureHandle.framesY: int
ParticleTextureHandle.framesY =(value: int)

Number of flipbook rows in the texture atlas.

Arguments:

  • value : int

ParticleTextureHandle.startFrameRange: int2
ParticleTextureHandle.startFrameRange =(value: int2)

Minimum and maximum starting frame index, randomized per particle.

Arguments:

  • value : int2

ParticleTextureHandle.randomFlipX: bool
ParticleTextureHandle.randomFlipX =(value: bool)

Randomly mirror particles horizontally.

Arguments:

  • value : bool

ParticleTextureHandle.randomFlipY: bool
ParticleTextureHandle.randomFlipY =(value: bool)

Randomly mirror particles vertically.

Arguments:

  • value : bool

ParticleTextureHandle.animation: ParticleTextureAnimationHandle

Flipbook animation settings.

ParticleTextureHandle.colorRemap: ParticleTextureColorRampKeysHandle

Remaps the texture’s R channel value through a color gradient. Leave empty to disable.

ParticleTextureAnimationHandle

Handle to the render.texture.animation field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleTextureAnimationHandle.active: bool
ParticleTextureAnimationHandle.active =(value: bool)

Enables flipbook texture animation over the atlas frames. The whole animation covers the particle’s lifetime unless the animation speed is changed by the speedRange parameter.

Arguments:

  • value : bool

ParticleTextureAnimationHandle.blendFrames: bool
ParticleTextureAnimationHandle.blendFrames =(value: bool)

Cross-fade between consecutive animation frames for smoother playback.

Arguments:

  • value : bool

ParticleTextureAnimationHandle.enableLoop: bool
ParticleTextureAnimationHandle.enableLoop =(value: bool)

Enable animation looping.

Arguments:

  • value : bool

ParticleTextureAnimationHandle.speedRange: float2
ParticleTextureAnimationHandle.speedRange =(value: float2)

Animation speed multiplier range. The actual speed is selected randomly per particle within this range. When speed is 1 the animation covers exactly the particle’s lifetime.

Arguments:

  • value : float2

ParticleTextureAnimationHandle.speedCurve: ParticleTextureAnimationSpeedCurveKeysHandle

Optional curve driving the animation frame over particle life. Leave empty to disable.

ParticleTextureAnimationSpeedCurveKeysHandle

Handle to the render.texture.animation.speedCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleTextureAnimationSpeedCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleTextureAnimationSpeedCurveKeysHandle.push(): ParticleTextureAnimationSpeedCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleTextureAnimationSpeedCurveKeysHandle.pop()

Removes the last element from the array.

ParticleTextureAnimationSpeedCurveKeysHandle.clear()

Removes all elements from the array.

ParticleTextureAnimationSpeedCurveKeysHandle.insert(pos: int): ParticleTextureAnimationSpeedCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleTextureAnimationSpeedCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleTextureAnimationSpeedCurveKeysHandle.[](index: int): ParticleTextureAnimationSpeedCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleTextureAnimationSpeedCurveKeyHandle

Handle to the i-th element of the render.texture.animation.speedCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the render.texture.animation.speedCurve field of the component.

Properties:

ParticleTextureAnimationSpeedCurveKeyHandle.pos: float
ParticleTextureAnimationSpeedCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleTextureAnimationSpeedCurveKeyHandle.value: float
ParticleTextureAnimationSpeedCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleTextureColorRampKeysHandle

Handle to the render.texture.colorRemap field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleTextureColorRampKeysHandle.length(): int

Returns the number of elements in the array.

ParticleTextureColorRampKeysHandle.push(): ParticleTextureColorRampKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleTextureColorRampKeysHandle.pop()

Removes the last element from the array.

ParticleTextureColorRampKeysHandle.clear()

Removes all elements from the array.

ParticleTextureColorRampKeysHandle.insert(pos: int): ParticleTextureColorRampKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleTextureColorRampKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleTextureColorRampKeysHandle.[](index: int): ParticleTextureColorRampKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleTextureColorRampKeyHandle

Handle to the i-th element of the render.texture.colorRemap field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the render.texture.colorRemap field of the component.

Properties:

ParticleTextureColorRampKeyHandle.pos: float
ParticleTextureColorRampKeyHandle.pos =(value: float)

Normalized position of the color stop along the gradient in range [0, 1].

Arguments:

  • value : float

ParticleTextureColorRampKeyHandle.color: float4
ParticleTextureColorRampKeyHandle.color =(value: float4)

Color at this gradient stop.

Arguments:

  • value : float4

ParticleColorHandle

Handle to the render.color field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleColorHandle.active: bool
ParticleColorHandle.active =(value: bool)

Enables color tinting and emission. When disabled the texture is drawn unmodulated.

Arguments:

  • value : bool

ParticleColorHandle.tintFrom: float4
ParticleColorHandle.tintFrom =(value: float4)

One end of the per-particle random tint range. The final particle color is picked randomly between tintFrom and tintTo.

Arguments:

  • value : float4

ParticleColorHandle.tintTo: float4
ParticleColorHandle.tintTo =(value: float4)

The other end of the per-particle random tint range. The final particle color is picked randomly between tintFrom and tintTo.

Arguments:

  • value : float4

ParticleColorHandle.gradient: ParticleColorGradientHandle

Optional color gradient applied over particle life or particle index.

ParticleColorHandle.curve: ParticleColorCurveHandle

Optional per-channel color and alpha curve applied over particle life or particle index.

ParticleColorHandle.alphaCurveByVelocity: ParticleAlphaCurveByVelocityHandle

Optional alpha modulation driven by particle speed.

ParticleColorHandle.alphaDissolve: bool
ParticleColorHandle.alphaDissolve =(value: bool)

When enabled, alpha modulation is performed as subtraction instead of multiplication: alphaOut = alphaIn - (1 - alphaCurve). It creates a dissolve effect instead of a uniform fade.

Arguments:

  • value : bool

ParticleColorGradientHandle

Handle to the render.color.gradient field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleColorGradientHandle.useParticleIndexAsKey: bool
ParticleColorGradientHandle.useParticleIndexAsKey =(value: bool)

When enabled, the gradient is sampled by the particle’s spawn index instead of its age, giving each particle a single constant color picked along the gradient.

Arguments:

  • value : bool

ParticleColorGradientHandle.keys: ParticleColorGradientKeysHandle

Color gradient stops. Leave the array empty to disable this gradient.

ParticleColorGradientKeysHandle

Handle to the render.color.gradient.keys field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleColorGradientKeysHandle.length(): int

Returns the number of elements in the array.

ParticleColorGradientKeysHandle.push(): ParticleColorGradientKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleColorGradientKeysHandle.pop()

Removes the last element from the array.

ParticleColorGradientKeysHandle.clear()

Removes all elements from the array.

ParticleColorGradientKeysHandle.insert(pos: int): ParticleColorGradientKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleColorGradientKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleColorGradientKeysHandle.[](index: int): ParticleColorGradientKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleColorGradientKeyHandle

Handle to the i-th element of the render.color.gradient.keys field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the render.color.gradient.keys field of the component.

Properties:

ParticleColorGradientKeyHandle.pos: float
ParticleColorGradientKeyHandle.pos =(value: float)

Normalized position of the color stop along the gradient in range [0, 1].

Arguments:

  • value : float

ParticleColorGradientKeyHandle.color: float4
ParticleColorGradientKeyHandle.color =(value: float4)

Color at this gradient stop.

Arguments:

  • value : float4

ParticleColorCurveHandle

Handle to the render.color.curve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleColorCurveHandle.mask: float4
ParticleColorCurveHandle.mask =(value: float4)

Color channels the curve modulates. The curve value scales the masked channels; the default mask targets alpha only.

Arguments:

  • value : float4

ParticleColorCurveHandle.useParticleIndexAsKey: bool
ParticleColorCurveHandle.useParticleIndexAsKey =(value: bool)

Sample the curve by particle spawn index instead of particle age.

Arguments:

  • value : bool

ParticleColorCurveHandle.keys: ParticleColorCurveKeysHandle

Curve values applied over the key range. Leave empty to disable.

ParticleColorCurveKeysHandle

Handle to the render.color.curve.keys field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleColorCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleColorCurveKeysHandle.push(): ParticleColorCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleColorCurveKeysHandle.pop()

Removes the last element from the array.

ParticleColorCurveKeysHandle.clear()

Removes all elements from the array.

ParticleColorCurveKeysHandle.insert(pos: int): ParticleColorCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleColorCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleColorCurveKeysHandle.[](index: int): ParticleColorCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleColorCurveKeyHandle

Handle to the i-th element of the render.color.curve.keys field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the render.color.curve.keys field of the component.

Properties:

ParticleColorCurveKeyHandle.pos: float
ParticleColorCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleColorCurveKeyHandle.value: float
ParticleColorCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleAlphaCurveByVelocityHandle

Handle to the render.color.alphaCurveByVelocity field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleAlphaCurveByVelocityHandle.active: bool
ParticleAlphaCurveByVelocityHandle.active =(value: bool)

Enables fading particle alpha based on its speed.

Arguments:

  • value : bool

ParticleAlphaCurveByVelocityHandle.velocityRange: float2
ParticleAlphaCurveByVelocityHandle.velocityRange =(value: float2)

Speed range mapped onto the alpha curve; speeds are normalized between these minimum and maximum values.

Arguments:

  • value : float2

ParticleAlphaCurveByVelocityHandle.keys: ParticleAlphaCurveByVelocityKeysHandle

Alpha multiplier as a function of normalized velocity. Leave empty to disable.

ParticleAlphaCurveByVelocityKeysHandle

Handle to the render.color.alphaCurveByVelocity.keys field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleAlphaCurveByVelocityKeysHandle.length(): int

Returns the number of elements in the array.

ParticleAlphaCurveByVelocityKeysHandle.push(): ParticleAlphaCurveByVelocityKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleAlphaCurveByVelocityKeysHandle.pop()

Removes the last element from the array.

ParticleAlphaCurveByVelocityKeysHandle.clear()

Removes all elements from the array.

ParticleAlphaCurveByVelocityKeysHandle.insert(pos: int): ParticleAlphaCurveByVelocityKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleAlphaCurveByVelocityKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleAlphaCurveByVelocityKeysHandle.[](index: int): ParticleAlphaCurveByVelocityKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleAlphaCurveByVelocityKeyHandle

Handle to the i-th element of the render.color.alphaCurveByVelocity.keys field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the render.color.alphaCurveByVelocity.keys field of the component.

Properties:

ParticleAlphaCurveByVelocityKeyHandle.pos: float
ParticleAlphaCurveByVelocityKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleAlphaCurveByVelocityKeyHandle.value: float
ParticleAlphaCurveByVelocityKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleRenderEmissionHandle

Handle to the render.emission field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleRenderEmissionHandle.active: bool
ParticleRenderEmissionHandle.active =(value: bool)

Enables particle emission which is applied as a per-channel multiplier to the final color.

Arguments:

  • value : bool

ParticleRenderEmissionHandle.mask: float3
ParticleRenderEmissionHandle.mask =(value: float3)

Per-channel emission multiplier. When render.texture.colorRemap is used, only R is effective and it multiplies all channels.

Arguments:

  • value : float3

ParticleRenderEmissionHandle.strength: float
ParticleRenderEmissionHandle.strength =(value: float)

Emissive intensity multiplier. Values above zero make particles glow and contribute to bloom.

Arguments:

  • value : float

ParticleRenderEmissionHandle.strengthCurve: ParticleRenderEmissionStrengthCurveKeysHandle

Optional emission intensity curve over particle life. Leave empty to disable.

ParticleRenderEmissionStrengthCurveKeysHandle

Handle to the render.emission.strengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

ParticleRenderEmissionStrengthCurveKeysHandle.length(): int

Returns the number of elements in the array.

ParticleRenderEmissionStrengthCurveKeysHandle.push(): ParticleRenderEmissionStrengthCurveKeyHandle

Appends an element to the end of the array and returns a handle to it.

ParticleRenderEmissionStrengthCurveKeysHandle.pop()

Removes the last element from the array.

ParticleRenderEmissionStrengthCurveKeysHandle.clear()

Removes all elements from the array.

ParticleRenderEmissionStrengthCurveKeysHandle.insert(pos: int): ParticleRenderEmissionStrengthCurveKeyHandle

Inserts an element at the specified position in the array.

Arguments:

  • pos : int

ParticleRenderEmissionStrengthCurveKeysHandle.erase(pos: int)

Removes the element at the specified position in the array.

Arguments:

  • pos : int

ParticleRenderEmissionStrengthCurveKeysHandle.[](index: int): ParticleRenderEmissionStrengthCurveKeyHandle

Retrieves a handle to the i-th element of the array field.

Arguments:

  • index : int

ParticleRenderEmissionStrengthCurveKeyHandle

Handle to the i-th element of the render.emission.strengthCurve field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

  • index0 : int - Index within the render.emission.strengthCurve field of the component.

Properties:

ParticleRenderEmissionStrengthCurveKeyHandle.pos: float
ParticleRenderEmissionStrengthCurveKeyHandle.pos =(value: float)

Normalized position of the key along the curve in range [0, 1], where 0 is particle birth and 1 is its death.

Arguments:

  • value : float

ParticleRenderEmissionStrengthCurveKeyHandle.value: float
ParticleRenderEmissionStrengthCurveKeyHandle.value =(value: float)

Curve value at this key.

Arguments:

  • value : float

ParticleLightingHandle

Handle to the render.lighting field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleLightingHandle.active: bool
ParticleLightingHandle.active =(value: bool)

Enables particle lighting.

Arguments:

  • value : bool

ParticleLightingHandle.mode: ParticleLightingMode
ParticleLightingHandle.mode =(value: ParticleLightingMode)

How particles are lit. See ParticleLightingMode enum description for details.

Arguments:
ParticleLightingHandle.normalSoftness: float
ParticleLightingHandle.normalSoftness =(value: float)

Softens the surface normals used for lighting, flattening the shading, in range [0, 1].

Arguments:

  • value : float

ParticleLightingHandle.usePointLights: bool
ParticleLightingHandle.usePointLights =(value: bool)

Include scene point lights when lighting particles.

Arguments:

  • value : bool

ParticleLightingHandle.translucency: float
ParticleLightingHandle.translucency =(value: float)

Amount of light that passes through the particle, simulating back-lighting, in range [0, 1].

Arguments:

  • value : float

ParticleDepthMaskHandle

Handle to the render.depthMask field of ParticleSystem component.

Fields:

  • nodeId : NodeId - The node this component is attached to.

Properties:

ParticleDepthMaskHandle.active: bool
ParticleDepthMaskHandle.active =(value: bool)

Enables soft depth fading where particles intersect scene geometry, hiding hard intersection seams.

Arguments:

  • value : bool

ParticleDepthMaskHandle.useParticleRadius: bool
ParticleDepthMaskHandle.useParticleRadius =(value: bool)

Scale the depth softness by the particle radius.

Arguments:

  • value : bool

ParticleDepthMaskHandle.depthSoftness: float
ParticleDepthMaskHandle.depthSoftness =(value: float)

Distance over which particles fade as they approach scene geometry.

Arguments:

  • value : float

ParticleDepthMaskHandle.znearSoftness: float
ParticleDepthMaskHandle.znearSoftness =(value: float)

Distance over which particles fade as they approach the camera near plane.

Arguments:

  • value : float

ParticleDepthMaskHandle.znearClip: float
ParticleDepthMaskHandle.znearClip =(value: float)

Hard clip distance from the camera near plane below which particles are not drawn.

Arguments:

  • value : float

Functions

set_particles_global_wind(direction: float; strength: float)

Sets the global wind direction and strength for instances of ParticleSystem.

Arguments:

  • direction : float - wind direction in degrees

  • strength : float - global wind strength which is then multiplied by per-ParticleSystem wind strength to get wind’s final speed in m/s