Class ParticleGenerator

A lightweight, native particle generator designed for VFX.

ParticleGenerator manages:

An internal container on the chosen canvas layer (usually canvas.primary)
Particle pooling (reusing sprites instead of constantly allocating new ones)
Lifetime, fade-in/out, basic motion, and optional constraints
Two usage styles:
- ambient: keep a steady density in the visible area (viewport-driven budget)
- effect: spawn particles in a specific area (manual spawns or a fixed target count)

The API is intentionally compact:

Put most settings at the top level (textures, blend, alpha, scale, count, lifetime, etc.)
Use area to define where particles spawn
Use spawnParticle() or spawnParticles() to spawn particles (optionally overriding texture/area/position)
Use start({spawn: n}) when you want to immediately seed a certain number of particles on start
Use onSpawn to customize each particle after it has been positioned and configured
Use onDeath to react when particles are recycled (optional)

Core concepts

Mode

mode: "ambient" maintains a stable density in the visible region. count is scaled by the visible area ratio, and spawning uses the padded viewport (viewPadding).
mode: "effect" spawns in a defined area. count is treated as an absolute target. You can use manual: true and spawn at your own rate via spawnParticle() / spawnParticles().

Fade

fade.in / fade.out accept:

milliseconds when value >= 1
a fraction of the particle lifetime when 0 < value < 1

Velocity

velocity can be:

fixed: {x, y} or new PIXI.Point(x, y)
ranged: {x: [min, max], y: [min, max]}
polar: {speed: [min, max], angle: [min, max]} (angle in degrees)

Area

area supports:

Point: {x, y}
Rect: {x, y, width, height} or new PIXI.Rectangle(x, y, w, h)
Circle: {x, y, radius}
Ring: {x, y, innerRadius, outerRadius} or {x, y, radius: [inner, outer]}
Line: {from: {x, y}, to: {x, y}}

If you provide an anchor, object-based areas can be treated as offsets relative to that anchor. To force an absolute rectangle while anchored, pass a PIXI.Rectangle.

Performance tips

Preload textures before creating the generator.
Prefer calling spawnParticle() or spawnParticles() with no options when you can. It avoids per-spawn object allocations.
Keep positionTest cheap. It runs in a hot path.
Avoid blur unless you really need it (pre-blurred textures are better).

Practical limits

ParticleGenerator is meant for local, short-lived effects (bursts, embers, motes, small auras), not for filling the entire scene with massive particle counts. If you push it into many thousands of active particles, performance could degrade quickly. In practice, you’ll get better results by using moderate counts, short lifetimes, and small spawn areas, and by stopping the effect when it’s no longer needed.

Texture size also matters. Large particle textures (or heavy blur) increase pixel work, especially with additive/screen blends and overdraw, which can become fill-rate bound on some GPUs. Prefer small textures (and sprite sheets!), keep particle sizes reasonable on screen, and avoid expensive full-screen coverage when you only need a local effect.

Examples

Example

1) Ambient dust (steady density in view)

Use this for soft, always-on atmospheric particles.

const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "ambient",
  textures: [
    "worlds/shared_assets/particles/dust1.png",
    "worlds/shared_assets/particles/dust2.png"
  ],
  blend: PIXI.BLEND_MODES.NORMAL,
  count: 300,
  viewPadding: 0.25,
  lifetime: [1200, 2200],
  fade: {in: 0.15, out: 0.25},
  velocity: {x: [-5, 5], y: [-10, -30]},
  alpha: [0.08, 0.18],
  scale: [0.35, 0.85]
});
gen.start();

2) Ambient snow (padding + random age)

Great for snowfall that looks continuous when you pan the camera.

const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "ambient",
  textures: ["worlds/shared_assets/particles/snow.png"],
  count: 400,
  viewPadding: 0.3,
  randomizeAgeInPadding: true,
  lifetime: [2500, 4500],
  fade: {in: 0.2, out: 0.2},
  velocity: {x: [-8, 8], y: [-25, -55]},
  alpha: [0.12, 0.25],
  scale: [0.3, 0.9],
  blend: PIXI.BLEND_MODES.SCREEN
});
gen.start();

