Particle System

The Gorilla3D Particle System provides powerful tools for creating stunning visual effects like fire, smoke, rain, explosions, and more. This guide covers everything you need to know about creating, customizing, and optimizing particle effects in your games and applications.

Table of Contents

Overview

The particle system supports:

  • Randomizable Particle Properties - Position, velocity, size, angle, weight, growth, and lifetime
  • Particle Caching - Reuse particles for better performance
  • Count Limitation - Control maximum particle count
  • Auto/Manual Emittance - Automatic or interactive particle generation
  • Endless/Limited Duration - Configure emission time
  • Physics-Based Collision - Optional collision detection with scene objects
  • Camera-Based Sorting - Automatic depth sorting for transparency
  • Extensive Influencers - Linear, spiral, gravity, wind, color, path-following, physics, and more
  • Sprite Sheet Support - Animated particles with texture atlases

Getting Started

Creating a Basic Emitter

The simplest way to create particles is to drop a TGorillaParticleEmitter component onto your viewport:

var
  LEmitter: TGorillaParticleEmitter;
begin
  LEmitter := TGorillaParticleEmitter.Create(Self);
  LEmitter.Parent := GorillaViewport1;
  LEmitter.Camera := Camera1;
  LEmitter.EmitParticles := 10;
  LEmitter.MaxParticles := 1000;
  LEmitter.Start();
end;

Pre-built Emitters

Gorilla3D includes pre-configured emitters for common effects:

Emitter Description
TGorillaFireParticleEmitter Realistic fire effects with flames and optional smoke
TGorillaSmokeParticleEmitter Various smoke styles (4 different textures)
TGorillaRainParticleEmitter Rain with droplets and splash effects
TGorillaSnowParticleEmitter Falling snow with spiral movement
TGorillaEruptionParticleEmitter Volcanic eruption with lava particles
TGorillaExplosionParticleEmitter Explosion with expanding particles
TGorillaSpotParticleEmitter Spot/splash effects
TGorillaWaterfallParticleEmitter Cascading water effect

particles2

Fire Effect Example:

var
  LFire: TGorillaFireParticleEmitter;
begin
  LFire := TGorillaFireParticleEmitter.Create(Self);
  LFire.Parent := GorillaViewport1;
  LFire.Camera := Camera1;
  LFire.Kind := TGorillaFireParticleKind.Torch;
  LFire.Start();
end;

Core Concepts

Particles

Each particle is a lightweight record containing:

TGorillaParticle = record
  Position : TPoint3D;    // Current 3D position
  Velocity : TPoint3D;    // Movement vector
  Color    : TAlphaColorF;// RGBA color
  Size     : Single;      // Current size
  Angle    : Single;      // Rotation angle
  Weight   : Single;      // Particle weight (affects gravity)
  Age      : Single;      // Current age (seconds)
  Life     : Single;      // Lifetime (seconds)
  Growth   : Single;      // Size change per frame
end;

Emitters

Emitters create and manage particles. The base class TGorillaParticleEmitter provides:

  • Particle Creation - Emit particles automatically or manually
  • Update Loop - Process particle aging and influencer effects
  • Rendering - Draw particles as point sprites
  • Sorting - Depth sort particles for correct transparency
  • Caching - Reuse expired particles

Influencers

Influencers manipulate particle behavior at runtime:

  • Movement - Linear, spiral, gravity, wind
  • Visual - Color transitions, fading
  • Advanced - Path following, attractors, obstacles, physics

Presets

Presets define randomization ranges for particle properties:

// TParticlePreset: Single value randomization
property ParticleSize: TParticlePreset;

// TParticleVectorPreset: 3D vector randomization
property ParticlePosition: TParticleVectorPreset;
property ParticleVelocity: TParticleVectorPreset;

Example:

// Size between 16-32 pixels
LEmitter.ParticleSize.Preset(16, 32, 1, false);

// Velocity: up with some horizontal spread
LEmitter.ParticleVelocity.Preset(0, 50, 1000, Point3D(1, -10, 1), [axX, axY, axZ]);

Configuration

Particle Properties

Position Preset:

// Random spawn area
LEmitter.ParticlePosition.RangeX.Preset(-100, 100, 100, true);
LEmitter.ParticlePosition.RangeY.Preset(0, 0, 100, false);
LEmitter.ParticlePosition.RangeZ.Preset(-100, 100, 100, true);
LEmitter.ParticlePosition.Direction.Point := Point3D(1, 1, 1);

