Particle System Modules

In the Inspector, each module appears as a section of the ParticleSystem component. In a .particle.json profile, the same module names are stored under modules so teams can review profile changes in version control when they need to.

Lenga uses familiar module names where that helps teams coming from other engines, but the current particle system is not a complete Unity Shuriken clone. The sections below describe what Lenga runs today and call out important limits so effects do not depend on controls that are still on the roadmap.

Main

The Main module controls the base simulation.

Important fields:

• duration: length of one emitter cycle
• looping: whether the emitter restarts after its duration
• prewarm: whether looping systems simulate one cycle before first render
• playOnAwake: whether playback starts when the scene starts
• simulationSpace: Local, World, or Custom with a referenced scene object whose Transform defines the simulation space
• deltaTime: Scaled follows the global time scale, Unscaled keeps simulating through pauses and slow motion
• scalingMode: how Transform scale affects the effect — Hierarchy (full world scale), Local (the emitter's own scale), or Shape (scale only affects spawn positions)
• emitterVelocityMode: whether emitter speed is measured from Transform movement or read from an attached Rigidbody
• stopAction: None, Disable, or Destroy applied to the GameObject once a stopped system has no live particles
• ringBufferMode: keep particles alive until their pool slot is reused — PauseUntilReplaced holds their final state, LoopUntilReplaced loops their age inside ringBufferLoopRange
• startDelay: delay before the emitter begins its active cycle
• startLifetime: how long particles live
• startSpeed: initial speed at spawn
• startSize: initial visual size, with an optional 3D toggle for independent X, Y, and Z sizes
• startRotation: initial rotation, with an optional 3D toggle for independent X, Y, and Z rotation
• flipRotation: probability that a new particle spins in the opposite direction
• startColor: color used when particles spawn
• simulationSpeed: multiplier for simulation time
• maxParticles: fixed pool size
• randomSeed and autoRandomSeed: deterministic playback controls

startDelay, startLifetime, startSpeed, startSize, startRotation, and startColor can be authored as constants, curves or gradients, random ranges, or random ranges between curves or gradients. Color fields also support a random-color mode that samples from a gradient palette.

flipRotation is a 0 to 1 probability. Use 0 when every particle should keep the authored rotation direction, 1 when every particle should spin the opposite way, and values between those when sparks, debris, or stylized motes need mixed spin directions. When rotation is flipped, every rotation axis is mirrored together.

The 3D toggles on startSize and startRotation switch between one uniform value and independent X, Y, and Z values. Both authored representations are kept, so switching back and forth never discards values. A scalar rotation always means rotation about the z axis, which is what 2D quads and billboard roll use; X and Y rotation tilt 3D billboards and become fully visible once oriented mesh particles are supported.

Use Main first. If an effect feels wrong, lifetime, speed, size, simulation space, and max particles are usually the first values to inspect.

Emission

The Emission module controls how particles are created.

Important fields:

• enabled
• rateOverTime
• rateOverDistance
• bursts

rateOverTime emits particles while the system is playing. rateOverDistance emits as the emitter moves. Both fields use the shared scalar editor, so they can be constants, curves, random ranges, or random ranges between curves.

Bursts create particles at specific times. Each burst row has:

• Time: when the burst happens within the emitter cycle
• Count: how many particles to emit, using the same scalar modes as other particle values
• Cycles: how many times the burst repeats
• Interval: seconds between repeated burst cycles
• Probability: the chance that the burst fires when it is due

Use Probability for variation, such as sparks that only sometimes split off from the main effect. Use Cycles and Interval for short repeated pulses without adding multiple identical rows.

Shape

The Shape module controls where particles spawn and which direction they start moving.

Supported shape data includes:

• Point
• Line (Unity calls this Edge; both names load)
• Circle
• Rectangle
• Cone2D
• Sphere
• Hemisphere
• Box
• Cone3D
• Donut: a torus where Radius is the ring, Donut Radius the tube, and radius thickness samples inside the tube; the arc modes walk the ring.
• Mesh Renderer: emits from a referenced MeshRenderer's vertices, edges, or triangles, optionally offset along the surface normal (Normal Offset) and tinted by vertex colors (Use Mesh Colors). Missing references fall back to point emission safely. Triangles are chosen uniformly by index; volume emission and material-index filtering are not offered because the mesh data cannot support them honestly.
• Sprite Renderer: emits across a referenced SpriteRenderer's world rectangle, honoring sprite-sheet source rects.

Shape fields include angle, spread, radius, radius thickness, arc, arc mode, arc spread, arc speed, length, emit-from mode, box size, local position, local rotation, local scale, align-to-direction, direction randomization, spherize direction, and position randomization.

Rectangle and Sprite Renderer sources can additionally use a Mask Texture: spawn points are rejected while the selected channel (Red/Green/Blue/Alpha) sits at or below Mask Threshold, and Mask Tints Color multiplies the sampled pixel into each particle's start color. Masking rejection-samples a bounded number of attempts per spawn so emission never stalls on sparse masks.

Use the Shape module for directional effects such as sparks and muzzle flashes. A narrow Cone2D or Cone3D, low radius thickness, and Align To Direction can produce a tight spray that reads clearly in motion.

When a particle system is selected, the scene view draws a wireframe outline of the emitter shape (including the shape's local offset, rotation, and scale) so you can see exactly where particles will spawn. The 2D scene view draws a flat outline; the 3D scene view draws the full wireframe for volumetric shapes such as Sphere, Box, and Cone3D. A shape with zero radius or size has no extent to outline, so switching shape types in the inspector seeds visible default sizes when the current values are degenerate.

Velocity Over Lifetime

Velocity Over Lifetime adds velocity as particles age. Use it when the particle should drift after spawn rather than only using its start speed. The linear values are a velocity, not an acceleration: they move particles directly and never build up. For accelerating motion use Force Over Lifetime.

• Linear X/Y/Z: velocity added along each axis, in Local (emitter) or World axes depending on Space.
• Orbital X/Y/Z: angular velocity in degrees/second around the orbit center (the emitter position plus Offset). Orbiting Z is the classic 2D swirl.
• Radial: velocity away from the orbit center — positive expands, negative attracts.
• Speed Modifier: multiplies each particle's whole frame velocity (its own motion plus this module's), so a curve here can freeze or burst entire effects.

Examples:

• smoke drifting sideways
• magic motes orbiting subtly
• rain blown by wind

Inherit Velocity

Inherit Velocity makes particles pick up a proportion of the emitter's own movement in Lenga's current runtime. Initial bakes the emitter velocity into each particle at spawn; Current keeps following the emitter's velocity as it changes. The Multiplier controls the proportion and can be a curve.

This module only affects systems that simulate in World space — in Local space particles already move with the emitter.

Use it for exhaust trails on moving vehicles, dust kicked up behind a runner, or any effect that should "carry" the motion of its source.

Unity uses this module mainly for sub-emitters inheriting the parent particle's velocity. That parent-particle inheritance path is planned for Lenga's sub-emitter parity work; today, author this module as emitter-transform velocity.

Lifetime By Emitter Speed

Lifetime By Emitter Speed scales the start lifetime of each new particle by a multiplier curve sampled from the emitter's speed, normalized between speedRangeMin and speedRangeMax.

Use it to keep trails compact at high speed: the faster the emitter moves, the shorter each particle lives.

Force Over Lifetime

Force Over Lifetime applies acceleration-like motion while particles live.

Use it for gravity, lift, wind, or pull.

Examples:

• sparks falling downward
• smoke rising upward
• leaves blown sideways

gravityModifier is a scalar value, so it can be a constant, a curve, a random range, or a random range between curves. Gravity always pulls along the world down axis, even for rotated systems simulating in local space.

Space chooses whether the force is applied along the emitter's axes or world axes. Random force ranges pick one stable value per particle from its seed; enable Randomize to re-roll the force every frame for jittery, energetic motion.

Color Over Lifetime

Color Over Lifetime multiplies each particle's start color by a color value from birth to death. It can be a constant color, a gradient, a random range between two colors, a random range between two gradients, or a random color sampled from a gradient palette.

Use it for:

• alpha fade-out
• heat shifting from white to orange to red
• smoke becoming lighter as it dissipates
• magic changing hue over time

For most effects, the final gradient key should have alpha 0 unless particles are meant to pop off sharply.

Color By Speed

Color By Speed multiplies particle color by a gradient sampled from the particle's current speed, normalized between speedRangeMin and speedRangeMax. It stacks with Color Over Lifetime.

Use it to make fast sparks burn white-hot while slow ones cool to red, or to fade particles out as they decelerate.

Size Over Lifetime

Size Over Lifetime multiplies each particle's start size as it ages.

Common patterns:

• dust grows while fading
• sparks shrink while fading
• smoke grows slowly
• raindrops stay nearly constant

The Start Size and End Size inspector fields write a simple size curve for compatibility with existing effects.

Separate Axes switches the multiplier to independent X, Y, and Z values so an effect can, for example, stretch vertically while thinning horizontally. The uniform value is kept when toggling.

Size By Speed

Size By Speed multiplies particle size by a curve sampled from the particle's current speed, normalized between speedRangeMin and speedRangeMax. It stacks with Size Over Lifetime and supports the same Separate Axes mode.

Use it to stretch the visual energy of an effect: fast debris reads bigger, slow drifting motes read smaller.

Rotation Over Lifetime

Rotation Over Lifetime spins particles as they age.

This is useful for textured particles where repetition would be obvious. Even a small random rotation can make dust, leaves, embers, and spark textures feel less tiled.

Separate Axes switches the angular velocity to independent X, Y, and Z values. The uniform value always means rotation about z, which is what 2D quads and billboard roll display.

Rotation By Speed

Rotation By Speed spins particles at an angular velocity sampled from the particle's current speed, normalized between speedRangeMin and speedRangeMax. It adds on top of Rotation Over Lifetime and supports the same Separate Axes mode.

Use it for tumbling debris or rolling chunks that should spin faster the faster they fly.

Noise

Noise perturbs particle motion with smooth, deterministic turbulence. Strength is a value over lifetime in simulation units per second (with an optional Separate Axes mode for per-axis strength), Frequency controls how quickly the turbulence changes over a particle's life, Octaves layers finer detail at extra cost (Octave Multiplier and Octave Scale tune the falloff and growth), and Scroll Speed drifts the noise field over time so even slow particles keep wandering.

Quality trades cost for richness: Low shares one noise channel across axes, Medium samples two, and High samples all three independently. Damping scales strength inversely with frequency so high-frequency noise stays subtle; it is off by default so existing effects keep their look. Remap reshapes the raw noise value through a curve.

The three amount fields route one shared noise sample into different outputs: Position Amount moves particles, Rotation Amount spins them (degrees per second), and Size Amount modulates render size fractionally.

Each particle follows its own noise path derived from its random seed, so seeded systems stay reproducible.

Use it for organic motion such as smoke, fire, magic, dust, or insects. Noise-heavy effects are more expensive and should be tested with realistic particle counts.

Limit Velocity

Limit Velocity caps particle speed and can dampen motion.

Speed is a value over lifetime; Dampen controls what fraction of the excess is removed each frame. Separate Axes clamps each axis independently in the module's Space (Local or World). Drag slows particles before clamping, optionally multiplied by particle size and/or current speed so large or fast particles lose more energy.

Use it when force, velocity, and noise combine into speeds that make the effect unreadable.

Module Evaluation Order

Combined motion stays predictable because modules always evaluate in one documented order each simulation step:

1. Velocity Over Lifetime samples its module velocity (linear, orbital, radial).
2. Force Over Lifetime and gravity integrate into the particle's velocity.
3. Limit Velocity applies drag, then clamps.
4. The particle moves by its own velocity plus the module velocity, scaled by Speed Modifier.
5. Noise perturbs position and rotation.
6. Inherit Velocity (Current mode) drifts position.
7. Collision, then Triggers.
8. Rotation Over Lifetime and Rotation By Speed spin the particle.
9. Trails record the final position.

Color and size (... Over Lifetime / ... By Speed) are resolved at render time from the final state.

Texture Sheet Animation

Texture Sheet Animation picks frames from a sprite sheet over particle lifetime.

Use it for:

• flipbook smoke
• animated fire
• spark variation
• stylized impact flashes

Mode selects where frames come from. Grid treats the renderer texture as a Tiles X by Tiles Y grid of equally sized frames, where Animation plays the whole sheet or a single row. Sprites plays a curated, ordered list of sprite assets instead; add or remove slots and pick the sprite for each slot directly in the inspector.

Time Mode chooses how frames advance: Lifetime samples the frame-over-time curve against particle age (optionally repeated with Cycles), Speed Range maps particle speed to a frame, and FPS advances frames at a fixed rate. Start Frame (or Random Start Frame) offsets where each particle begins so particles do not all display the same frame.

Intentional differences from Unity's module: a mesh-index row mode and UV channel selection are not offered yet, because Lenga particles do not have per-particle mesh indices or multiple renderer UV streams. Both arrive with the mesh rendering and material work rather than as inert controls here.

Collision

The Collision module deflects particles when they hit configured particle collision surfaces.

Use Planes when an effect should collide with an authored plane such as a floor, wall, or shield surface. Use World Colliders when the particles should collide with the scene physics world.

Important settings:

• Type chooses no collision, plane collision, or world-collider collision.
• Collides With chooses which GameObject layers world-collider particles can hit.
• Bounce controls how strongly particles rebound.
• Damping reduces sideways motion after impact.
• Lifetime Loss shortens particles when they hit.
• Radius Scale adjusts the particle collision radius.
• Min Kill Speed and Max Kill Speed kill particles whose speed after the collision response falls below or above the limits.
• Planes references scene objects whose Transforms define collision planes (position plus rotated up axis). The authored Plane Normal and Plane Distance apply when the list is empty; missing references are skipped safely.
• Send Messages records bounded per-frame collision events that scripts poll with getCollisionEvents().

Intentional differences from Unity: there are no collision-quality or cached-collision tiers (every live particle sweeps every frame — watch the collisionQueries profiling counter instead), queries return the first blocking hit, and collider-force output is not available yet.

Trails

Trails makes each particle leave a fading ribbon of its recent path.

Important settings:

• mode: Particles gives each particle its own path history; Ribbon connects the live particles to each other in stable spawn order — useful for lightning, chains, and streamers.
• ratio is the fraction of particles that record a trail; selection is deterministic per particle.
• lifetime is how long (in seconds) each recorded trail point survives before fading out.
• dieWithParticles (default on) removes a particle's trail when it dies; turn it off to let recorded points fade out naturally.
• width is the trail thickness in simulation units.
• widthOverTrail multiplies width from the trail head (new) to the tail (old); curves are supported in the module data.
• colorOverTrail multiplies color along the trail the same way.
• sizeAffectsWidth / sizeAffectsLifetime multiply width or lifetime by the particle's largest start-size axis.
• minVertexDistance is how far a particle must travel before a new point is recorded; larger values produce coarser, cheaper trails.
• inheritParticleColor multiplies the trail color with each particle's start color.
• color tints the whole trail; alpha fades along the trail with point age.

Each particle keeps a bounded number of trail points, so cost scales with Max Particles. Trail segments currently render as unlit lines; textured ribbon strips, trail materials, ribbon counts above one, and trail lighting/shadow controls arrive with the render batching work.

Sub Emitters

Sub Emitters let one particle system spawn particles on another particle system in response to particle events. Use this when a particle should create a secondary effect, such as sparks that leave tiny smoke puffs when they die, fireworks that spawn glitter at birth, or debris that creates a dust pop when it expires.

Each slot has:

• Event: Birth, Death, or Manual. Birth emits continuously across each parent particle's lifetime using the target system's emission rates (rate over time plus rate over distance measured from parent movement), and additionally bursts Emit Count particles the moment a parent spawns. Death bursts Emit Count particles when a parent dies, including when a ring-buffer particle is finally replaced. Manual slots fire only when a script calls triggerSubEmitter(). Collision and Trigger are visible but disabled until the collision-event and trigger-event phases of the particle roadmap.
• Target: a GameObject in the same scene that has a ParticleSystem component. You can pick it from the field or drag a ParticleSystem GameObject from the Hierarchy.
• Emit Count: how many particles the target system emits per event.
• Emit Probability: how likely the slot is to fire when the event occurs. A value of 0 never fires; a value of 1 always fires.
• Inherit flags: what spawned particles take from their parent particle. Color multiplies the child's start color by the parent's current color, Size multiplies the child's start size by the parent's current size, Rotation adds the parent's roll, and Lifetime scales the child's lifetime by the parent's remaining lifetime fraction.

Positions and velocities convert correctly between the two systems' simulation spaces, so a world-space parent can feed a local-space child and vice versa. When the target's Inherit Velocity module is enabled, its Initial mode adds the parent particle's velocity at spawn and its Current mode keeps following the parent's live velocity while the parent exists, falling back to the captured velocity afterwards.

To keep effects predictable and avoid runaway chains, particles spawned by a sub emitter do not generate additional sub-emitter events, and each system dispatches at most a bounded number of sub-emitter particles per frame (counted in the profiling counters when exceeded). Child burst rows are not yet applied per parent particle during Birth emission.

Triggers

Triggers let particles react to entering or leaving referenced collider volumes. Reference up to 32 scene objects with colliders; each particle tracks which of them it is inside using one overlap query per particle per frame (radius = particle radius times Radius Scale).

Each of the four conditions — Inside, Outside, Enter, and Exit — chooses an action:

• Ignore: nothing happens.
• Kill: the particle dies through the normal death path (Death sub emitters fire).
• Callback: a bounded per-frame trigger event is recorded; scripts poll them with getTriggerEvents().

Trigger sub-emitter slots fire when a particle enters any referenced collider. Missing or inactive collider references are skipped safely, and each referenced collider's own scene gizmo shows the effective bounds.

External Forces

External Forces lets scene-authored Particle Force Field components push particles around. Add a Particle Force Field component to any GameObject (Effects group in Add Component); its Transform places and orients the field.

Each field offers:

• Shape: Sphere (influence ramps from full strength at Start Range to zero at End Range) or Box (full strength inside the oriented Box Size).
• Direction: a constant force along the field's local axes.
• Gravity and Gravity Focus: pull toward the focus shell — focus 0 targets the field center, 1 targets the end-range shell, letting you build rings and orbits.
• Rotation Speed, Rotation Attraction, Rotation Randomness: a vortex around the field's up axis (z in 2D). Attraction pulls existing velocity onto the orbit; randomness tilts each particle's vortex axis deterministically from its seed.
• Drag, optionally multiplied by particle size and/or speed.

On the particle system, the External Forces module chooses which fields apply: Influence Filter selects by GameObject layer mask or an explicit field list, and Multiplier scales all field influence. Fields are gathered once per frame per system and every particle-field evaluation shows up in the profiling counters, so field-heavy scenes stay measurable. Vector-field textures are not offered yet; the runtime contract is ready for them once volume textures land.

Lights

Lights lets a fraction of particles contribute real point lights to the scene — fire embers that glow on nearby walls, magic sparks that light a 2D dungeon. Lights are transient: the renderer owns them for exactly one frame and no Light components are ever created in the scene.

• Light: a scene object whose Point Light (3D systems) or Point Light 2D (2D systems) component acts as the light template. Lenga references a scene object here rather than a prefab asset; disable the template object if you do not want the template light itself to render. With no reference the module falls back to a default white light (intensity 1, range 8).
• Ratio: the fraction of particles that carry a light, from 0 to 1.
• Random Distribution: on, each particle rolls against the ratio using a stable per-particle hash; off, lights follow a regular every-Nth-particle cadence that produces the exact fraction. Both modes are deterministic for a fixed seed.
• Use Particle Color multiplies the template color with the particle's current rendered color, so lights inherit Color over Lifetime and Color by Speed exactly as drawn.
• Size Affects Range multiplies the light range by the particle's largest rendered size axis; Alpha Affects Intensity scales intensity with the particle's current alpha — useful for lights that fade with the particle.
• Range Multiplier and Intensity Multiplier scale the template values.
• Max Lights: the per-system budget. Selection walks live particles in stable order, so which particles keep their lights never flickers between frames; lights beyond the budget are counted in the profiling stats as dropped.

Path-specific limits, stated honestly: the 3D lit shader exposes four point-light slots in total, and particle lights only fill slots that scene-authored Point Lights leave free — treat 3D particle lights as an accent, not a crowd. The 2D path accepts up to 64 transient lights per frame and particle lights never cast 2D shadows. The isolated particle preview panel does not run scene lighting; use the scene or game view to judge light behavior.

Performance and Determinism

Every hard limit is a documented constant, so effects fail predictably instead of growing unbounded: the particle pool is fixed at Max Particles; sub-emitter events cap at 256 per frame with 512 spawned particles per frame; contact events cap at 256 per frame; trails keep at most 64 points per particle; transient particle lights cap at 64 (2D) and the lit shader's four point-light slots (3D). When a budget saturates, the overflow is counted, not leaked — read the frame stats (aliveParticles, lastSimulationMilliseconds, lastRenderSubmissions, lastRenderBatchesEstimate, lastTransientLightSubmissions, dropped counters) to find which budget you are hitting.

Batching: submissions that share a texture merge into one GPU batch, so a 4,000-particle same-texture system is a handful of draw calls. Texture switches (sprite-mode sheets with many source textures) split batches; lastRenderBatchesEstimate near your particle count means state churn is defeating batching.

Determinism: with Auto Random Seed off, a fixed seed replays the exact same simulation across runs, restarts, and machines — selection of lit particles, trail carriers, and custom-data randomness all key off stable per-particle ids. Anything driven by variable frame time (camera-scale stretch, editor preview stepping) is reproducible under a fixed timestep.

Troubleshooting

• Nothing renders in the scene view: check the FX chip in the scene toolbar (it persists across sessions) and Show Only Selected in the preview panel. A disabled Renderer module draws nothing anywhere.
• Trails but no particles: Render Mode is None — intended for trails-only effects.
• Particles vanish early under heavy emission: the pool is recycling; raise Max Particles or use Ring Buffer Mode. poolExhaustedSpawns in the frame stats confirms it.
• Sub-emitters stop spawning in dense scenes: per-frame event and spawn budgets are saturating; check droppedSubEmitterEvents.
• 3D particle lights don't appear: the lit shader has four point-light slots total and scene lights fill them first.
• Custom-data shader has no effect: the material needs a shader asset; judge it in the scene or game view — the isolated preview panel does not apply materials.
• Effect looks different between editor preview and game: geometry is shared and cannot drift; shading differences (scene lighting, custom shaders, particle lights) are listed in the scene-view parity audit.

Custom Data

Custom Data hands authored per-particle values to custom particle materials, so advanced shaders (dissolves, distortion, per-particle variation) can consume data the simulation controls.

Two channels are available, Custom 1 and Custom 2. Each channel is either a Vector (up to four components, each a full scalar value — constant, random-between, or curves sampled over the particle lifetime) or a Color (constant, gradient, or random-between, packed as normalized rgba). Random modes are stable per particle, so replays are deterministic.

Shader authors: assign a material whose shader asset is a custom particle shader. Each particle's channels arrive as uniforms set before its draw:

uniform vec4 particleCustom1;
uniform vec4 particleCustom2;

// example: dissolve driven by custom1.x, tint by custom2.rgb
void main()
{
    vec4 base = texture(texture0, fragTexCoord) * fragColor;
    if (base.a < particleCustom1.x) discard;
    finalColor = vec4(base.rgb * particleCustom2.rgb, base.a);
}

The particle's resolved color still arrives through the standard vertex color. Notes, stated honestly: values are per-draw uniforms (not vertex streams), so extremely large systems pay one uniform update per particle; Lenga colors are 8-bit, so author HDR-style intensities through Vector mode; the isolated particle preview panel does not apply materials — judge custom shaders in the scene or game view.

Renderer

The Renderer module controls how particles draw.

Important fields:

• renderMode: Billboard, StretchedBillboard, HorizontalBillboard, VerticalBillboard, Mesh, or None (particles emit no geometry — useful for trails-only effects).
• renderAlignment (Billboard and Stretched Billboard): View faces the camera plane, World locks to world axes, Local follows the emitter's rotation, Facing points at the camera position, and Velocity orients each particle along its motion.
• allowRoll: off strips the particle's roll from camera-facing billboards; x/y tilt still applies.
• blendMode
• sortMode: None keeps spawn order; OldestInFront / YoungestInFront order by stable particle age; Distance draws far-to-near from the active 3D camera (2D keeps spawn order). All modes are deterministic — ties break on the particle id, so ordering never flickers.
• texturePath
• materialPath: the material's base color tints all particles and its base texture is used when no explicit texture is set. Lit/custom shader modes and trail materials are not yet applied to particles (planned with batching and ribbon trails).
• meshPath (Mesh mode): loads a model asset; a multi-mesh model distributes its meshes across particles deterministically. Without an asset, the selected primitive shape draws instead.
• receiveShadows: the system's world polygon receives baked 2D shadows like any other 2D renderer. Particles do not cast shadows.
• stretchLengthScale, stretchSpeedScale, and stretchCameraScale (camera movement adds streak length)
• freeformStretching: keeps stretched quads camera-facing by rotating toward the on-screen velocity, so streaks never collapse when moving toward the camera.
• minParticleSize / maxParticleSize: viewport-height fractions that clamp billboard sizes under a 3D camera (0 disables a clamp). 2D sizes are authored in pixels and are not clamped.
• sortingLayer
• orderInLayer
• lightingEnabled
• receiveShadows
• pivot
• flipX and flipY

For 2D, sorting layer and order are often the most important renderer values. For 3D, render mode, particle size, texture alpha, and camera distance usually matter most.

Use StretchedBillboard when particles should read as streaks, such as rain, sparks, debris trails, or speed lines. stretchLengthScale gives every particle a base streak length, while stretchSpeedScale adds more length from particle velocity.