UI Particle System Documentation

D O C U M E N T A T I O N

UI Particle System - Scripting API

Welcome to the UI Particle System v2.1.2 coding reference. This guide provides comprehensive examples of how to control the particle system entirely via script, using the new TierStudios namespace structure.

NEW NAMESPACE ALERT:
All scripts are now organized under the TierStudios.UIParticleSystem namespace. Please update your using directives as shown in the examples below.

0. Namespace Structure (Updated)

Include these namespaces to access all features.


// Standard Namespace Imports
using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using TierStudios.UIParticleSystem.Managers;
using TierStudios.UIParticleSystem.Utilities;
using TierStudios.UIParticleSystem.Enums;

1. Basic Initialization

How to initialize the system.


using UnityEngine;
using TierStudios.UIParticleSystem.Core;

public class ParticleStarter : MonoBehaviour
{
    private UIParticleSystem particleSystem;

    void Start()
    {
        particleSystem = GetComponent<UIParticleSystem>();
        particleSystem.StartEmitting();
    }
}

2. Emission Control

Methods to start, stop, pause, and restart.


using TierStudios.UIParticleSystem.Core;
using UnityEngine;

public class EmissionController : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    public void StartEmission() => particleSystem.StartEmitting();
    public void StopEmission() => particleSystem.StopEmitting();
    public void PauseEmission() => particleSystem.PauseSystem();
    public void ResumeEmission() => particleSystem.ResumeSystem();
    public void RestartEmission() => particleSystem.RestartSystem();

    public void ClearAllParticles()
    {
        UIParticleSystem.ClearAllParticles(particleSystem);
    }

    public int GetActiveCount()
    {
        return particleSystem.GetActiveParticleCount();
    }
}

3. Modifying Emission Settings

Changing emission rates and bursts at runtime.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using TierStudios.UIParticleSystem.Enums;
using UnityEngine;

public class EmissionCustomizer : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    void Start()
    {
        var emission = particleSystem.EmissionSettings;
        
        // Emission settings
        emission.emissionRate = 50f;
        emission.maxParticles = 1000;
        emission.looping = true;
        emission.duration = 5f;
        emission.startDelay = 0.5f;
        
        // Shape settings
        emission.emissionShape = EmissionShapeType.Circle;
        emission.circleRadius = 100f;
        emission.emitFromEdge = false;
        
        // Direction settings
        emission.emissionDirection = Vector2.up;
        emission.randomizeDirection = true;
        emission.directionVariance = 45f;
        
        // Simulation space
        emission.simulationSpace = SimulationSpace.Local;
    }

    // Add Burst
    public void AddExplosion()
    {
        var burst = new Burst
        {
            time = 1f,
            count = 200,
            probability = 1f
        };
        
        particleSystem.EmissionSettings.bursts.Add(burst);
    }
}

4. Lifetime and Size Settings

Controlling particle lifespan and scale.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using UnityEngine;

public class ParticleAppearance : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    void Start()
    {
        // Lifetime
        var lifetime = particleSystem.LifetimeSettings;
        lifetime.useRandomLifetime = true;
        lifetime.minLifetime = 1f;
        lifetime.maxLifetime = 3f;

        // Size
        var size = particleSystem.SizeSettings;
        size.useSizeRange = true;
        size.minSize = 20f;
        size.maxSize = 80f;
        
        // Size over lifetime
        size.useSizeOverLifetime = true;
        size.sizeOverLifetime = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
        
        // 2D Size Usage
        size.use2DSize = true;
        size.size2D = new Vector2(50f, 100f);
    }
}

5. Color and Gradient

Applying solid colors, random ranges, or gradients.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using UnityEngine;

public class ColorController : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    void Start()
    {
        var color = particleSystem.ColorSettings;
        
        // Simple Color
        color.particleColor = Color.red;
        
        // Random between two colors
        color.useRandomColors = true;
        color.particleColor = Color.yellow;
        color.particleColorEnd = Color.red;
        
        // Gradient Usage
        color.useGradientColor = true;
        Gradient gradient = new Gradient();
        gradient.SetKeys(
            new GradientColorKey[] {
                new GradientColorKey(Color.white, 0f),
                new GradientColorKey(Color.blue, 0.5f),
                new GradientColorKey(Color.cyan, 1f)
            },
            new GradientAlphaKey[] {
                new GradientAlphaKey(1f, 0f),
                new GradientAlphaKey(0f, 1f)
            }
        );
        color.colorGradient = gradient;
    }
}

6. Rotation Settings

Controlling angular velocity and initial rotation.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using UnityEngine;

public class RotationController : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    void Start()
    {
        var rotation = particleSystem.RotationSettings;
        
        // Start Rotation
        rotation.useRandomRotation = true;
        rotation.minRotation = 0f;
        rotation.maxRotation = 360f;
        
        // Rotation Speed
        rotation.useRotationOverLifetime = true;
        rotation.useRandomRotationSpeed = true;
        rotation.minRotationSpeed = -180f;
        rotation.maxRotationSpeed = 180f;
    }
}

7. Velocity Over Lifetime (NEW)