Velocity Preset:

// Upward movement
LEmitter.ParticleVelocity.Direction.Point := Point3D(0, -1, 0);
LEmitter.ParticleVelocity.RangeY.Preset(100, 200, 1000, false);

Size & Growth:

// Start size
LEmitter.ParticleSize.Preset(32, 64, 1, false);

// Growth (shrinking particles)
LEmitter.ParticleGrowth.Preset(-10, -5, 1000, false);

Angle & Rotation:

// Random initial angle
LEmitter.ParticleAngle.Preset(0, 360, 1, false);

// Auto-rotation in shader
LEmitter.AutoRotation := 0.5;

Lifetime:

// 2-5 seconds lifetime
LEmitter.ParticleLifeTime.Preset(2000, 5000, 1000, false);

Weight:

// Affects gravity influence
LEmitter.ParticleWeight.Preset(1, 10, 10, false);

Emission Settings

Basic Emission:

LEmitter.EmitParticles := 10;      // Emit 10 particles per interval
LEmitter.MaxParticles := 1000;     // Maximum 1000 active particles
LEmitter.EmitTime := 16;           // Update every 16ms (~60 FPS)
LEmitter.AutoEmit := True;         // Emit automatically

Limited Duration:

// Emit for 5 seconds then stop
LEmitter.MaxAutoEmitTime := 5000;
LEmitter.AutoEmit := True;
LEmitter.Start();

Manual Emission:

// Disable auto-emit
LEmitter.AutoEmit := False;
LEmitter.Start();

// Emit manually (e.g., on mouse click)
procedure TForm1.ViewportClick(Sender: TObject);
var
  LPos: TPoint3D;
begin
  LPos := Get3DPosition(Mouse.X, Mouse.Y);
  LEmitter.EmitParticle(LPos);
end;

Rendering Options

Blending:

// Additive blending (bright fire/explosions)
LEmitter.BlendFunc := TBlendEquationFunc.befAdd;
LEmitter.BlendSource := TBlendFactor.bfOne;
LEmitter.BlendDest := TBlendFactor.bfOne;

// Alpha blending (smoke/fog)
LEmitter.BlendFunc := TBlendEquationFunc.befAdd;
LEmitter.BlendSource := TBlendFactor.bfSrcAlpha;
LEmitter.BlendDest := TBlendFactor.bfOneMinusSrcAlpha;

Particle Fading:

// Fade particle edges to prevent clipping artifacts
LEmitter.ParticleFade := 2.5;

Debug Visualization:

LEmitter.ShowBounds := True;  // Show bounding box

Influencers

Movement Influencers

Linear Movement

The default influencer that applies velocity to position:

// Automatically created with every emitter
// Applies: Position += Velocity * DeltaTime

Spiral Movement

Creates spiral/helical motion (great for snowflakes):

var
  LSpiral: TGorillaSpiralParticleInfluencer;
begin
  LSpiral := TGorillaSpiralParticleInfluencer.Create(LEmitter);
  LSpiral.Emitter := LEmitter;
  LSpiral.Spirals := 10;  // Number of spirals in lifetime
  LSpiral.Enabled := True;
end;

Gravity

Simulates falling particles:

var
  LGravity: TGorillaGravityParticleInfluencer;
begin
  LGravity := TGorillaGravityParticleInfluencer.Create(LEmitter);
  LGravity.Emitter := LEmitter;
  LGravity.Force.Point := Point3D(0, 9.81, 0);  // Earth gravity (m/s²)
  LGravity.Ratio := 0.01;  // Power multiplier
  LGravity.Enabled := True;
end;

Wind

Creates wind zones affecting particles:

var
  LWind: TGorillaWindParticleInfluencer;
begin
  LWind := TGorillaWindParticleInfluencer.Create(LEmitter);
  LWind.Emitter := LEmitter;
  LWind.Origin.Point := Point3D(0, 0, 0);
  LWind.Size.Point := Point3D(50, 20, 20);
  LWind.Force.Point := Point3D(-8.0, 0, 0);  // Beaufort scale (m/s)
  LWind.Enabled := True;
end;

Beaufort Wind Scale:

Speed (m/s) Description
0.0 - 0.2 Calm
0.3 - 1.6 Light air
1.6 - 3.4 Light breeze
5.5 - 8.0 Moderate breeze
13.9 - 17.2 Strong breeze
32.7+ Hurricane

