Rasagar/Library/PackageCache/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphObjectPool.cs
2024-08-26 23:07:20 +03:00

137 lines
4.9 KiB
C#

using System;
using System.Collections.Generic;
namespace UnityEngine.Rendering.RenderGraphModule
{
/// <summary>
/// Helper class provided in the RenderGraphContext to all Render Passes.
/// It allows you to do temporary allocations of various objects during a Render Pass.
/// </summary>
public sealed class RenderGraphObjectPool
{
// Only used to clear all existing pools at once from here when needed
static DynamicArray<SharedObjectPoolBase> s_AllocatedPools = new DynamicArray<SharedObjectPoolBase>();
// Non abstract class instead of an interface to store it in a DynamicArray
class SharedObjectPoolBase
{
public SharedObjectPoolBase() {}
public virtual void Clear() {}
}
class SharedObjectPool<T> : SharedObjectPoolBase where T : class, new()
{
private static readonly Pool.ObjectPool<T> s_Pool = AllocatePool();
private static Pool.ObjectPool<T> AllocatePool()
{
var newPool = new Pool.ObjectPool<T>(() => new T(), null, null);
// Storing instance to clear the static pool of the same type if needed
s_AllocatedPools.Add(new SharedObjectPool<T>());
return newPool;
}
/// <summary>
/// Clear the pool using SharedObjectPool instance.
/// </summary>
/// <returns></returns>
public override void Clear()
{
s_Pool.Clear();
}
/// <summary>
/// Get a new instance from the pool.
/// </summary>
/// <returns></returns>
public static T Get() => s_Pool.Get();
/// <summary>
/// Release an object to the pool.
/// </summary>
/// <param name="toRelease">instance to release.</param>
public static void Release(T toRelease) => s_Pool.Release(toRelease);
}
Dictionary<(Type, int), Stack<object>> m_ArrayPool = new Dictionary<(Type, int), Stack<object>>();
List<(object, (Type, int))> m_AllocatedArrays = new List<(object, (Type, int))>();
List<MaterialPropertyBlock> m_AllocatedMaterialPropertyBlocks = new List<MaterialPropertyBlock>();
internal RenderGraphObjectPool() { }
/// <summary>
/// Allocate a temporary typed array of a specific size.
/// Unity releases the array at the end of the Render Pass.
/// </summary>
/// <typeparam name="T">Type of the array to be allocated.</typeparam>
/// <param name="size">Number of element in the array.</param>
/// <returns>A new array of type T with size number of elements.</returns>
public T[] GetTempArray<T>(int size)
{
if (!m_ArrayPool.TryGetValue((typeof(T), size), out var stack))
{
stack = new Stack<object>();
m_ArrayPool.Add((typeof(T), size), stack);
}
var result = stack.Count > 0 ? (T[])stack.Pop() : new T[size];
m_AllocatedArrays.Add((result, (typeof(T), size)));
return result;
}
/// <summary>
/// Allocate a temporary MaterialPropertyBlock for the Render Pass.
/// </summary>
/// <returns>A new clean MaterialPropertyBlock.</returns>
public MaterialPropertyBlock GetTempMaterialPropertyBlock()
{
var result = SharedObjectPool<MaterialPropertyBlock>.Get();
result.Clear();
m_AllocatedMaterialPropertyBlocks.Add(result);
return result;
}
internal void ReleaseAllTempAlloc()
{
foreach (var arrayDesc in m_AllocatedArrays)
{
bool result = m_ArrayPool.TryGetValue(arrayDesc.Item2, out var stack);
Debug.Assert(result, "Correct stack type should always be allocated.");
stack.Push(arrayDesc.Item1);
}
m_AllocatedArrays.Clear();
foreach (var mpb in m_AllocatedMaterialPropertyBlocks)
{
SharedObjectPool<MaterialPropertyBlock>.Release(mpb);
}
m_AllocatedMaterialPropertyBlocks.Clear();
}
// Regular pooling API. Only internal use for now
internal T Get<T>() where T : class, new()
{
return SharedObjectPool<T>.Get();
}
internal void Release<T>(T value) where T : class, new()
{
SharedObjectPool<T>.Release(value);
}
internal void Cleanup()
{
m_AllocatedArrays.Clear();
m_AllocatedMaterialPropertyBlocks.Clear();
m_ArrayPool.Clear();
// Removing all objects in the pools
foreach (var pool in s_AllocatedPools)
pool.Clear();
}
}
}