Controlling speed, orbital movement, and gravity.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using TierStudios.UIParticleSystem.Enums;
using UnityEngine;

public class VelocityController : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    void Start()
    {
        var velocity = particleSystem.VelocityOverLifetimeSettings;
        
        // Enable Velocity Module
        velocity.enabled = true;
        
        // Linear velocity
        velocity.velocityX = AnimationCurve.Linear(0f, 0f, 1f, 50f);
        velocity.velocityY = AnimationCurve.Linear(0f, 100f, 1f, -100f);
        
        // Orbital velocity
        velocity.orbitalX = AnimationCurve.Constant(0f, 1f, 45f);
        velocity.orbitalY = AnimationCurve.Constant(0f, 1f, 90f);
        
        // Space setting
        velocity.space = SimulationSpace.Local;
        
        // Speed modifier
        velocity.speedModifier = AnimationCurve.Linear(0f, 1f, 1f, 0.5f);
    }

    // Apply Gravity Effect
    public void ApplyGravity()
    {
        var velocity = particleSystem.VelocityOverLifetimeSettings;
        velocity.enabled = true;
        velocity.velocityY = AnimationCurve.Linear(0f, 0f, 1f, -200f);
    }
}

8. Attractor System

Creating magnets and vortex effects.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using TierStudios.UIParticleSystem.Enums;
using UnityEngine;

public class AttractorController : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;
    [SerializeField] private Transform attractorTarget;

    void Start()
    {
        var attractor = particleSystem.AttractorSettings;
        
        // Enable Attractor
        attractor.useAttractor = true;
        attractor.attractorType = AttractorType.Attract;
        
        // Target Position
        attractor.attractorPosition = attractorTarget.position;
        
        // Strength & Radius
        attractor.attractorStrength = 150f;
        attractor.attractorRadius = 300f;
        
        // Falloff curve
        attractor.attractorFalloff = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
        
        // Kill radius
        attractor.useKillRadius = true;
        attractor.killRadius = 20f;
    }

    void Update()
    {
        // Dynamic Update
        particleSystem.AttractorSettings.attractorPosition = attractorTarget.position;
    }

    // Create Vortex
    public void CreateVortex()
    {
        var attractor = particleSystem.AttractorSettings;
        attractor.attractorType = AttractorType.Vortex;
        attractor.attractorStrength = 100f;
    }
}

9. Noise System

Adding turbulence and organic movement.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using TierStudios.UIParticleSystem.Enums;
using UnityEngine;

public class NoiseController : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    void Start()
    {
        var noise = particleSystem.NoiseSettings;
        
        // Enable Noise
        noise.useNoise = true;
        noise.noiseType = NoiseType.Perlin;
        
        // Settings
        noise.noiseStrength = 50f;
        noise.noiseFrequency = 1f;
        noise.noiseScrollSpeed = 10f;
        noise.noiseOctaves = 3;
        
        // Strength over lifetime
        noise.useNoiseStrengthOverLifetime = true;
        noise.noiseStrengthOverLifetime = AnimationCurve.Linear(0f, 0f, 1f, 1f);
    }

    // Apply Turbulence
    public void ApplyTurbulence()
    {
        var noise = particleSystem.NoiseSettings;
        noise.noiseType = NoiseType.Turbulence;
        noise.noiseStrength = 100f;
    }
}

10. Trail System

Rendering trails behind particles.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using UnityEngine;

public class TrailController : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    void Start()
    {
        var trail = particleSystem.TrailSettings;
        
        // Enable Trails
        trail.useTrails = true;
        
        // Settings
        trail.trailLifetime = 0.5f;
        trail.trailWidth = 5f;
        trail.trailMaxPoints = 20;
        trail.trailUpdateInterval = 0.05f;
        trail.maxVerticesPerFrame = 1000;
        
        // Color
        trail.inheritParticleColor = true;
        trail.trailStartColor = Color.white;
        trail.trailEndColor = new Color(1f, 1f, 1f, 0f);
        
        // Width curve
        trail.trailWidthCurve = AnimationCurve.Linear(0f, 1f, 1f, 0f);
        
        // Material
        trail.trailMaterial = Resources.Load<Material>("TrailMaterial");
    }

    public void RefreshTrails()
    {
        particleSystem.RefreshTrailSettings();
    }
}

11. Texture Sheet Animation

Using sprite sheets for animated particles.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using TierStudios.UIParticleSystem.Enums;
using UnityEngine;

public class TextureSheetController : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;
    [SerializeField] private Texture2D spriteSheet;

    void Start()
    {
        var textureSheet = particleSystem.TextureSheetSettings;
        
        // Enable
        textureSheet.useTextureSheetAnimation = true;
        textureSheet.textureSheet = spriteSheet;
        
        // Grid
        textureSheet.tilesX = 4;
        textureSheet.tilesY = 4;
        
        // Type
        textureSheet.animationCycle = AnimationCycle.WholeSheet;
        textureSheet.animationFrames = 16;
        
        // Speed & Loop
        textureSheet.animationSpeed = 24f;
        textureSheet.loopAnimation = true;
        
        // Random Start
        textureSheet.randomStartFrame = true;
    }

    public void PlaySingleRow(int rowIndex)
    {
        var textureSheet = particleSystem.TextureSheetSettings;
        textureSheet.animationCycle = AnimationCycle.SingleRow;
        textureSheet.singleRowIndex = rowIndex;
    }
}