Tractor (Attractor)

Creates gravitational attraction to a point:

var
  LTractor: TGorillaTraktorInfluencer;
begin
  LTractor := TGorillaTraktorInfluencer.Create(LEmitter);
  LTractor.Emitter := LEmitter;
  LTractor.Center := Point3D(0, 0, 0);
  LTractor.Radius := 50;
  LTractor.Acceleration := 0.25;
  LTractor.Enabled := True;
end;

Trailed (Path Following)

Particles follow a predefined 3D path:

var
  LTrail: TGorillaTrailedParticleInfluencer;
begin
  LTrail := TGorillaTrailedParticleInfluencer.Create(LEmitter);
  LTrail.Emitter := LEmitter;

  // Define path points
  LTrail.Path.MoveTo3D(Point3D(0, 0, 0));
  LTrail.Path.LineTo3D(Point3D(10, 5, 0));
  LTrail.Path.CurveTo3D(Point3D(20, 10, 5), Point3D(15, 7, 2));

  LTrail.Enabled := True;
end;

Visual Influencers

Colored Particles

Interpolate between start and end colors:

var
  LColor: TGorillaColoredParticleInfluencer;
begin
  LColor := TGorillaColoredParticleInfluencer.Create(LEmitter);
  LColor.Emitter := LEmitter;
  LColor.StartColor := TAlphaColorRec.Blue;
  LColor.EndColor := TAlphaColorRec.Red;
  LColor.Enabled := True;
end;

Random Color

Apply random colors to particles:

var
  LRandColor: TGorillaRandomColorParticleInfluencer;
begin
  LRandColor := TGorillaRandomColorParticleInfluencer.Create(LEmitter);
  LRandColor.Emitter := LEmitter;
  LRandColor.Enabled := True;
end;

Physics Influencers

Obstacle

Simple collision with spheres, cubes, or meshes:

var
  LObstacle: TGorillaObstacleInfluencer;
begin
  LObstacle := TGorillaObstacleInfluencer.Create(LEmitter);
  LObstacle.Emitter := LEmitter;
  LObstacle.Kind := TParticleObstacleKind.Sphere;
  LObstacle.Center := Point3D(0, 0, 0);
  LObstacle.Radius := 5;
  LObstacle.Surface := TParticleObstacleSurface.Reflect;
  LObstacle.Acceleration := 9.81;
  LObstacle.Elasticity := 0.1;
  LObstacle.Enabled := True;
end;

Obstacle Types:

  • Sphere - Spherical collision volume
  • Cube - Box collision volume
  • Mesh - Custom mesh collision (experimental)

Surface Modes:

  • Flow - Particles flow around obstacle
  • Reflect - Particles bounce off surface

Physics Integration

Full physics engine integration (requires Q3 / JOLT Physics package):

var
  LPhysics: TGorillaPhysicsInfluencer;
begin
  LPhysics := TGorillaPhysicsInfluencer.Create(LEmitter);
  LPhysics.Emitter := LEmitter;
  LPhysics.Physics := GorillaPhysicsSystem1;
  LPhysics.Restitution := 0.1;  // Bounciness
  LPhysics.Density := 0.00001;
  LPhysics.Enabled := True;
end;

particles3

The following example shows how to interact on particle collision. This examples has a rain emitter and when the particles collide with anything else than another particle, a splashing effect should happen. The splashing is solved again by a particle emitter component. This example uses the Q3 Physics engine.

uses
  [...]
  Gorilla.Material.Particle,
  Gorilla.Particle.Emitter,
  Gorilla.Particle.Influencer,
  Gorilla.Particle.Rain,
  Gorilla.Particle.Spot,
  Gorilla.Physics,
  Gorilla.Physics.Q3.Body;

TForm1 = class(TForm)
  procedure FormCreate(Sender: TObject);
  protected
    FViewport : TGorillaViewport;
    FCamera : TGorillaCamera;
    FPhysics : TGorillaPhysicsSystem;
    FParticles : TGorillaRainParticleEmitter;
    FInfluencer : TGorillaPhysicsInfluencer;
    FSplashes : TGorillaSpotParticleEmitter;

    procedure DoOnGorillaPhysicsNotifyContact(const AContact : Pointer {PQ3ContactConstraint};
        const AOffset, ANormal : TPoint3D; const ABodyA, ABodyB : TGorillaPhysicsBody);
  [...]