3) Manual burst at a point (effect mode)

Use this for clicks, impacts, or quick one-shot effects.

const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "effect",
  manual: true,
  textures: ["worlds/shared_assets/particles/dust1.png"],
  lifetime: [450, 900],
  fade: {in: 0.05, out: 0.4},
  velocity: {speed: [80, 200], angle: [0, 360]},
  alpha: [0.4, 0.8],
  scale: [0.3, 0.8]
});
gen.start();

// Spawn a burst at {x,y}
const p = {x: 1000, y: 800};
gen.spawnParticles(120, {position: p});

4) Manual spawn rate (embers around a token)

Use this to continuously spawn particles around something.

const token = canvas.tokens.controlled[0];
let acc = 0;
const area = {radius: 70}; // relative to anchor, no x/y needed

const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "effect",
  manual: true,
  anchor: token,
  anchorPoint: "center",
  area,
  elevation: token.document.elevation ?? 0,
  textures: [
    "worlds/shared_assets/particles/dust1.png",
    "worlds/shared_assets/particles/dust2.png",
    "worlds/shared_assets/particles/dust3.png",
    "worlds/shared_assets/particles/dust4.png"
  ],
  lifetime: [450, 900],
  fade: {in: 0.05, out: 0.4},
  velocity: {x: [-160, 160], y: [-160, 160]},
  rotationSpeed: 180,
  alpha: [0.5, 0.75],
  scale: [0.25, 0.75],
  blend: PIXI.BLEND_MODES.NORMAL,
  onTick: (dt, generator) => {
    const RATE = 90; // particles/sec
    acc += (dt * RATE) / 1000;
    const n = acc | 0;
    acc -= n;
    if ( n > 0 ) generator.spawnParticles(n, {area});
  }
});
gen.start();

5) Ring spawn + radial outward motion (use onSpawn)

Good for shockwaves, sparks, or “pushing out” energy.

const center = {x: 1200, y: 900};
const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "effect",
  manual: true,
  textures: ["worlds/shared_assets/particles/spark.png"],
  area: {x: center.x, y: center.y, radius: [80, 120]},
  lifetime: [500, 900],
  fade: {in: 0.1, out: 0.3},
  alpha: [0.4, 0.9],
  scale: [0.3, 0.7],
  onSpawn: (p) => {
    const cx = center.x - gen._bounds.x;
    const cy = center.y - gen._bounds.y;

    let dx = p.x - cx;
    let dy = p.y - cy;

    const d = Math.hypot(dx, dy) || 1;
    dx /= d;
    dy /= d;

    const speed = Math.mix(120, 240, Math.random());
    p.movementSpeed.x = dx * speed;
    p.movementSpeed.y = dy * speed;
  }
});
gen.start({spawn: 120});

6) Keep particles inside a rectangle (wrap)

Use this for localized ambient effects in a region.

const zone = new PIXI.Rectangle(900, 700, 600, 400);
const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "effect",
  manual: false,
  count: 250,
  area: zone,
  constraintMode: "wrap",
  constraintArea: zone,
  textures: ["worlds/shared_assets/particles/dust1.png"],
  lifetime: [1200, 2200],
  fade: {in: 0.2, out: 0.2},
  velocity: {x: [-20, 20], y: [-10, 10]},
  alpha: [0.1, 0.25],
  scale: [0.4, 0.9]
});
gen.start({spawn: 250});

7) Bounce inside bounds (arcade-style)

Great for “energy balls” in a box or magic motes in a bounded area.

const zone = new PIXI.Rectangle(900, 700, 600, 400);
const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "effect",
  manual: false,
  count: 80,
  area: zone,
  constraintMode: "bounce",
  constraintArea: zone,
  restitution: 0.9,
  textures: ["worlds/shared_assets/particles/mote.png"],
  lifetime: [2000, 4000],
  fade: {in: 0.15, out: 0.25},
  velocity: {x: [-120, 120], y: [-120, 120]},
  alpha: [0.25, 0.6],
  scale: [0.5, 1.0],
  blend: PIXI.BLEND_MODES.SCREEN
});
gen.start({spawn: 80});

