// * Rename to suggest this is a per-frame update, break out the initialization logic
// * APPLICATION BOTTLENECK: focus optimization efforts here!
// Since this is for visuals, could call on a fixed interval, e.g. 1/5 second
public void InitializeRenderBuffers()
{
// * For testing
var cursorCoords = theCursorCzar.GetScaledCursorCoords(360f, -720f);
// Initialize world tree line data
var worldTreeLines = new WorldTreeLineData[worldTreeBufferCount];
worldTreeLineDataCBuffer?.Release();
worldTreeLineDataCBuffer = new ComputeBuffer(worldTreeBufferCount, sizeof(float) * 7);
// Create creature lines
for (int line = 0; line < worldTreeNumCreatureLines; line++)
{
for (int i = 0; i < worldTreeNumPointsPerLine; i++)
{
CreateCreatureLine(line, i, cursorCoords, worldTreeLines);
}
}
// Create species lines (on top)
for (int line = 0; line < worldTreeNumSpeciesLines; line++)
{
for (int i = 0; i < worldTreeNumPointsPerLine; i++)
{
CreateSpeciesLine(line, i, cursorCoords, worldTreeLines);
}
}
worldTreeLineDataCBuffer.SetData(worldTreeLines);
}
private void OnDisable()
{
_sphereBuffer?.Release();
_meshObjectBuffer?.Release();
_vertexBuffer?.Release();
_indexBuffer?.Release();
}
public void ClearBuffers()
{
/*
* if(animalParticlesNearestCritters1 != null) {
* animalParticlesNearestCritters1.Release();
* animalParticlesNearestCritters32.Release();
* animalParticlesNearestCritters1024.Release();
* } */
animalParticlesCBuffer?.Release();
animalParticlesCBufferSwap?.Release();
closestAnimalParticlesDataCBuffer?.Release();
animalParticlesEatAmountsCBuffer?.Release();
animalParticlesMeasure32?.Release();
animalParticlesMeasure1?.Release();
zooplanktonRepresentativeGenomeCBuffer?.Release();
if (critterNearestZooplankton32 != null)
{
critterNearestZooplankton32.Release();
}
closestZooplanktonDistancesCBuffer?.Release();
closestAnimalParticlesDataCBuffer?.Release();
cursorDistances1024?.Release();
cursorClosestParticleDataCBuffer?.Release();
}
private void Update()
{
positionBuffer?.Release();
positionBuffer = new ComputeBuffer(count * count, 4 * 16);
computeShader.SetInt(ResolutionID, count);
computeShader.SetFloat(TimeID, Time.time);
computeShader.SetBuffer(0, PositionID, positionBuffer);
//resolution : 128
//16,384 개의 스레드가 돌아야 함
//커널함수 하나가 8 * 8 = 64 개의 스레드를 갖고 있으니
//16,384 / 64 = 256 개의 그룹을 돌려야 함
//루트256 = 16 이므로 각 그룹은 16이어야 함
//16은 즉 resolution / 8 과 같으므로
//groups = resoltion / 8 임
int groups = Mathf.CeilToInt(count / 8f);
computeShader.Dispatch(0, groups, groups, 1);
material.SetBuffer(PositionID, positionBuffer);
Graphics.DrawMeshInstancedProcedural(
mesh, 0, material, new Bounds(Vector3.zero, Vector3.one), count * count
);
}
private void OnDisable()
{
_planeBuffer?.Release();
_boxBuffer?.Release();
_sphereBuffer?.Release();
_discBuffer?.Release();
_quadBuffer?.Release();
_sizeBuffer?.Release();
}
public void UpdateComputeBufferSize(int newInstanceCount)
{
MergeBuffer?.Release();
MergeBuffer = null;
VisibleBufferLOD0?.Release();
VisibleBufferLOD0 = null;
VisibleBufferLOD1?.Release();
VisibleBufferLOD1 = null;
VisibleBufferLOD2?.Release();
VisibleBufferLOD2 = null;
VisibleBufferLOD3?.Release();
VisibleBufferLOD3 = null;
ShadowBufferLOD0?.Release();
ShadowBufferLOD0 = null;
ShadowBufferLOD1?.Release();
ShadowBufferLOD1 = null;
ShadowBufferLOD2?.Release();
ShadowBufferLOD2 = null;
ShadowBufferLOD3?.Release();
ShadowBufferLOD3 = null;
MergeBuffer = new ComputeBuffer(newInstanceCount, (16 * 4 * 2) + 16, ComputeBufferType.Append);
MergeBuffer.SetCounterValue(0);
VisibleBufferLOD0 = new ComputeBuffer(newInstanceCount, (16 * 4 * 2) + 16, ComputeBufferType.Append);
VisibleBufferLOD0.SetCounterValue(0);
VisibleBufferLOD1 = new ComputeBuffer(newInstanceCount, (16 * 4 * 2) + 16, ComputeBufferType.Append);
VisibleBufferLOD1.SetCounterValue(0);
VisibleBufferLOD2 = new ComputeBuffer(newInstanceCount, (16 * 4 * 2) + 16, ComputeBufferType.Append);
VisibleBufferLOD2.SetCounterValue(0);
VisibleBufferLOD3 = new ComputeBuffer(newInstanceCount, (16 * 4 * 2) + 16, ComputeBufferType.Append);
VisibleBufferLOD3.SetCounterValue(0);
ShadowBufferLOD0 = new ComputeBuffer(newInstanceCount, (16 * 4 * 2) + 16, ComputeBufferType.Append);
ShadowBufferLOD0.SetCounterValue(0);
ShadowBufferLOD1 = new ComputeBuffer(newInstanceCount, (16 * 4 * 2) + 16, ComputeBufferType.Append);
ShadowBufferLOD1.SetCounterValue(0);
ShadowBufferLOD2 = new ComputeBuffer(newInstanceCount, (16 * 4 * 2) + 16, ComputeBufferType.Append);
ShadowBufferLOD2.SetCounterValue(0);
ShadowBufferLOD3 = new ComputeBuffer(newInstanceCount, (16 * 4 * 2) + 16, ComputeBufferType.Append);
ShadowBufferLOD3.SetCounterValue(0);
}
private void VerifyBuffer(int requiredCount)
{
if (buffer == null || requiredCount > buffer.count)
{
buffer?.Release();
var newCount = ((requiredCount + BufferGranularity - 1) / BufferGranularity) * BufferGranularity;
buffer = new ComputeBuffer(newCount, UnsafeUtility.SizeOf <Line>());
lineMaterial.SetBuffer(BufferProperty, buffer);
}
}
void InitializeNeuronFeedDataCBuffer()
{
neuronFeedDataCBuffer?.Release();
neuronFeedDataCBuffer = new ComputeBuffer(numNeurons, sizeof(float) * 1);
NeuronFeedData[] neuronValuesArray = new NeuronFeedData[numNeurons];
for (int i = 0; i < neuronValuesArray.Length; i++)
{
neuronValuesArray[i].curValue = neurons[i].currentValue;
}
neuronFeedDataCBuffer.SetData(neuronValuesArray);
}
private void OnDisable()
{
allInstancesPosWSBuffer?.Release();
allInstancesPosWSBuffer = null;
visibleInstancesOnlyPosWSIDBuffer?.Release();
visibleInstancesOnlyPosWSIDBuffer = null;
argsBuffer?.Release();
argsBuffer = null;
instance = null;
}
private void InitSpheresBuffer()
{
sphereBuffer?.Release();
var spheresInfo = new List <SphereInfo>();
spheres.ForEach(s =>
{
spheresInfo.Add(s.GetSphereInfo());
// s.gameObject.SetActive(false);
});
sphereBuffer = new ComputeBuffer(spheres.Count, 56);
sphereBuffer.SetData(spheresInfo);
}
private void OnDestroy()
{
_nodesBuffer?.Release();
_woopTrisBuffer?.Release();
_triIndicesBuffer?.Release();
_verticesBuffer?.Release();
_normalsBuffer?.Release();
_triIndicesBuffer?.Release();
_trianglesBuffer?.Release();
_materialsBuffer?.Release();
_matIdxBuffer?.Release();
}
private void OnDisable()
{
_SphereBuffer?.Release();
_MeshObjectBuffer?.Release();
_MeshMaterialBuffer?.Release();
_VertexBuffer?.Release();
_IndexBuffer?.Release();
_FrustumBuffer?.Release();
_TriangleBuffer?.Release();
if (_TextureBuffer != null)
{
Destroy(_TextureBuffer);
}
}
private void UpdateShaderParameters()
{
mandelbrotComputeShader.SetFloat(scaleId, scale);
mandelbrotComputeShader.SetVector(lowerLeftId, lowerLeft);
mandelbrotComputeShader.SetInt(maxIterationsId, maxIterations);
mandelbrotComputeShader.SetInt(colorLevelsId, colorLevels);
if (colors.Length != colorsBuffer?.count)
{
colorsBuffer?.Release();
colorsBuffer = new ComputeBuffer(colors.Length, 4 * sizeof(float));
}
colorsBuffer.SetData(colors);
mandelbrotComputeShader.SetBuffer(colourEscapeTimeKernelId, colorsBufferId, colorsBuffer);
}
// For now only one seed data
void InitializeNeuronCBufferData()
{
neuronInitDataCBuffer?.Release();
neuronInitDataCBuffer = new ComputeBuffer(numNeurons, sizeof(float) * 3);
NeuronInitData[] neuronInitDataArray = new NeuronInitData[neurons.Count]; //[numNeurons];
for (int x = 0; x < neuronInitDataArray.Length; x++)
{
NeuronInitData neuronData = new NeuronInitData((float)neurons[x].io / 2.0f);
neuronInitDataArray[x] = neuronData;
}
neuronInitDataCBuffer.SetData(neuronInitDataArray);
}
public override void Cleanup()
{
quadVerticesCBuffer?.Release();
waterCurveVerticesCBuffer?.Release();
waterCurveStrokesCBuffer?.Release();
waterQuadStrokesCBufferLrg?.Release();
waterQuadStrokesCBufferSml?.Release();
waterNutrientsBitsCBuffer?.Release();
waterSurfaceBitsCBuffer?.Release();
waterRipplesCBuffer?.Release();
//waterSurfaceBitsShadowsCBuffer?.Release();
waterDebrisBitsCBuffer?.Release();
waterDebrisBitsShadowsCBuffer?.Release();
waterChains0CBuffer?.Release();
waterChains1CBuffer?.Release();
if (waterSurfaceDataRT0 != null)
{
waterSurfaceDataRT0.Release();
}
if (waterSurfaceDataRT1 != null)
{
waterSurfaceDataRT1.Release();
}
}
void OnDestroy()
{
m_argsBuffer?.Release();
m_boxDataBuffer?.Release();
m_normalsBuffer?.Release();
m_positionsBuffer?.Release();
}
public void Release()
{
meshPropertiesBuffer?.Release();
meshPropertiesBuffer = null;
argsBuffer?.Release();
argsBuffer = null;
}
private void RunBufferCleanUp()
{
empty.Release();
m_topLevelAcc.Release();
m_topLevelAccGeoMap.Release();
m_primitiveBuffer.Release();
m_worldToPrimitiveBuffer.Release();
foreach (var item in m_gemoetryInstanceBuffer)
{
item.Value?.Release();
}
m_gemoetryInstanceBuffer.Clear();
foreach (var item in m_objectLevelAccGeoBuffers)
{
item.Value?.Release();
}
m_objectLevelAccGeoBuffers.Clear();
foreach (var item in m_objectLevelAccGeoMapBuffers)
{
item.Value?.Release();
}
m_objectLevelAccGeoMapBuffers.Clear();
m_lightInfoBuffer?.Release();
foreach (var materialBuffers in computeBufferForMaterials)
{
materialBuffers.Release();
}
computeBufferForMaterials.Clear();
}
//Setup all buffers and variables
private void Update()
{
//Recreate the buffer
bufferElements.Clear();
foreach (Building building in buildings)
{
BuildingBufferElement element = new BuildingBufferElement
{
PositionX = building.transform.position.x,
PositionY = building.transform.position.z,
Range = building.Range,
Heat = building.Heat
};
bufferElements.Add(element);
}
buffer?.Release();
buffer = new ComputeBuffer(bufferElements.Count * 4, sizeof(float));
//Set the buffer data and parse it to the compute shader
buffer.SetData(bufferElements);
computeShader.SetBuffer(0, buildingBufferId, buffer);
//Set other variables needed in the compute function
computeShader.SetInt(buildingCountId, bufferElements.Count);
//Execute the compute shader
//Our thread group size is 8x8=64,
//thus we have to dispatch (TextureSize / 8) * (TextureSize / 8) thread groups
computeShader.Dispatch(0, Mathf.CeilToInt(TextureSize / 8.0f), Mathf.CeilToInt(TextureSize / 8.0f), 1);
}
void OnDestroy()
{
m_vectorFieldBuffer?.Release();
m_positionBuffer?.Release();
m_normalBuffer?.Release();
m_boidsDataBuffer?.Release();
}
protected void EraseGpu()
{
dataBuffer?.Release();
shapeBuffer?.Release();
stridesBuffer?.Release();
dataOnGpu = false;
}
public void ReleaseBuffers()
{
_featurePointBuffer?.Release();
_quadsBuffer?.Release();
_indicesBuffer?.Release();
_verticesArgumentBuffer?.Release();
}
void CreateOrResizeVtxBuffer(ref ComputeBuffer buffer, int count)
{
int num = ((count - 1) / 256 + 1) * 256;
buffer?.Release();
buffer = new ComputeBuffer(num, UnsafeUtility.SizeOf <ImDrawVert>());
}
private void OnDisable()
{
sphereBuffer?.Release();
meshObjectBuffer?.Release();
vertexBuffer?.Release();
indexBuffer?.Release();
}
void ReleaseBuffers()
{
entityMeshPropertiesBuffer?.Release();
entityMeshPropertiesBuffer = null;
entityArgsBuffer?.Release();
entityArgsBuffer = null;
}
protected override void Deinitialize()
{
Active.ForEach(req =>
{
req.TextureSet.Release();
});
foreach (var tex in AvailableRenderTextures)
{
tex.Release();
}
foreach (var tex in AvailableTextures)
{
DestroyImmediate(tex);
}
PointCloudBuffer?.Release();
CosLatitudeAnglesBuffer?.Release();
SinLatitudeAnglesBuffer?.Release();
if (PointCloudMaterial != null)
{
DestroyImmediate(PointCloudMaterial);
}
}
void CreateOrResizeArgBuffer(ref ComputeBuffer buffer, int count)
{
int num = ((count - 1) / 256 + 1) * 256;
buffer?.Release();
buffer = new ComputeBuffer(num, UnsafeUtility.SizeOf <int>(), ComputeBufferType.IndirectArguments);
}
private void ClearEverything()
{
_snapshotBuffer?.Release();
_vertexBuffer?.Release();
_fillArgsBuffer?.Release();
_lineArgsBuffer?.Release();
_latestVerticesBuffer?.Release();
if (_lineMat != null)
{
Destroy(_lineMat);
}
if (_fillMat != null)
{
Destroy(_fillMat);
}
if (_snapshotCompute != null)
{
Destroy(_snapshotCompute);
}
if (_vertexCompute != null)
{
Destroy(_vertexCompute);
}
}
public virtual void OnDestroy()
{
Active.ForEach(req =>
{
req.TextureSet.Release();
});
foreach (var tex in AvailableRenderTextures)
{
tex.Release();
}
foreach (var tex in AvailableTextures)
{
DestroyImmediate(tex);
}
PointCloudBuffer?.Release();
CosLatitudeAnglesBuffer?.Release();
SinLatitudeAnglesBuffer?.Release();
if (PointCloudMaterial != null)
{
DestroyImmediate(PointCloudMaterial);
}
}
private void UpdateLightBuffer(CullingResults cullingResults)
{
_LightBuffer?.Release();
_LightBuffer = new ComputeBuffer(maxLightCount, System.Runtime.InteropServices.Marshal.SizeOf <LightSource>());
List <LightSource> lightPosRadius = new List <LightSource>();
for (int i = 0; i < cullingResults.visibleLights.Length; ++i)
{
var light = cullingResults.visibleLights[i];
if (light.light.enabled == true)
{
LightSource l = new LightSource();
l.position = new Vector3(light.light.transform.position.x, light.light.transform.position.y,
light.light.transform.position.z);
if (light.lightType == LightType.Directional || light.lightType == LightType.Spot)
{
l.direction = light.light.transform.forward;
l.direction = light.light.transform.localToWorldMatrix.GetColumn(2);
}
l.color = light.finalColor;
if (light.lightType == LightType.Spot)
{
l.spotAngle = light.spotAngle;
}
l.range = light.range;
l.type = (uint)light.lightType;
lightPosRadius.Add(l);
}
}
_LightBuffer.SetData(lightPosRadius);
_lightCount = lightPosRadius.Count;
}