end;

[...]

procedure TForm1.DoOnGorillaPhysicsNotifyContact(const AContact : Pointer {PQ3ContactConstraint};
    const AOffset, ANormal : TPoint3D; const ABodyA, ABodyB : TGorillaPhysicsBody);
begin
  // collision detected - create splashes on particle-sphere/box/terrain/mesh collision
  // not on particle-particle collision (too much)
  if (PTypeInfo(TQ3Body(ABodyA).UserDataType) = TypeInfo(PGorillaParticle))
  and (PTypeInfo(TQ3Body(ABodyB).UserDataType) = TypeInfo(PGorillaParticle)) then
    Exit;

  if (PTypeInfo(TQ3Body(ABodyA).UserDataType) = TypeInfo(PGorillaParticle)) then
    FSplashes.EmitParticle(
      PGorillaParticle(TQ3Body(ABodyA).UserData)^.Position
      )
  else if (PTypeInfo(TQ3Body(ABodyB).UserDataType) = TypeInfo(PGorillaParticle)) then
    FSplashes.EmitParticle(
      PGorillaParticle(TQ3Body(ABodyB).UserData)^.Position
      );
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  [...]

  // create physics system with contact callback function to display splashes
  FPhysics := TGorillaPhysicsSystem.Create(FViewport);
  FPhysics.OnBeginContact := DoOnGorillaPhysicsNotifyContact;

  // create rain particle emitter
  FParticles := TGorillaRainParticleEmitter.Create(FViewport);
  FParticles.Parent := FViewport;
  FParticles.Camera := FCamera;
  FParticles.EmitParticles := 25;

  // preconfigure particles
  FParticles.Colored.StartColor := TAlphaColorF.Create( TAlphaColorRec.Blue );
  FParticles.Colored.EndColor := TAlphaColorF.Create( TAlphaColorRec.Blueviolet );
  FParticles.ParticleSize.Preset(20, 20, 1, false);
  FParticles.ParticleGrowth.Preset(0, 0, 1, false);
  FParticles.Colored.Enabled := false;
  FParticles.Wind.Enabled := false;

  // create a physics influencer
  FInfluencer := TGorillaPhysicsInfluencer.Create(FParticles);
  FInfluencer.Emitter := FParticles;
  // link to physics system component
  FInfluencer.Physics := FPhysics;
  FInfluencer.Enabled := true;

  // another particle emitter to simulate rain drop splashes when they hit an obstacle
  FSplashes := TGorillaSpotParticleEmitter.Create(FViewport);
  FSplashes.Parent := FViewport;
  FSplashes.Camera := FCamera;
  FSplashes.LoadTexture('splash.png');

  // Activate physics
  FPhysics.Active := true;

  // Activate rain particle emitter
  FParticles.Start();
  FParticles.Splashes.Stop(); // BUGFIX: in some cases sub-emitters rendering black

  // Active splash emitter
  FSplashes.Start();
end;

Advanced Features

Sprite Sheets

Animate particles using texture atlases:

var
  LMaterial: TGorillaParticleMaterialSource;
begin
  LMaterial := TGorillaParticleMaterialSource.Create(Self);
  LMaterial.IsSpriteSheet := True;
  LMaterial.SpriteSheetRowCount := 4;
  LMaterial.SpriteSheetColCount := 4;
  LMaterial.FrameWidth := 256;
  LMaterial.FrameHeight := 256;
  LMaterial.Duration := 1.5;  // Animation duration
  LMaterial.Texture.LoadFromFile('explosion_spritesheet.png');

  LEmitter.MaterialSource := LMaterial;
end;

Helper Method:

LEmitter.LoadTexture(
  'explosion.png',  // Filename
  64,               // Particle size
  True,             // Is sprite sheet
  4, 4,             // Rows, columns
  256, 256          // Frame width/height
);

Particle Caching

Reuse expired particles for better performance:

LEmitter.Reuse := True;  // Enable caching (default)

// Clear cached particles
LEmitter.ClearUnused();

// Clear all particles
LEmitter.Clear();

Async Processing

Process particles on background thread:

LEmitter.Async := True;  // Enable async mode
LEmitter.EmitTime := 16;
LEmitter.Start();

// Access the thread
if Assigned(LEmitter.Thread) then
  ShowMessage('Async thread running');