8) Use a clip mask (hard visual boundary)

Use this when you need a strict rectangle cutout.

const clipRect = new PIXI.Rectangle(900, 700, 600, 400);
const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "effect",
  manual: false,
  count: 300,
  area: clipRect,
  clip: clipRect,
  textures: ["worlds/shared_assets/particles/fog.png"],
  lifetime: [2000, 4000],
  fade: {in: 0.2, out: 0.2},
  velocity: {x: [-10, 10], y: [-10, 10]},
  alpha: [0.08, 0.18],
  scale: [0.8, 1.6],
  blend: PIXI.BLEND_MODES.SCREEN
});
gen.start({spawn: 300});

9) Multiple textures + additive blend (magic motes)

Use this for “sparkly” looks with layered variation.

const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "effect",
  manual: false,
  count: 150,
  area: {x: 1200, y: 900, radius: 250},
  textures: ["mote1.png", "mote2.png", "mote3.png"],
  blend: PIXI.BLEND_MODES.SCREEN,
  lifetime: [1500, 2600],
  fade: {in: 0.2, out: 0.35},
  velocity: {speed: [5, 20], angle: [0, 360]},
  rotationSpeed: 45,
  alpha: [0.15, 0.45],
  scale: [0.3, 0.8]
});
gen.start({spawn: 150});

10) Force a specific texture per spawn

Useful when you want a rare “special” particle occasionally.

const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "effect",
  manual: true,
  textures: ["a.png", "b.png"]
});
gen.start();
gen.spawnParticle({texture: "special.png", position: {x: 1200, y: 900}});

11) Spawn into a temporary override area

Use this to reuse one generator for multiple nearby spawns without rebuilding it.

const gen = new foundry.canvas.animation.ParticleGenerator({
  mode: "effect",
  manual: true,
  textures: ["dust1.png"],
  lifetime: [500, 900]
});

// Start the generator
gen.start();

const r1 = new PIXI.Rectangle(900, 700, 200, 200);
const r2 = new PIXI.Rectangle(1200, 700, 200, 200);
gen.spawnParticles(50, {area: r1});
gen.spawnParticles(50, {area: r2});

// Stop the generator (soft stop by default)
gen.stop()

Index

Constructors

constructor

Accessors

budgetRectLocal debugStats viewRectLocal

Constructors

constructor

new ParticleGenerator(
config?: ParticleGeneratorConfiguration,
): ParticleGenerator
Parameters
- Optionalconfig: ParticleGeneratorConfiguration = {}
Returns ParticleGenerator

Properties

adjustedMaxParticles

adjustedMaxParticles: number = 0

The computed target particle count based on visible area (ambient mode) or the configured budget (effect mode).

alphaRange

alphaRange: { max: number; min: number }

The maximum alpha range for particles.

anchor

anchor: ParticleGeneratorAnchor

An optional anchor used to attach areas and behaviors.

anchorOffset

anchorOffset: { x: number; y: number } | null

A fixed offset (scene pixels) applied to the anchor.

anchorPoint

anchorPoint: ParticleGeneratorAnchorPoint

Which point to use when anchoring.

blendMode

blendMode: BLEND_MODES

The blend mode used to render particles.

blurOptions

blurOptions:
    | { enabled: boolean; intensity: number; quality: number
    | undefined }
    | null

Optional blur filter options applied to the internal container.

clip

clip: { enabled: boolean | null; rect: Rectangle | null }

Clip (mask) options.

constraints

constraints: {
    area: Rectangle | "world" | "view" | "budget" | null;
    mode: ParticleGeneratorConstraintMode;
    restitution: number;
}

Out-of-bounds constraint configuration.

container

container: Container<DisplayObject>

The parent container which receives the internal particle container.

drift

drift: { enabled: boolean; intensity: number }

Optional random drift configuration.

elevation

elevation: number

The elevation for the particle container.

fadeInDuration

fadeInDuration: number

The fade-in duration in milliseconds, or a fraction of lifetime if 0 < value < 1.

fadeOutDuration

fadeOutDuration: number

