public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
{
if (renderingData.cameraData.renderType != CameraRenderType.Base)
{
return;
}
var cameraID = renderingData.cameraData.camera.GetInstanceID();
// Recreate resources on domain reload.
var firstFrame = !passes.TryGetValue(cameraID, out var pass);
// if (pass?.Material == null) {
// passes.Remove(cameraID);
// firstFrame = true;
// }
// Create a new pass per-camera (or get it if already created).
if (firstFrame)
{
pass = new SheepPass(sheepMesh, sheepMaterial);
passes.Add(cameraID, pass);
}
#if UNITY_EDITOR
if (lastMesh != sheepMesh)
{
vertexBuffer?.Dispose();
indexBuffer?.Dispose();
InitializeVertexBuffer(sheepMesh);
InitializeIndexBuffer(sheepMesh);
lastMesh = sheepMesh;
}
#endif
// Update drawArgs.
if (drawArgsBuffer != null && sheepMesh != null)
{
var drawArgs = new int[1 * 1 * 5];
drawArgs[0] = sheepMesh.GetSubMesh(0).indexCount;
drawArgs[1] = sheepCount;
drawArgs[2] = 0;
drawArgs[3] = 0;
drawArgs[4] = 0;
drawArgsBuffer.SetData(drawArgs);
}
// Update the ambient light.
SetSHCoefficients(sheepMaterial);
// Update the pass values and enqueue it.
pass.Update(indexBuffer, drawArgsBuffer);
renderer.EnqueuePass(pass);
}
void OnDestroy()
{
idxBuff.Dispose();
tblBuff.Dispose();
colBuff.Dispose();
vrtBuff.Dispose();
}
public override void Cleanup()
{
_quadPrimitive?.Dispose();
_indexBuffer?.Dispose();
_vertexBuffer?.Dispose();
base.Cleanup();
}
private void OnDestroy()
{
if (quadTree != null)
{
quadTree.Release();
quadTree = null;
}
if (perlin != null)
{
perlin.Release();
perlin = null;
}
if (meshTerrain != null)
{
meshTerrain.Clear();
meshTerrain = null;
}
if (argBuffer != null)
{
argBuffer.Release();
argBuffer.Dispose();
argBuffer = null;
}
renderPatchesBuffer = null;
}
public override void Cleanup()
{
_trianglePrimitive?.Dispose();
_constantBuffer?.Dispose();
_vertexBuffer?.Dispose();
base.Cleanup();
}
private void CleanUp()
{
if (bufferA != null)
{
bufferA.Dispose();
}
if (bufferB != null)
{
bufferB.Dispose();
}
if (bufferA_index != null)
{
bufferA_index.Dispose();
}
if (bufferB_index != null)
{
bufferB_index.Dispose();
}
if (argsBuffer != null)
{
argsBuffer.Release();
argsBuffer = null;
}
}
private void ReleaseBuffer()
{
if (m_Buffer != null)
{
m_Buffer.Dispose();
m_Buffer = null;
}
}
public override void Cleanup()
{
_pyramid?.Dispose();
_constantBuffer?.Dispose();
_indexBuffer?.Dispose();
_vertexBuffer?.Dispose();
base.Cleanup();
}
public override void Cleanup()
{
_trianglePrimitive?.Dispose();
_texture2D?.Dispose();
_uploadBuffer?.Dispose();
_vertexBuffer?.Dispose();
base.Cleanup();
}
void OnDisable()
{
if (bufferA != null)
{
bufferA.Dispose();
}
if (bufferB != null)
{
bufferB.Dispose();
}
}
void Release()
{
Destroy(_Material);
Destroy(_Mesh);
_Mesh = null;
_VertexBuffer?.Dispose();
_VertexBuffer = null;
_TexcoordBuffer?.Dispose();
_TexcoordBuffer = null;
_NormalBuffer?.Dispose();
_NormalBuffer = null;
}
public override void Cleanup()
{
_sierpinskiPrimitive?.Dispose();
_constantBuffer?.Dispose();
_indexBuffer?.Dispose();
_texture3D.Dispose();
_uploadBuffer?.Dispose();
_vertexBuffer?.Dispose();
base.Cleanup();
}
public override void Cleanup()
{
_trianglePrimitive?.Dispose();
_trianglePrimitiveTransforms.Dispose();
_trianglePrimitivePerSecondDelta.Dispose();
_constantBuffer?.Dispose();
_uploadBuffer?.Dispose();
_vertexBuffer?.Dispose();
base.Cleanup();
}
void Load(GameObject target)
{
_Dimension = 0;
_Mesh.vertexBufferTarget |= GraphicsBuffer.Target.Raw;
_Mesh.indexBufferTarget |= GraphicsBuffer.Target.Raw;
VertexAttributeDescriptor[] attributes = _Mesh.GetVertexAttributes();
for (int i = 0; i < attributes.Length; i++)
{
_Dimension += attributes[i].dimension;
}
_Count = _Mesh.triangles.Length / 2; // 3 : 1.5 = 2
_Renderer = target.GetComponentInChildren <Renderer>();
if (_VertexBuffer != null)
{
_VertexBuffer.Dispose();
}
_VertexBuffer = _Mesh.GetVertexBuffer(0);
if (_IndexBuffer != null)
{
_IndexBuffer.Dispose();
}
_IndexBuffer = _Mesh.GetIndexBuffer();
}
private void OnDestroy()
{
vertexBuffer?.Dispose();
indexBuffer?.Dispose();
drawArgsBuffer?.Dispose();
instanceMatrixBuffer?.Dispose();
instanceResourcesBuffer?.Dispose();
foreach (var entry in passes)
{
entry.Value.Dispose();
}
passes.Clear();
}
void ReleaseGraphicsBuffer()
{
if (CullingPatchesBuffer != null)
{
CullingPatchesBuffer.Release();
CullingPatchesBuffer.Dispose();
CullingPatchesBuffer = null;
}
if (argBuffer != null)
{
argBuffer.Release();
argBuffer.Dispose();
argBuffer = null;
}
}
void ReleaseGraphicsBuffer()
{
if (PerlinPerm != null)
{
PerlinPerm.Release();
PerlinPerm.Dispose();
PerlinPerm = null;
}
if (PerlinGrad != null)
{
PerlinGrad.Release();
PerlinGrad.Dispose();
PerlinGrad = null;
}
}
void ReleaseGraphicsBuffer()
{
if (perm != null)
{
perm.Release();
perm.Dispose();
perm = null;
}
if (permGrad2 != null)
{
permGrad2.Release();
permGrad2.Dispose();
permGrad2 = null;
}
}
private void OnDestroy()
{
if (m_initialized)
{
m_BatchRendererGroup.RemoveBatch(m_batchID);
if (m_material)
{
m_BatchRendererGroup.UnregisterMaterial(m_materialID);
}
if (m_mesh)
{
m_BatchRendererGroup.UnregisterMesh(m_meshID);
}
m_BatchRendererGroup.Dispose();
m_GPUPersistentInstanceData.Dispose();
m_sysmemBuffer.Dispose();
}
}
internal int FlushInstanceArray()
{
int count = InstanceArray.Count;
if (count > 0)
{
if (InstanceVertexBuffer == null || InstanceVertexBuffer.Size < InstanceArray.Count * InstanceTypeSize)
{
if (InstanceVertexBuffer != null)
{
InstanceVertexBuffer.Dispose();
}
InstanceVertexBuffer = new GraphicsBuffer(count * InstanceTypeSize * 3 / 2, BufferUsage.DynamicDraw);
}
InstanceVertexBuffer.Write(0, InstanceArray.Array, 0, InstanceArray.Count);
ClearInstanceArray();
}
return(count / InstanceVertexElementCount);
}
void Cleanup()
{
isInitialized = false;
vertexBuffers.ForEach(b =>
{
if (b != null)
{
b.Dispose();
}
});
vertexBuffers.Clear();
if (indexBuffer != null)
{
indexBuffer.Dispose();
}
if (indexBufferGraphics != null)
{
indexBufferGraphics.Dispose();
}
}
public void Dispose()
{
perVertexBuffer.Dispose();
perVertexSkinBuffer.Dispose();
perVertexStream.Dispose();
indexBuffer.Dispose();
indexCountBuffer.Dispose();
if (edgeLengthBuffer != null)
{
edgeLengthBuffer.Dispose();
}
if (tensionBuffer != null)
{
tensionBuffer.Dispose();
}
dispatchcer.Dispose();
renderer.Dispose();
}
private void OnDestroy()
{
if (m_initialized)
{
// NOTE: Don't need to remove batch or unregister BatchRendererGroup resources. BRG.Dispose takes care of that.
m_BatchRendererGroup.Dispose();
m_GPUPersistentInstanceData.Dispose();
m_renderers.Dispose();
m_batchHash.Dispose();
m_rangeHash.Dispose();
m_drawBatches.Dispose();
m_drawRanges.Dispose();
m_instances.Dispose();
m_instanceIndices.Dispose();
m_drawIndices.Dispose();
#if UNITY_EDITOR
DestroyImmediate(m_pickingMaterial);
#endif
}
}
private void DisposeBuffers()
{
if (tablesBuffer != null)
{
tablesBuffer.Dispose();
}
if (counterBuffer != null)
{
counterBuffer.Dispose();
}
if (counterCheckBuffer != null)
{
counterCheckBuffer.Dispose();
}
if (vertexBuffer != null)
{
vertexBuffer.Dispose();
}
if (cvmBuffer != null)
{
cvmBuffer.Dispose();
}
}
void ReleaseGraphicsBuffer()
{
if (ConsumeNodeList != null)
{
ConsumeNodeList.Release();
ConsumeNodeList.Dispose();
ConsumeNodeList = null;
}
if (AppendNodeList != null)
{
AppendNodeList.Release();
AppendNodeList.Dispose();
AppendNodeList = null;
}
if (AppendFinalNodeList != null)
{
AppendFinalNodeList.Release();
AppendFinalNodeList.Dispose();
AppendFinalNodeList = null;
}
if (CounterBuffer != null)
{
CounterBuffer.Release();
CounterBuffer.Dispose();
CounterBuffer = null;
}
if (NodeDescriptorBuffer != null)
{
NodeDescriptorBuffer.Release();
NodeDescriptorBuffer.Dispose();
NodeDescriptorBuffer = null;
}
}
private void OnDestroy()
{
_bufferWithArgs?.Dispose();
}
private void OnDestroy()
{
readbackBuffer_.Dispose();
}
// We need to dispose our GraphicsBuffer and BatchRendererGroup when our script is no longer used,
// to avoid leaking anything. Registered Meshes and Materials, and any batches added to the
// BatchRendererGroup are automatically disposed when disposing the BatchRendererGroup.
private void OnDisable()
{
m_InstanceData.Dispose();
m_BRG.Dispose();
}
public void Release()
{
fragmentLinkBuffer?.Dispose();
startOffsetBuffer?.Dispose();
}
