Class VehicleExhaust

Exhaust smoke and steam for a Fleet: one shared GPU particle system (soft, lit, view-facing smoke puffs, depth-sorted) fed from every vehicle's vents each frame by exhaustSources. Its object is parented to the fleet's, so particles live in fleet space.

Example

const exhaust = new VehicleExhaust(fleet, { temperature: -4, humidity: 0.8 })
renderer.setAnimationLoop(() => {
  fleet.update(dt)
  exhaust.update(renderer, dt, camera)
  renderer.render(scene, camera)
})

Index

Constructors

constructor

new VehicleExhaust(fleet: Fleet, input?: ExhaustInput): VehicleExhaust
Parameters
- fleet: Fleet
- input: ExhaustInput = {}
Returns VehicleExhaust
- Defined in vehicles/src/exhaust.ts:263

Properties

particles

particles: ParticleSystem

The particle system (its object is a child of the fleet's).

settings

settings: ExhaustSettings

Resolved settings.

sourceCount

sourceCount: number = 0

Sources written last frame.

Methods

dispose

dispose(): void
Removes the particles and frees GPU resources.

Returns void
- Defined in vehicles/src/exhaust.ts:341

particleOptions

particleOptions(): {
    capacity?: number;
    curves?: { color?: string[]; opacity?: number[]; size?: number[] };
    emitter?: {
        position?: [number, number, number];
        shape?: EmitterShape;
        size?: [number, number, number];
        spread?: number;
        temperature?: [number, number];
        velocity?: [number, number, number];
    };
    forces?: {
        ambientTemperature?: number;
        buoyancy?: number;
        cooling?: number;
        drag?: number;
        gravity?: number;
        gridLift?: number;
        turbulence?: number;
        turbulenceScale?: number;
        turbulenceSpeed?: number;
        wind?: [number, number, number];
        windShear?: number;
    };
    life?: [number, number];
    maxPerFrame?: number;
    rate?: number;
    render?: {
        absorption?: number;
        albedo?: [string, string];
        anisotropy?: number;
        aspect?: number;
        blackbody?: boolean;
        blending?: "additive" | "alpha" | "premultiplied";
        capHeight?: number;
        detail?: number;
        detailDistance?: number;
        glow?: string;
        glowStrength?: number;
        intensity?: number;
        lightSteps?: number;
        opacity?: number;
        refraction?: number;
        shading?: ParticleShading;
        shadowSteps?: number;
        silverLining?: number;
        size?: number;
        sizeRandom?: [number, number];
        softness?: number;
        sort?: boolean;
        stretch?: number;
    };
    seed?: string
    | number;
}
The particle options for these settings.

Returns {
    capacity?: number;
    curves?: { color?: string[]; opacity?: number[]; size?: number[] };
    emitter?: {
        position?: [number, number, number];
        shape?: EmitterShape;
        size?: [number, number, number];
        spread?: number;
        temperature?: [number, number];
        velocity?: [number, number, number];
    };
    forces?: {
        ambientTemperature?: number;
        buoyancy?: number;
        cooling?: number;
        drag?: number;
        gravity?: number;
        gridLift?: number;
        turbulence?: number;
        turbulenceScale?: number;
        turbulenceSpeed?: number;
        wind?: [number, number, number];
        windShear?: number;
    };
    life?: [number, number];
    maxPerFrame?: number;
    rate?: number;
    render?: {
        absorption?: number;
        albedo?: [string, string];
        anisotropy?: number;
        aspect?: number;
        blackbody?: boolean;
        blending?: "additive" | "alpha" | "premultiplied";
        capHeight?: number;
        detail?: number;
        detailDistance?: number;
        glow?: string;
        glowStrength?: number;
        intensity?: number;
        lightSteps?: number;
        opacity?: number;
        refraction?: number;
        shading?: ParticleShading;
        shadowSteps?: number;
        silverLining?: number;
        size?: number;
        sizeRandom?: [number, number];
        softness?: number;
        sort?: boolean;
        stretch?: number;
    };
    seed?: string
    | number;
}
- Optionalcapacity?: number
  
  Pool size: the most particles alive at once. Changing it rebuilds the GPU buffers.
- Optionalcurves?: { color?: string[]; opacity?: number[]; size?: number[] }
  
  Shape over life (0 → 1), each an evenly spaced list of 1 to 8 keys.
  - Optionalcolor?: string[]
    
    Colour (#rrggbb); multiplied by the blackbody colour when render.blackbody.
  - Optionalopacity?: number[]
    
    Opacity multiplier.
  - Optionalsize?: number[]
    
    Size multiplier.
- Optionalemitter?: {
      position?: [number, number, number];
      shape?: EmitterShape;
      size?: [number, number, number];
      spread?: number;
      temperature?: [number, number];
      velocity?: [number, number, number];
  }
  
  Spawn shape and initial state.
  - Optionalposition?: [number, number, number]
    
    Centre, local space, metres.
  - Optionalshape?: EmitterShape
    
    point, box (half extents size), disc (radius size[0], on XZ), sphere (radius size[0]) or sources (see threejs-particles!ParticleSystem.setSources).
  - Optionalsize?: [number, number, number]
    
    Box half extents / disc and sphere radius in [0]; for sources, the jitter half extents around each source.
  - Optionalspread?: number
    
    Random extra speed in a random direction, m/s.
  - Optionaltemperature?: [number, number]
    
    Initial temperature range, kelvin (drives buoyancy, cooling and blackbody colour).
  - Optionalvelocity?: [number, number, number]
    
    Initial velocity, m/s.
- Optionalforces?: {
      ambientTemperature?: number;
      buoyancy?: number;
      cooling?: number;
      drag?: number;
      gravity?: number;
      gridLift?: number;
      turbulence?: number;
      turbulenceScale?: number;
      turbulenceSpeed?: number;
      wind?: [number, number, number];
      windShear?: number;
  }
  
  What moves particles.
  - OptionalambientTemperature?: number
    
    Ambient air temperature, kelvin.
  - Optionalbuoyancy?: number
    
    Buoyancy: up-acceleration = 9.81 × buoyancy × (T − ambient) / ambient (Boussinesq).
  - Optionalcooling?: number
    
    Exponential cooling towards ambient, 1/s.
  - Optionaldrag?: number
    
    Drag towards the air velocity, 1/s.
  - Optionalgravity?: number
    
    Gravity, m/s² (down).
  - OptionalgridLift?: number
    
    With a grid: up-acceleration from the grid's channel 0 (heat h), gridLift × h / (1 + h) m/s².
  - Optionalturbulence?: number
    
    Curl-noise turbulence, m/s².
  - OptionalturbulenceScale?: number
    
    Eddy size, metres.
  - OptionalturbulenceSpeed?: number
    
    How fast the eddies change, 1/s.
  - Optionalwind?: [number, number, number]
    
    Air velocity, m/s; drag pulls particles towards it.
  - OptionalwindShear?: number
    
    Wind grows by this share per 100 m above emitter.position.y (wind shear).
- Optionallife?: [number, number]
  
  Life range, seconds.
- OptionalmaxPerFrame?: number
  
  Most particles spawned in one update (caps catch-up after a long frame).
- Optionalrate?: number
  
  Particles per second. With emitter.shape: 'sources' this is per unit of source weight, so a bigger fire front spawns more. Throttled so the pool never runs out (capacity / mean life).
- Optionalrender?: {
      absorption?: number;
      albedo?: [string, string];
      anisotropy?: number;
      aspect?: number;
      blackbody?: boolean;
      blending?: "additive" | "alpha" | "premultiplied";
      capHeight?: number;
      detail?: number;
      detailDistance?: number;
      glow?: string;
      glowStrength?: number;
      intensity?: number;
      lightSteps?: number;
      opacity?: number;
      refraction?: number;
      shading?: ParticleShading;
      shadowSteps?: number;
      silverLining?: number;
      size?: number;
      sizeRandom?: [number, number];
      softness?: number;
      sort?: boolean;
      stretch?: number;
  }
  
  How particles are drawn.
  - Optionalabsorption?: number
    
    Smoke: light absorbed per unit of density.
  - Optionalalbedo?: [string, string]
    
    Smoke albedo for clean (white) smoke and dirty (dark) smoke; particles mix by their source tint.
  - Optionalanisotropy?: number
    
    Smoke: Henyey-Greenstein anisotropy (0 isotropic … 0.9 strongly forward).
  - Optionalaspect?: number
    
    Height / width of each quad.
  - Optionalblackbody?: boolean
    
    Colour from temperature (blackbody) instead of only the colour curve.
  - Optionalblending?: "additive" | "alpha" | "premultiplied"
    
    additive (sparks), alpha (smoke) or premultiplied (flames: emit light and partly hide what is behind).
  - OptionalcapHeight?: number
    
    Smoke: height above the emitter (metres) where the plume caps into bright, dense, sharply billowing pyrocumulus-like cloud. 0 = off.
  - Optionaldetail?: number
    
    Per-pixel noise detail 0…1 (0 = flat sprites, cheapest).
  - OptionaldetailDistance?: number
    
    Beyond this camera distance (metres) the per-pixel detail and self-shadow taps fade out.
  - Optionalglow?: string
    
    Smoke: warm light from below (#rrggbb), scaled by how hot the particle still is.
  - OptionalglowStrength?: number
    
    Smoke: glow strength.
  - Optionalintensity?: number
    
    Brightness multiplier (HDR; > 1 blooms).
  - OptionallightSteps?: number
    
    Smoke with a grid: per-particle density steps towards the sun through the grid (0…8). Rebuilds the compute pass.
  - Optionalopacity?: number
    
    Opacity multiplier.
  - Optionalrefraction?: number
    
    Haze: screen-space refraction strength (fraction of the screen).
  - Optionalshading?: ParticleShading
    
    Built-in shading: unlit sprites, noise-shaped flame tongues, lit volumetric smoke, thin spark streaks, refracting haze.
  - OptionalshadowSteps?: number
    
    Smoke: per-pixel density taps towards the sun (0…4). Rebuilds the material.
  - OptionalsilverLining?: number
    
    Smoke: extra forward-scattered light on thin edges when back-lit (silver lining).
  - Optionalsize?: number
    
    Base size (width), metres.
  - OptionalsizeRandom?: [number, number]
    
    Random size multiplier range.
  - Optionalsoftness?: number
    
    Soft depth fade against opaque geometry, metres (0 = hard).
  - Optionalsort?: boolean
    
    Back-to-front GPU sort (alpha blending).
  - Optionalstretch?: number
    
    Stretch along velocity: extra length = speed × stretch (seconds). 0 = camera-facing quads.
- Optionalseed?: string | number
  
  Seed for every per-particle random number (spawn position, velocity, size, life).
- Defined in vehicles/src/exhaust.ts:284

reset

reset(input?: ExhaustInput): this
Replaces the settings (anything not given goes back to DEFAULT_EXHAUST).
Parameters
- input: ExhaustInput = {}
Returns this
- Defined in vehicles/src/exhaust.ts:278

set

set(input: ExhaustInput): this
Merges input into the settings (capacity rebuilds the particle pool; the rest is live).
Parameters
- input: ExhaustInput
Returns this
- Defined in vehicles/src/exhaust.ts:272

update

update(renderer: Renderer, dt: number, camera: Camera): this
Advances the smoke by dt seconds: refreshes the sources from the fleet's vents (as seen from camera) and runs the particle passes. Call after fleet.update().
Parameters
- renderer: Renderer
- dt: number
- camera: Camera
Returns this
- Defined in vehicles/src/exhaust.ts:320

Class VehicleExhaust

Example

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns VehicleExhaust

Properties

particles

settings

sourceCount

Methods

dispose

Returns void

particleOptions

Optionalcapacity?: number

Optionalcurves?: { color?: string[]; opacity?: number[]; size?: number[] }

Optionalcolor?: string[]

Optionalopacity?: number[]

Optionalsize?: number[]

Optionalemitter?: { position?: [number, number, number]; shape?: EmitterShape; size?: [number, number, number]; spread?: number; temperature?: [number, number]; velocity?: [number, number, number];}

Optionalposition?: [number, number, number]

Optionalshape?: EmitterShape

Optionalsize?: [number, number, number]

Optionalspread?: number

Optionaltemperature?: [number, number]

Optionalvelocity?: [number, number, number]

Optionalforces?: { ambientTemperature?: number; buoyancy?: number; cooling?: number; drag?: number; gravity?: number; gridLift?: number; turbulence?: number; turbulenceScale?: number; turbulenceSpeed?: number; wind?: [number, number, number]; windShear?: number;}

OptionalambientTemperature?: number

Optionalbuoyancy?: number

Optionalcooling?: number

Optionaldrag?: number

Optionalgravity?: number

OptionalgridLift?: number

Optionalturbulence?: number

OptionalturbulenceScale?: number

OptionalturbulenceSpeed?: number

Optionalwind?: [number, number, number]

OptionalwindShear?: number

Optionallife?: [number, number]

OptionalmaxPerFrame?: number

Optionalrate?: number

Optionalabsorption?: number

Optionalalbedo?: [string, string]

Optionalanisotropy?: number

Optionalaspect?: number

Optionalblackbody?: boolean

Optionalblending?: "additive" | "alpha" | "premultiplied"

OptionalcapHeight?: number

Optionaldetail?: number

OptionaldetailDistance?: number

Optionalglow?: string

OptionalglowStrength?: number

Optionalintensity?: number

OptionallightSteps?: number

Optionalopacity?: number

Optionalrefraction?: number

Optionalshading?: ParticleShading

OptionalshadowSteps?: number

OptionalsilverLining?: number

Optionalsize?: number

OptionalsizeRandom?: [number, number]

Optionalsoftness?: number

Optionalsort?: boolean

Optionalstretch?: number

Optionalseed?: string | number

reset

Parameters

Returns this

set

Parameters

Returns this

update

Parameters

Returns this

Settings

On This Page

`Optional`capacity?: number

`Optional`curves?: { color?: string[]; opacity?: number[]; size?: number[] }

`Optional`color?: string[]

`Optional`opacity?: number[]

`Optional`size?: number[]

`Optional`emitter?: {
position?: [number, number, number];
shape?: EmitterShape;
size?: [number, number, number];
spread?: number;
temperature?: [number, number];
velocity?: [number, number, number];
}

`Optional`position?: [number, number, number]

`Optional`shape?: EmitterShape

`Optional`size?: [number, number, number]

`Optional`spread?: number

`Optional`temperature?: [number, number]

`Optional`velocity?: [number, number, number]

`Optional`forces?: {
ambientTemperature?: number;
buoyancy?: number;
cooling?: number;
drag?: number;
gravity?: number;
gridLift?: number;
turbulence?: number;
turbulenceScale?: number;
turbulenceSpeed?: number;
wind?: [number, number, number];
windShear?: number;
}

`Optional`ambientTemperature?: number

`Optional`buoyancy?: number

`Optional`cooling?: number

`Optional`drag?: number

`Optional`gravity?: number

`Optional`gridLift?: number

`Optional`turbulence?: number

`Optional`turbulenceScale?: number

`Optional`turbulenceSpeed?: number

`Optional`wind?: [number, number, number]

`Optional`windShear?: number

`Optional`life?: [number, number]

`Optional`maxPerFrame?: number

`Optional`rate?: number

`Optional`absorption?: number

`Optional`albedo?: [string, string]

`Optional`anisotropy?: number

`Optional`aspect?: number

`Optional`blackbody?: boolean

`Optional`blending?: "additive" | "alpha" | "premultiplied"

`Optional`capHeight?: number

`Optional`detail?: number

`Optional`detailDistance?: number

`Optional`glow?: string

`Optional`glowStrength?: number

`Optional`intensity?: number

`Optional`lightSteps?: number

`Optional`opacity?: number

`Optional`refraction?: number

`Optional`shading?: ParticleShading

`Optional`shadowSteps?: number

`Optional`silverLining?: number

`Optional`size?: number

`Optional`sizeRandom?: [number, number]

`Optional`softness?: number

`Optional`sort?: boolean

`Optional`stretch?: number

`Optional`seed?: string | number