The fade-out duration in milliseconds, or a fraction of lifetime if 0 < value < 1.

follow

follow: ParticleGeneratorFollowOptions

Follow behavior options.

initialBatch

initialBatch: number

The initial proportion (0..1) of the computed target particle count to spawn on start.

manualSpawning

manualSpawning: boolean

If true, particles are never spawned automatically.

maxParticles

maxParticles: number

The target particle count.

maxParticlesPerFrame

maxParticlesPerFrame: number

The maximum number of particles that may be spawned per frame (auto-spawn mode).

mode

mode: ParticleGeneratorMode

The runtime mode.

onDeath

onDeath: Function | null

An optional callback called when a particle is recycled.

onSpawn

onSpawn: Function | null

An optional callback called after the particle has been placed and configured.

onTick

onTick: Function | null

An optional callback called one time per frame (not per particle!).

orbit

orbit: ParticleGeneratorOrbitOptions

Orbit behavior options.

particleLifetime

particleLifetime: number | number[] | { max: number; min: number }

The particle lifetime configuration in milliseconds.

particlePool

particlePool: ParticleMesh[] = []

A pool of recycled particles ready to be reused.

particles

particles: ParticleMesh[] = []

The currently active particle instances.

positionTest

positionTest: Function | null

An optional spawn validator.

rotationSpeed

rotationSpeed: number

The rotation speed of particles in radians per second.

scaleRange

scaleRange: { max: number; min: number }

The scale range for particles.

sort

sort: number

The sorting key for the particle container.

spawnProbability

spawnProbability: number

The chance (0..1) that a spawn attempt actually creates a particle.

textures

textures: Texture<Resource>[]

The configured particle textures.

velocity

velocity: ParticleGeneratorVelocityOptions | null

The velocity configuration used to generate per-particle movement.

viewport

viewport: {
    newlyVisible: boolean;
    padding: number;
    randomizeAgeInPadding: boolean;
}

Viewport-related behavior (used primarily in ambient mode).

`Protected`_anchorLocal

_anchorLocal: Point = ...

The current anchor position in local coordinates.

`Protected`_anchorScene

_anchorScene: Point = ...

The current anchor position in scene coordinates.

`Protected`_behavior

_behavior: ParticleGeneratorBehavior | null = null

The active behavior implementation.

`Protected`_behaviorContext

_behaviorContext: object

A cached context object passed to behavior hooks.

`Protected`_blurFilter

_blurFilter: Filter | null = null

The blur filter applied to the internal container, if any.

`Protected`_bounds

_bounds: Rectangle

Generator bounds in scene coordinates.

`Protected`_brLocal

_brLocal: Point = ...

Temp point used to avoid per-frame allocations.

`Protected`_brScreen

_brScreen: Point = ...

Temp point used to avoid per-frame allocations.

`Protected`_budgetRectLocal

_budgetRectLocal: Rectangle = ...

The local-space viewport rectangle with padding.

`Protected`_constraintRect

_constraintRect: Rectangle | null = null

Optional custom constraint rectangle in local coordinates.

`Protected`_debug

_debug: ParticleGeneratorDebugOptions | null = null

Normalized debug options.

`Protected`_debugProfile

_debugProfile: boolean = false

Whether profiling is enabled.

`Protected`_debugStats

_debugStats: ParticleGeneratorDebugStats | null = null

Debug statistics and profiling output. Null when debug stats are disabled.

`Protected`_debugTint

_debugTint: { mode: ParticleGeneratorDebugTintMode; palette: number[] } | null = null

Cached debug tint options.

`Protected`_debugTintByTexture

_debugTintByTexture: WeakMap<Texture<Resource>, number> | null = null

A mapping from textures to deterministic tint values.

`Protected`_generateMovementSpeed

_generateMovementSpeed: Function

A function which generates per-particle movement speed vectors.

`Protected`_hasOldBudgetRectLocal

_hasOldBudgetRectLocal: boolean = false

Whether the previous-frame budget rectangle is initialized.

`Protected`_initialized

_initialized: boolean = false

Whether the generator has spawned its initial batch.

`Protected`_mask

_mask: Graphics | null = null

