# GetParticles

> Gets the particles of this Particle System.

## Definition

* **Type:** Method
* **Namespace:** [UnityEngine](/engine/6000.7/script-reference/unityengine.md)
* **Assembly:** UnityEngine.ParticleSystemModule

## GetParticles(Particle\[], int, int)

Gets the particles of this Particle System.

```csharp
public int GetParticles(ParticleSystem.Particle[] particles, int size, int offset)
```

### Parameters

**** (\[Particle\[]]\(/engine/6000.7/script-reference/unityengine/particlesystem/particle)): Output particle buffer, containing the current particle state.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The number of elements that are read from the Particle System.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The offset into the active particle list, from which to copy the particles.

### Returns

| Type                                                       | Description                                                                                            |
| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The number of particles written to the input particle array (the number of particles currently alive). |

### Remarks

This method is allocation free as long the input "particles" array is preallocated once (see example below). The method only gets the particles that are currently alive in the Particle System when it is called, so it may only get a small part of the particles array.

Additional Resources: [ParticleSystem.Particle](/engine/6000.7/script-reference/unityengine/particlesystem/particle.md), [ParticleSystem.SetParticles](/engine/6000.7/script-reference/unityengine/particlesystem/setparticles.md)

### Examples

```csharp
using UnityEngine;

[RequireComponent(typeof(ParticleSystem))]
public class ParticleFlow : MonoBehaviour
{
    ParticleSystem m_System;
    ParticleSystem.Particle[] m_Particles;
    public float m_Drift = 0.01f;

    private void LateUpdate()
    {
        InitializeIfNeeded();

        // GetParticles is allocation free because we reuse the m_Particles buffer between updates
        int numParticlesAlive = m_System.GetParticles(m_Particles);

        // Change only the particles that are alive
        for (int i = 0; i < numParticlesAlive; i++)
        {
            m_Particles[i].velocity += Vector3.up * m_Drift;
        }

        // Apply the particle changes to the Particle System
        m_System.SetParticles(m_Particles, numParticlesAlive);
    }

    void InitializeIfNeeded()
    {
        if (m_System == null)
            m_System = GetComponent<ParticleSystem>();

        if (m_Particles == null || m_Particles.Length < m_System.main.maxParticles)
            m_Particles = new ParticleSystem.Particle[m_System.main.maxParticles];
    }
}
```

## GetParticles(Particle\[], int)

Gets the particles of this Particle System.

```csharp
public int GetParticles(ParticleSystem.Particle[] particles, int size)
```

### Parameters

**** (\[Particle\[]]\(/engine/6000.7/script-reference/unityengine/particlesystem/particle)): Output particle buffer, containing the current particle state.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The number of elements that are read from the Particle System.

### Returns

| Type                                                       | Description                                                                                            |
| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The number of particles written to the input particle array (the number of particles currently alive). |

### Remarks

This method is allocation free as long the input "particles" array is preallocated once (see example below). The method only gets the particles that are currently alive in the Particle System when it is called, so it may only get a small part of the particles array.

Additional Resources: [ParticleSystem.Particle](/engine/6000.7/script-reference/unityengine/particlesystem/particle.md), [ParticleSystem.SetParticles](/engine/6000.7/script-reference/unityengine/particlesystem/setparticles.md)

### Examples

```csharp
using UnityEngine;

[RequireComponent(typeof(ParticleSystem))]
public class ParticleFlow : MonoBehaviour
{
    ParticleSystem m_System;
    ParticleSystem.Particle[] m_Particles;
    public float m_Drift = 0.01f;

    private void LateUpdate()
    {
        InitializeIfNeeded();

        // GetParticles is allocation free because we reuse the m_Particles buffer between updates
        int numParticlesAlive = m_System.GetParticles(m_Particles);

        // Change only the particles that are alive
        for (int i = 0; i < numParticlesAlive; i++)
        {
            m_Particles[i].velocity += Vector3.up * m_Drift;
        }

        // Apply the particle changes to the Particle System
        m_System.SetParticles(m_Particles, numParticlesAlive);
    }

    void InitializeIfNeeded()
    {
        if (m_System == null)
            m_System = GetComponent<ParticleSystem>();

        if (m_Particles == null || m_Particles.Length < m_System.main.maxParticles)
            m_Particles = new ParticleSystem.Particle[m_System.main.maxParticles];
    }
}
```