Note: Async mode is recommended for particle systems with > 5000 particles or complex influencers.

Mouse Interaction

Of course you can use the power of Firemonkey to control particle emission by mouse interaction. In the following example, we setup a raw emitter with our own particle material. By the viewport MouseUp, MouseDown and MoveMove events we can detect mouse events. This demo should emit particles every time the mouse is pressed and move. By this we can "draw" particles.

particles1

var 
  FParticles : TGorillaParticleEmitter;

procedure TForm1.FormCreate(Sender: TObject);
var LParticleMat : TParticleMaterialSource;
    LColorInfl : TGorillaColoredParticleInfluencer;
begin
  // create the particle material shader
  LParticleMat := TParticleMaterialSource.Create(FGorilla);
  LParticleMat.Parent := FGorilla;
  LParticleMat.UseTexture := false;
  LParticleMat.IsTextureAtlas := false;

  // create particle emitter for spraying effect
  FParticles := TGorillaParticleEmitter.Create(FGorilla);
  FParticles.Parent := FGorilla;

  // connect particle shader and emitter
  LParticleMat.Emitter := FParticles;

  // limit number of particles
  FParticles.EmitParticles := 100;
  FParticles.MaxParticles  := 10000;

  // disable auto emittance, becaus we want only to emit on mouse click
  FParticles.AutoEmit := false;

  // enable particle caching
  FParticles.Reuse := true;

  // randomize particle properties
  // 1) random position of particles
  FParticles.ParticlePosition.Preset(0, 0, 1000, Point3D(1, 1, 1), [axX, axY, axZ]);

  // 2) random velocity of particles
  FParticles.ParticleVelocity.Preset(5, 10, 1000, Point3D(1, 2, 1), [axX, axY, axZ]);
  FParticles.ParticleVelocity.RangeY.Negative := false;

  // 3) the rest of properties
  FParticles.ParticleSize.Preset(2, 3, 1, false);
  FParticles.ParticleAngle.Preset(0, 360, 1, false);
  FParticles.ParticleWeight.Preset(1, 1, 1, false);
  FParticles.ParticleGrowth.Preset(0, 0, 1, false);
  FParticles.ParticleLifeTime.Preset(500, 5000, 1000, false);

  // create a color influencer for a starting and end color
  LColorInfl:= TGorillaColoredParticleInfluencer.Create(FParticles);
  LColorInfl.StartColor := TAlphaColorF.Create(0, 1, 0, 1);
  LColorInfl.EndColor := TAlphaColorF.Create(0, 0, 1, 0);
end;

var 
  FLatest : TPointF;
  FMouseMove : Boolean = false;
  FClickPt : TPoint3D; 

procedure TForm1.DoOnViewportMouseUp(ASender : TObject; AButton : TMouseButton;
  AShift : TShiftState; X, Y : Single);
begin
  FMouseMove := false;
end;

procedure TForm1.DoOnViewportMouseDown(ASender : TObject; AButton : TMouseButton;
  AShift : TShiftState; X, Y : Single);
var I : Integer;
begin
  if (ssLeft in AShift) then
  begin
    FMouseMove := true;
    FLatest := PointF(X, Y);

    // emit particles at mouse position
    FClickPt := FGorilla.ScreenToWorld(Point(round(X), round(Y)));
    for I := 0 to (FParticles.EmitParticles - 1) do
      FParticles.EmitParticle(FClickPt);
  end;
end;

procedure TForm1.DoOnViewportMouseMove(ASender : TObject; AShiftState : TShiftState;
  X, Y : Single);
var lDiff   : TPointF;
    I       : Integer;
    lOrigin : TPoint3D;
begin
  if (ssLeft in AShiftState) then
  begin
    // emit particles at mouse position
    FClickPt := FGorilla.ScreenToWorld(Point(round(X), round(Y)));
    for I := 0 to (FParticles.EmitParticles - 1) do
      FParticles.EmitParticle(FClickPt);
  end;

  if FMouseMove then
  begin
    FLatest := PointF(X, Y);
  end;
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  // on some constellations you will need an interval to update the viewport
  FGorilla.Invalidate();
end;

Pre-built Effects

Fire

var
  LFire: TGorillaFireParticleEmitter;
begin
  LFire := TGorillaFireParticleEmitter.Create(Self);
  LFire.Parent := GorillaViewport1;
  LFire.Camera := Camera1;
  LFire.Kind := TGorillaFireParticleKind.Default;  // or Alternative, Torch
  LFire.Start();

  // Optional: Access smoke component
  LFire.Smoke.Visible := True;