The mask graphics used to clip rendering.

`Protected`_newlyVisibleAreaPool

_newlyVisibleAreaPool: Rectangle[] = ...

A fixed pool of rectangles used to describe newly visible areas.

`Protected`_newlyVisibleAreas

_newlyVisibleAreas: Rectangle[] = []

The list of newly visible areas for the current frame in local coordinates.

`Protected`_oldBudgetRectLocal

_oldBudgetRectLocal: Rectangle = ...

The previous-frame budget rectangle.

`Protected`_particlesContainer

_particlesContainer: PrimaryCanvasParticleContainer | null = null

The internal container which holds all particles.

`Protected`_spawnArea

_spawnArea: ParticleGeneratorArea | null = null

The configured default spawn area (effect mode). This area is defined in scene coordinates and may be interpreted relative to an anchor.

`Protected`_stopped

_stopped: boolean = true

Whether the generator is soft-stopped.

`Protected`_tickerAttached

_tickerAttached: boolean = false

Whether the update callback is attached to the ticker.

`Protected`_tlLocal

_tlLocal: Point = ...

Temp point used to avoid per-frame allocations.

`Protected`_tlScreen

_tlScreen: Point = ...

Temp point used to avoid per-frame allocations.

`Protected`_viewRectLocal

_viewRectLocal: Rectangle = ...

The local-space viewport rectangle without padding.

`Protected`_worldRectLocal

_worldRectLocal: Rectangle = ...

The local-space generator bounds.

`Static`DEFAULT_OPTIONS

DEFAULT_OPTIONS: ParticleGeneratorConfiguration = ...

Default generator config.

Accessors

budgetRectLocal

get budgetRectLocal(): Rectangle
The current padded viewport rectangle used for budget/spawning in ambient mode.

Returns Rectangle

debugStats

get debugStats(): ParticleGeneratorDebugStats | null
Debug statistics and profiling output. Returns null if ParticleGeneratorDebugOptions#stats is not enabled.

Note: This getter returns a stable object reference and updates the live values (active/pool/target) on access.

Returns ParticleGeneratorDebugStats | null

viewRectLocal

get viewRectLocal(): Rectangle
The current unpadded viewport rectangle in the generator's local space.

Returns Rectangle

Methods

_initializeParticles

_initializeParticles(): void
Spawn the initial batch.

Returns void

_setupParticleBase

_setupParticleBase(particle: ParticleMesh): void
Initialize/refresh base particle properties.
Parameters
- particle: ParticleMesh
Returns void

spawnParticle

spawnParticle(
    options?: {
        area?: ParticleGeneratorArea | null;
        position?: Point | { x: number; y: number } | null;
        texture?: string | Texture<Resource>;
    },
): ParticleMesh
| null
Spawn a single particle. In "ambient" mode, the default spawn area is the current padded viewport rectangle. In "effect" mode, the default spawn area is the configured ParticleGeneratorArea.
Parameters
- Optionaloptions: {
      area?: ParticleGeneratorArea | null;
      position?: Point | { x: number; y: number } | null;
      texture?: string | Texture<Resource>;
  } = {}
  - Optionalarea?: ParticleGeneratorArea | null
    An optional spawn area override. Interpreted the same as the configured area (scene coordinates, or relative-to-anchor when anchored).
  - Optionalposition?: Point | { x: number; y: number } | null
    An optional explicit spawn position (scene coordinates).
  - Optionaltexture?: string | Texture<Resource>
    A texture (or texture source string) to force for this particle.
Returns ParticleMesh | null

spawnParticles

spawnParticles(
    count: number,
    options?: {
        area?: ParticleGeneratorArea | null;
        position?: IPointData | null;
        texture?: string | Texture<Resource>;
    },
): number
Spawn multiple particles.
Parameters
- count: number
  The number of particles to spawn.
- Optionaloptions: {
      area?: ParticleGeneratorArea | null;
      position?: IPointData | null;
      texture?: string | Texture<Resource>;
  } = {}
  - Optionalarea?: ParticleGeneratorArea | null
    An optional spawn area override. Interpreted the same as the configured area (scene coordinates, or relative-to-anchor when anchored).
  - Optionalposition?: IPointData | null
    An optional explicit spawn position (scene coordinates).
  - Optionaltexture?: string | Texture<Resource>
    A texture (or texture source string) to force for this burst.
