Struct DynamicBuffer<T>

An array-like data structure that can be used as a component.

Namespace: Unity.Entities

Syntax

[NativeContainer]
public struct DynamicBuffer<T> : IQueryTypeParameter, IEnumerable<T>, IEnumerable, INativeList<T>, IIndexable<T> where T : struct

Type Parameters

Name	Description
T	The data type stored in the buffer. Must be a value type.

Examples

[InternalBufferCapacity(8)]
public struct FloatBufferElement : IBufferElementData
{
    // Actual value each buffer element will store.
    public float Value;

    // The following implicit conversions are optional, but can be convenient.
    public static implicit operator float(FloatBufferElement e)
    {
        return e.Value;
    }

    public static implicit operator FloatBufferElement(float e)
    {
        return new FloatBufferElement { Value = e };
    }
}

public partial class DynamicBufferExample : SystemBase
{
    protected override void OnUpdate()
    {
        float sum = 0;

        Entities.ForEach((DynamicBuffer<FloatBufferElement> buffer) =>
        {
            for (int i = 0; i < buffer.Length; i++)
            {
                sum += buffer[i].Value;
            }
        }).Run();

        Debug.Log("Sum of all buffers: " + sum);
    }
}

Properties

Name	Description
Capacity	The number of elements the buffer can hold.
IsCreated	Whether the memory for this dynamic buffer has been allocated.
IsEmpty	Reports whether container is empty.
Item[Int32]	Array-like indexing operator.
Length	The number of elements the buffer holds.

Methods

Name	Description
Add(T)	Adds an element to the end of the buffer, resizing as necessary.
AddRange(NativeArray<T>)	Adds all the elements from newElems to the end of the buffer, resizing as necessary.
AsNativeArray()	Return a native array that aliases the original buffer contents.
Clear()	Sets the buffer length to zero.
CopyFrom(T[])	Copies all the elements from an array.
CopyFrom(NativeArray<T>)	Copies all the elements from the specified native array into this dynamic buffer.
CopyFrom(NativeSlice<T>)	Copies all the elements from the specified native slice into this dynamic buffer.
CopyFrom(DynamicBuffer<T>)	Copies all the elements from another dynamic buffer.
ElementAt(Int32)	Gets the reference to the element at the given index.
EnsureCapacity(Int32)	Ensures that the buffer has at least the specified capacity.
GetEnumerator()	Provides an enumerator for iterating over the buffer elements.
GetUnsafePtr()	Gets an unsafe read/write pointer to the contents of the buffer.
GetUnsafeReadOnlyPtr()	Gets an unsafe read-only pointer to the contents of the buffer.
Insert(Int32, T)	Inserts an element at the specified index, resizing as necessary.
Reinterpret<U>()	Returns a dynamic buffer of a different type, pointing to the same buffer memory.
RemoveAt(Int32)	Removes the element at the specified index.
RemoveAtSwapBack(Int32)	Removes the element at the specified index and swaps the last element into its place. This is more efficient than moving all elements following the removed element, but does change the order of elements in the buffer.
RemoveRange(Int32, Int32)	Removes the specified number of elements, starting with the element at the specified index.
RemoveRangeSwapBack(Int32, Int32)	Removes the specified number of elements, starting with the element at the specified index. It replaces the elements that were removed with a range of elements from the back of the buffer. This is more efficient than moving all elements following the removed elements, but does change the order of elements in the buffer.
Resize(Int32, NativeArrayOptions)	Sets the length of this buffer, increasing the capacity if necessary.
ResizeUninitialized(Int32)	Sets the length of this buffer, increasing the capacity if necessary.
ToNativeArray(AllocatorManager.AllocatorHandle)	Copies the buffer into a new native array.
TrimExcess()	Removes any excess capacity in the buffer.