## GetParticles(Particle\[])

Gets the particles of this Particle System.

```csharp
public int GetParticles(ParticleSystem.Particle[] particles)
```

### Parameters

**** (\[Particle\[]]\(/engine/6000.7/script-reference/unityengine/particlesystem/particle)): Output particle buffer, containing the current particle state.

### Returns

| Type                                                       | Description                                                                                            |
| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The number of particles written to the input particle array (the number of particles currently alive). |

### Remarks

This method is allocation free as long the input "particles" array is preallocated once (see example below). The method only gets the particles that are currently alive in the Particle System when it is called, so it may only get a small part of the particles array.

Additional Resources: [ParticleSystem.Particle](/engine/6000.7/script-reference/unityengine/particlesystem/particle.md), [ParticleSystem.SetParticles](/engine/6000.7/script-reference/unityengine/particlesystem/setparticles.md)

### Examples

```csharp
using UnityEngine;

[RequireComponent(typeof(ParticleSystem))]
public class ParticleFlow : MonoBehaviour
{
    ParticleSystem m_System;
    ParticleSystem.Particle[] m_Particles;
    public float m_Drift = 0.01f;

    private void LateUpdate()
    {
        InitializeIfNeeded();

        // GetParticles is allocation free because we reuse the m_Particles buffer between updates
        int numParticlesAlive = m_System.GetParticles(m_Particles);

        // Change only the particles that are alive
        for (int i = 0; i < numParticlesAlive; i++)
        {
            m_Particles[i].velocity += Vector3.up * m_Drift;
        }

        // Apply the particle changes to the Particle System
        m_System.SetParticles(m_Particles, numParticlesAlive);
    }

    void InitializeIfNeeded()
    {
        if (m_System == null)
            m_System = GetComponent<ParticleSystem>();

        if (m_Particles == null || m_Particles.Length < m_System.main.maxParticles)
            m_Particles = new ParticleSystem.Particle[m_System.main.maxParticles];
    }
}
```

## GetParticles(NativeArray\<Particle>, int, int)

Gets the particles of this Particle System.

```csharp
public int GetParticles(NativeArray<ParticleSystem.Particle> particles, int size, int offset)
```

### Parameters

**** (\[NativeArray\<Particle>]\(/engine/6000.7/script-reference/unity/collections/nativearray1)): Output particle buffer, containing the current particle state.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The number of elements that are read from the Particle System.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The offset into the active particle list, from which to copy the particles.

### Returns

| Type                                                       | Description                                                                                            |
| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The number of particles written to the input particle array (the number of particles currently alive). |

### Remarks

This method is allocation free as long the input "particles" array is preallocated once (see example below). The method only gets the particles that are currently alive in the Particle System when it is called, so it may only get a small part of the particles array.

Additional Resources: [ParticleSystem.Particle](/engine/6000.7/script-reference/unityengine/particlesystem/particle.md), [ParticleSystem.SetParticles](/engine/6000.7/script-reference/unityengine/particlesystem/setparticles.md)

### Examples

```csharp
using UnityEngine;

[RequireComponent(typeof(ParticleSystem))]
public class ParticleFlow : MonoBehaviour
{
    ParticleSystem m_System;
    ParticleSystem.Particle[] m_Particles;
    public float m_Drift = 0.01f;

    private void LateUpdate()
    {
        InitializeIfNeeded();

        // GetParticles is allocation free because we reuse the m_Particles buffer between updates
        int numParticlesAlive = m_System.GetParticles(m_Particles);

        // Change only the particles that are alive
        for (int i = 0; i < numParticlesAlive; i++)
        {
            m_Particles[i].velocity += Vector3.up * m_Drift;
        }

        // Apply the particle changes to the Particle System
        m_System.SetParticles(m_Particles, numParticlesAlive);
    }

    void InitializeIfNeeded()
    {
        if (m_System == null)
            m_System = GetComponent<ParticleSystem>();

        if (m_Particles == null || m_Particles.Length < m_System.main.maxParticles)
            m_Particles = new ParticleSystem.Particle[m_System.main.maxParticles];
    }
}
```