Returns number
The number of successfully spawned particles.

start

start(options?: { spawn?: number }): void
Start the generator, create the update loop and optionally spawn an initial batch.
Parameters
- Optionaloptions: { spawn?: number }
  - Optionalspawn?: number
    Spawn this many particles immediately after starting. If ParticleGenerator#manualSpawning is false, this is capped to the remaining budget (target - active).
Returns void

stop

stop(options?: { hard?: boolean }): void
Stop the generator.
Parameters
- Optionaloptions: { hard?: boolean } = {}
  - Optionalhard?: boolean
    If true, detach the update loop and destroy internal resources. If false, stop spawning and let existing particles expire naturally.
Returns void

`Protected`_applyRandomDrift

_applyRandomDrift(particle: ParticleMesh): void
Protected
Apply a random drift vector to a particle.
Parameters
- particle: ParticleMesh
Returns void

`Protected`_autoSpawnParticles

_autoSpawnParticles(): void
Protected
Spawn particles to move toward the current target count.

Returns void

`Protected`_calculateGeneratorProperties

_calculateGeneratorProperties(): void
Protected
Compute the current viewport rectangles and target particle count. All rectangles are in the local coordinate space of the internal container.

Returns void

`Protected`_computeNewlyVisibleAreas

_computeNewlyVisibleAreas(oldRect: Rectangle, newRect: Rectangle): void
Protected
Compute the portions of newRect that were not visible in oldRect. This method reuses a fixed pool of rectangles to avoid per-frame allocations.
Parameters
- oldRect: Rectangle
- newRect: Rectangle
Returns void

`Protected`_configureDebug

_configureDebug(
debug: boolean | ParticleGeneratorDebugOptions | null | undefined,
): void
Protected
Configure optional debug helpers. This feature set is fully opt-in and is designed to have near-zero overhead when disabled.
Parameters
- debug: boolean | ParticleGeneratorDebugOptions | null | undefined
Returns void

`Protected`_configureOptions

_configureOptions(cfg: ParticleGeneratorConfiguration): void
Protected
Apply the configuration to the ParticleGenerator instance.
Parameters
- cfg: ParticleGeneratorConfiguration
  The configuration object.
Returns void

`Protected`_createNewParticle

_createNewParticle(texture: Texture<Resource>): ParticleMesh
Protected
Create a new particle instance.
Parameters
- texture: Texture<Resource>
Returns ParticleMesh

`Protected`_getDefaultBounds

_getDefaultBounds(): Rectangle
Protected
Get default bounds from the current scene dimensions.

Returns Rectangle

`Protected`_getRandomTexture

_getRandomTexture(): Texture<Resource> | null
Protected
Get a random texture from the configured set.

Returns Texture<Resource> | null

`Protected`_initializeBehaviors

_initializeBehaviors(cfg: ParticleGeneratorConfiguration): void
Protected
Initialize behaviors from the configuration object.
Parameters
- cfg: ParticleGeneratorConfiguration
Returns void

`Protected`_initializeCachedGenerators

_initializeCachedGenerators(_cfg: ParticleGeneratorConfiguration): void
Protected
Initialize cached generators from the configuration object.
Parameters
- _cfg: ParticleGeneratorConfiguration
Returns void

`Protected`_onTick

_onTick(): void
Protected
Ticker callback.

Returns void

`Protected`_recycleParticle

_recycleParticle(particle: ParticleMesh, reason: string): void
Protected
Recycle a particle to the pool.
Parameters
- particle: ParticleMesh
- reason: string
Returns void

`Protected`_updateExistingParticles

_updateExistingParticles(dt: number): void
Protected
Update all active particles.
Parameters
- dt: number
  Delta time in milliseconds.
Returns void

`Protected`_updateParticlesConstrained