12. Event System

Listening to system events (C# & UnityEvents).


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using UnityEngine;

public class ParticleEventHandler : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;
    
    void OnEnable()
    {
        // Enable Events
        particleSystem.EventSettings.EnableEvents = true;
        
        // C# Action Events
        particleSystem.OnParticleSpawned += OnParticleSpawned;
        particleSystem.OnParticleDied += OnParticleDied;
        
        // UnityEvents
        particleSystem.EventSettings.onParticleSpawned.AddListener(OnSpawn);
    }

    void OnDisable()
    {
        particleSystem.OnParticleSpawned -= OnParticleSpawned;
        particleSystem.OnParticleDied -= OnParticleDied;
    }

    void OnParticleSpawned(ParticleEventArgs args)
    {
        Debug.Log($"Particle Spawned! Pos: {args.Particle.position}");
    }

    void OnParticleDied(ParticleEventArgs args)
    {
        Debug.Log($"Particle Died! Age: {args.Particle.age}");
    }

    void OnSpawn(ParticleEventData data)
    {
        Debug.Log($"UnityEvent Spawn! Index: {data.particleIndex}");
    }
}

13. Mobile Optimization (NEW)

Optimizing performance for mobile devices.


using TierStudios.UIParticleSystem.Core;
using UnityEngine;

public class MobileOptimizer : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    void Start()
    {
#if UNITY_ANDROID || UNITY_IOS
        // Activate Mobile Optimization
        particleSystem.SetMobileOptimization(
            enabled: true,
            maxParticles: 50,
            updateInterval: 0.033f
        );
#endif
    }

    // Manual Mode
    public void EnableMobileMode()
    {
        particleSystem.MobileOptimizationMode = true;
        particleSystem.MobileMaxParticles = 75;
    }

    public void CheckPerformance()
    {
        int effectiveMax = particleSystem.EffectiveMaxParticles;
        Debug.Log($"Max Particles: {effectiveMax}");
    }
}

14. Direct Particle Manipulation

Modifying active particles.


using TierStudios.UIParticleSystem.Core;
using System.Collections.Generic;
using UnityEngine;

public class ParticleManipulator : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;

    void Update()
    {
        List<Particle> particles = particleSystem.ActiveParticles;
        
        foreach (Particle particle in particles)
        {
            if (particle == null || !particle.isAlive) continue;
            
            // Modify properties
            particle.position += Vector2.up * Time.deltaTime * 10f;
            particle.velocity *= 0.99f;
            particle.color = Color.Lerp(particle.color, Color.red, Time.deltaTime);
            particle.size += Time.deltaTime * 5f;
            particle.rotation += Time.deltaTime * 90f;
        }
    }
}

15. Complete Example: Dynamic System

A comprehensive example combining multiple features.


using TierStudios.UIParticleSystem.Core;
using TierStudios.UIParticleSystem.Settings;
using TierStudios.UIParticleSystem.Enums;
using UnityEngine;

public class DynamicFeedbackSystem : MonoBehaviour
{
    [SerializeField] private UIParticleSystem particleSystem;
    [SerializeField] private Transform player;

    void Start()
    {
        SetupParticleSystem();
    }

    void SetupParticleSystem()
    {
        // Emission
        var emission = particleSystem.EmissionSettings;
        emission.emissionRate = 50f;
        emission.maxParticles = 300;
        emission.emissionShape = EmissionShapeType.Circle;
        
        // Velocity (NEW)
        var velocity = particleSystem.VelocityOverLifetimeSettings;
        velocity.enabled = true;
        velocity.velocityY = AnimationCurve.Linear(0f, 0f, 1f, -100f);
        
        // Attractor
        var attractor = particleSystem.AttractorSettings;
        attractor.useAttractor = true;
        attractor.attractorStrength = 200f;
        attractor.attractorPosition = player.position;
        
        particleSystem.StartEmitting();
    }

    void Update()
    {
        if (player != null)
        {
            particleSystem.AttractorSettings.attractorPosition = player.position;
        }
    }

    public void TriggerHitEffect(Vector2 hitPosition)
    {
        var burst = new Burst
        {
            time = 0f,
            count = 100,
            probability = 1f
        };
        
        particleSystem.EmissionSettings.bursts.Add(burst);
        particleSystem.transform.position = hitPosition;
        particleSystem.RestartSystem();
    }
}

Summary of Features

  • Emission: Start, Stop, Pause, Resume, Restart controls.
  • Settings: Full access to Emission, Lifetime, Size, Color, etc.
  • Velocity (New): Orbital velocity, gravity, and speed modifiers.
  • Mobile (New): Optimization settings for better performance on Android/iOS.
  • Effects: Attractor, Noise, Trail, Texture Sheet Animation.
  • Events: Complete C# and UnityEvent system support.

Social Platforms

@TierStudios