## GetParticles(NativeArray\<Particle>, int)

Gets the particles of this Particle System.

```csharp
public int GetParticles(NativeArray<ParticleSystem.Particle> particles, int size)
```

### Parameters

**** (\[NativeArray\<Particle>]\(/engine/6000.7/script-reference/unity/collections/nativearray1)): Output particle buffer, containing the current particle state.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The number of elements that are read from the Particle System.

### Returns

| Type                                                       | Description                                                                                            |
| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The number of particles written to the input particle array (the number of particles currently alive). |

### Remarks

This method is allocation free as long the input "particles" array is preallocated once (see example below). The method only gets the particles that are currently alive in the Particle System when it is called, so it may only get a small part of the particles array.

Additional Resources: [ParticleSystem.Particle](/engine/6000.7/script-reference/unityengine/particlesystem/particle.md), [ParticleSystem.SetParticles](/engine/6000.7/script-reference/unityengine/particlesystem/setparticles.md)

### Examples

```csharp
using UnityEngine;

[RequireComponent(typeof(ParticleSystem))]
public class ParticleFlow : MonoBehaviour
{
    ParticleSystem m_System;
    ParticleSystem.Particle[] m_Particles;
    public float m_Drift = 0.01f;

    private void LateUpdate()
    {
        InitializeIfNeeded();

        // GetParticles is allocation free because we reuse the m_Particles buffer between updates
        int numParticlesAlive = m_System.GetParticles(m_Particles);

        // Change only the particles that are alive
        for (int i = 0; i < numParticlesAlive; i++)
        {
            m_Particles[i].velocity += Vector3.up * m_Drift;
        }

        // Apply the particle changes to the Particle System
        m_System.SetParticles(m_Particles, numParticlesAlive);
    }

    void InitializeIfNeeded()
    {
        if (m_System == null)
            m_System = GetComponent<ParticleSystem>();

        if (m_Particles == null || m_Particles.Length < m_System.main.maxParticles)
            m_Particles = new ParticleSystem.Particle[m_System.main.maxParticles];
    }
}
```

## GetParticles(NativeArray\<Particle>)

Gets the particles of this Particle System.

```csharp
public int GetParticles(NativeArray<ParticleSystem.Particle> particles)
```

### Parameters

**** (\[NativeArray\<Particle>]\(/engine/6000.7/script-reference/unity/collections/nativearray1)): Output particle buffer, containing the current particle state.

### Returns

| Type                                                       | Description                                                                                            |
| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| [int](https://learn.microsoft.com/dotnet/api/system.int32) | The number of particles written to the input particle array (the number of particles currently alive). |

### Remarks

This method is allocation free as long the input "particles" array is preallocated once (see example below). The method only gets the particles that are currently alive in the Particle System when it is called, so it may only get a small part of the particles array.

Additional Resources: [ParticleSystem.Particle](/engine/6000.7/script-reference/unityengine/particlesystem/particle.md), [ParticleSystem.SetParticles](/engine/6000.7/script-reference/unityengine/particlesystem/setparticles.md)

### Examples

```csharp
using UnityEngine;

[RequireComponent(typeof(ParticleSystem))]
public class ParticleFlow : MonoBehaviour
{
    ParticleSystem m_System;
    ParticleSystem.Particle[] m_Particles;
    public float m_Drift = 0.01f;

    private void LateUpdate()
    {
        InitializeIfNeeded();

        // GetParticles is allocation free because we reuse the m_Particles buffer between updates
        int numParticlesAlive = m_System.GetParticles(m_Particles);

        // Change only the particles that are alive
        for (int i = 0; i < numParticlesAlive; i++)
        {
            m_Particles[i].velocity += Vector3.up * m_Drift;
        }

        // Apply the particle changes to the Particle System
        m_System.SetParticles(m_Particles, numParticlesAlive);
    }

    void InitializeIfNeeded()
    {
        if (m_System == null)
            m_System = GetComponent<ParticleSystem>();

        if (m_Particles == null || m_Particles.Length < m_System.main.maxParticles)
            m_Particles = new ParticleSystem.Particle[m_System.main.maxParticles];
    }
}
```