_updateParticlesConstrained(
    dt: number,
    ds: number,
    bounds: Rectangle,
    particles: ParticleMesh[],
    behavior: ParticleGeneratorBehavior | null,
    bctx: object | null,
    mode: ParticleGeneratorConstraintMode,
): void
Protected
Update particles with constraints applied.
Parameters
- dt: number
- ds: number
- bounds: Rectangle
- particles: ParticleMesh[]
- behavior: ParticleGeneratorBehavior | null
- bctx: object | null
- mode: ParticleGeneratorConstraintMode
Returns void

`Protected`_updateParticlesUnconstrained

_updateParticlesUnconstrained(
    dt: number,
    ds: number,
    particles: object[],
    behavior: ParticleGeneratorBehavior | null,
    bctx: object | null,
): void
Protected
Update particles without constraints.
Parameters
- dt: number
  Delta time in milliseconds.
- ds: number
  Delta time in seconds.
- particles: object[]
- behavior: ParticleGeneratorBehavior | null
- bctx: object | null
Returns void

Class ParticleGenerator

Core concepts

Mode

Fade

Velocity

Area

Performance tips

Practical limits

Examples

Example

1) Ambient dust (steady density in view)

2) Ambient snow (padding + random age)

3) Manual burst at a point (effect mode)

4) Manual spawn rate (embers around a token)

5) Ring spawn + radial outward motion (use onSpawn)

6) Keep particles inside a rectangle (wrap)

7) Bounce inside bounds (arcade-style)

8) Use a clip mask (hard visual boundary)

9) Multiple textures + additive blend (magic motes)

10) Force a specific texture per spawn

11) Spawn into a temporary override area

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Returns ParticleGenerator

Properties

adjustedMaxParticles

alphaRange

anchor

anchorOffset

anchorPoint

blendMode

blurOptions

clip

constraints

container

drift

elevation

fadeInDuration

fadeOutDuration

follow

initialBatch

manualSpawning

maxParticles

maxParticlesPerFrame

mode

onDeath

onSpawn

onTick

orbit

particleLifetime

particlePool

particles

positionTest

rotationSpeed

scaleRange

sort

spawnProbability

textures

velocity

viewport

Protected_anchorLocal

Protected_anchorScene

Protected_behavior

Protected_behaviorContext

Protected_blurFilter

Protected_bounds

Protected_brLocal

Protected_brScreen

Protected_budgetRectLocal

Protected_constraintRect

Protected_debug

Protected_debugProfile

Protected_debugStats

Protected_debugTint

`Protected`_anchorLocal

`Protected`_anchorScene

`Protected`_behavior

`Protected`_behaviorContext

`Protected`_blurFilter

`Protected`_bounds

`Protected`_brLocal

`Protected`_brScreen

`Protected`_budgetRectLocal

`Protected`_constraintRect

`Protected`_debug

`Protected`_debugProfile

`Protected`_debugStats

`Protected`_debugTint

`Protected`_debugTintByTexture

`Protected`_generateMovementSpeed

`Protected`_hasOldBudgetRectLocal

`Protected`_initialized

`Protected`_mask

`Protected`_newlyVisibleAreaPool

`Protected`_newlyVisibleAreas

`Protected`_oldBudgetRectLocal

`Protected`_particlesContainer

`Protected`_spawnArea

`Protected`_stopped

`Protected`_tickerAttached

`Protected`_tlLocal

`Protected`_tlScreen

`Protected`_viewRectLocal

`Protected`_worldRectLocal

`Static`DEFAULT_OPTIONS

`Optional`area?: ParticleGeneratorArea | null

`Optional`position?: Point | { x: number; y: number } | null

`Optional`texture?: string | Texture<Resource>

`Optional`area?: ParticleGeneratorArea | null

`Optional`position?: IPointData | null

`Optional`texture?: string | Texture<Resource>

`Optional`spawn?: number

`Optional`hard?: boolean

`Protected`_applyRandomDrift

`Protected`_autoSpawnParticles

`Protected`_calculateGeneratorProperties

`Protected`_computeNewlyVisibleAreas

`Protected`_configureDebug

`Protected`_configureOptions

`Protected`_createNewParticle

`Protected`_getDefaultBounds