end;

Rain

var
  LRain: TGorillaRainParticleEmitter;
begin
  LRain := TGorillaRainParticleEmitter.Create(Self);
  LRain.Parent := GorillaViewport1;
  LRain.Camera := Camera1;
  LRain.Width := 100;
  LRain.Height := 50;
  LRain.Depth := 100;
  LRain.SpawnSize := 0.05;  // 5% from top
  LRain.Start();

  // Configure wind
  LRain.Wind.Force.Point := Point3D(-5, 0, 0);

  // Enable splashes
  LRain.Splashes.Visible := True;
end;

Snow

var
  LSnow: TGorillaSnowParticleEmitter;
begin
  LSnow := TGorillaSnowParticleEmitter.Create(Self);
  LSnow.Parent := GorillaViewport1;
  LSnow.Camera := Camera1;
  LSnow.Width := 100;
  LSnow.Height := 50;
  LSnow.Depth := 100;
  LSnow.Start();
end;

Explosion

var
  LExplosion: TGorillaExplosionParticleEmitter;
begin
  LExplosion := TGorillaExplosionParticleEmitter.Create(Self);
  LExplosion.Parent := GorillaViewport1;
  LExplosion.Camera := Camera1;
  LExplosion.MaxAutoEmitTime := 1000;  // 1 second burst
  LExplosion.Start();
end;

Performance Optimization

Particle Count

  • Desktop: 10,000+ particles possible
  • Mobile: Keep below 5,000 particles
  • Adjust MaxParticles based on target hardware

Update Frequency

// 60 FPS updates
LEmitter.EmitTime := 16;

// 30 FPS updates (better performance)
LEmitter.EmitTime := 33;

Particle Reuse

// Always enable for performance
LEmitter.Reuse := True;

Influencer Count

  • Minimize active influencers
  • Disable unused influencers: Influencer.Enabled := False
  • Physics influencers are most expensive

Async Mode

// Enable for > 5000 particles
if LEmitter.MaxParticles > 5000 then
  LEmitter.Async := True;

Texture Size

  • Use compressed textures (DXT/ETC)
  • Keep sprite sheet frames under 512×512
  • Share materials between similar emitters

Best Practices

Camera Assignment

Always link emitter to active camera for proper sorting:

LEmitter.Camera := GorillaViewport1.Camera;

Lifetime vs MaxAutoEmitTime

// Continuous effect
LEmitter.MaxAutoEmitTime := 0;  // Infinite
LEmitter.ParticleLifeTime.Preset(2000, 4000, 1000, False);

// One-time effect (explosion)
LEmitter.MaxAutoEmitTime := 1000;  // 1 second
LEmitter.ParticleLifeTime.Preset(500, 1500, 1000, False);

Manual Update

Force particle update independently of timer:

LEmitter.ForceUpdate();

Event Handling

LEmitter.OnStart := OnEmitterStart;
LEmitter.OnStop := OnEmitterStop;
LEmitter.OnEmitted := OnParticleEmitted;
LEmitter.OnDispose := OnParticleDispose;
LEmitter.OnProcess := OnAutoEmitProcess;

Cleanup

// Stop emitter
LEmitter.Stop();

// Clear all particles
LEmitter.Clear();

// Remove influencers
LEmitter.ClearInfluencers();

Troubleshooting

Particles not visible

  • Check LEmitter.Visible := True
  • Verify LEmitter.Start() was called
  • Ensure MaxParticles > 0
  • Check material/texture is assigned
  • Verify particle size is reasonable

Particles appear as squares

  • Point sprite rendering may be hardware-dependent
  • Intel HD Graphics clamps point size
  • Use textured particles for consistent results

Performance issues

  • Reduce MaxParticles
  • Increase EmitTime interval
  • Enable Async := True
  • Disable unused influencers
  • Enable Reuse := True

Transparency sorting issues

  • Link emitter to camera: LEmitter.Camera := Camera1
  • Check blend mode settings
  • Ensure emitter has opacity < 1.0

Particles not affected by influencers

  • Check Influencer.Enabled := True
  • Verify Influencer.Emitter := LEmitter
  • Ensure emitter is started

See Also

API Reference

Related Topics

  • Materials - For particle materials
  • Camera - Camera setup for particle sorting