public void DrawTerrain(ref RenderClusterOptions ops, Material terrainMat, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer)
{
if (referenceBuffer.Length <= 0)
{
return;
}
ComputeShader sh = ops.terrainCompute;
CommandBuffer bf = ops.command;
bf.SetComputeBufferParam(sh, frustumCullKernel, ShaderIDs.clusterBuffer, clusterBuffer);
bf.SetComputeBufferParam(sh, frustumCullKernel, ShaderIDs.resultBuffer, resultBuffer);
bf.SetComputeBufferParam(sh, frustumCullKernel, ShaderIDs.instanceCountBuffer, instanceCountBuffer);
bf.SetComputeBufferParam(sh, clearCullKernel, ShaderIDs.instanceCountBuffer, instanceCountBuffer);
bf.SetComputeVectorArrayParam(sh, ShaderIDs.planes, ops.frustumPlanes);
bf.SetComputeIntParam(sh, ShaderIDs._CullingPlaneCount, ops.isOrtho ? 6 : 5);
bf.SetGlobalInt(ShaderIDs._MeshSize, meshSize);
bf.DispatchCompute(sh, clearCullKernel, 1, 1, 1);
ComputeShaderUtility.Dispatch(sh, bf, frustumCullKernel, referenceBuffer.Length, 64);
bf.SetGlobalBuffer(ShaderIDs.heightMapBuffer, heightMapBuffer);
bf.SetGlobalBuffer(ShaderIDs.triangleBuffer, triangleBuffer);
bf.SetGlobalBuffer(ShaderIDs.verticesBuffer, verticesBuffer);
bf.SetGlobalBuffer(ShaderIDs.clusterBuffer, clusterBuffer);
bf.SetGlobalBuffer(ShaderIDs.resultBuffer, resultBuffer);
bf.SetRenderTarget(colorBuffer, depthBuffer);
bf.DrawProceduralIndirect(Matrix4x4.identity, terrainMat, 0, MeshTopology.Triangles, instanceCountBuffer);
}
public void DeleteRun()
{
PipelineResources resources = RenderPipeline.current.resources;
PipelineBaseBuffer baseBuffer = SceneController.baseBuffer;
int result = baseBuffer.clusterCount - property.clusterCount;
ComputeShader shader = resources.shaders.streamingShader;
if (result > 0)
{
NativeArray <int> indirectArgs = new NativeArray <int>(5, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
indirectArgs[0] = 0;
indirectArgs[1] = 1;
indirectArgs[2] = 1;
indirectArgs[3] = result;
indirectArgs[4] = propertyCount;
baseBuffer.moveCountBuffer.SetData(indirectArgs);
ComputeBuffer indexBuffer = SceneController.GetTempPropertyBuffer(property.clusterCount, 8);
indirectArgs.Dispose();
shader.SetBuffer(0, ShaderIDs.instanceCountBuffer, baseBuffer.moveCountBuffer);
shader.SetBuffer(0, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
shader.SetBuffer(0, ShaderIDs._IndexBuffer, indexBuffer);
shader.SetBuffer(1, ShaderIDs._IndexBuffer, indexBuffer);
shader.SetBuffer(1, ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
ComputeShaderUtility.Dispatch(shader, 0, result);
shader.DispatchIndirect(1, baseBuffer.moveCountBuffer);
}
baseBuffer.clusterCount = result;
loading = false;
state = State.Unloaded;
}
public static void MoveEachScenes(NativeList <MoveCommand> allCommands)
{
int maximumClusterCount = 0;
if (allCommands.Length > 0)
{
maximumClusterCount = allCommands[0].clusterCount;
for (int i = 1; i < allCommands.Length; ++i)
{
maximumClusterCount = max(maximumClusterCount, allCommands[i].clusterCount);
}
}
ComputeShader shad = resources.shaders.streamingShader;
ComputeBuffer tempBuffer = GetTempPropertyBuffer(maximumClusterCount + 1, sizeof(uint));
CommandBuffer cb = RenderPipeline.BeforeFrameBuffer;
cb.SetComputeBufferParam(shad, CLEAR_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
cb.SetComputeBufferParam(shad, COLLECT_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
cb.SetComputeBufferParam(shad, COLLECT_KERNEL, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
cb.SetComputeBufferParam(shad, EXECUTE_CLUSTER_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
cb.SetComputeBufferParam(shad, EXECUTE_CLUSTER_KERNEL, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
cb.SetComputeBufferParam(shad, EXECUTE_POINT_KERNEL, ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
cb.SetComputeBufferParam(shad, EXECUTE_POINT_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
foreach (var i in allCommands)
{
cb.SetComputeIntParam(shad, ShaderIDs._TargetElement, i.sceneIndex);
cb.SetComputeVectorParam(shad, ShaderIDs._OffsetDirection, float4(i.deltaPosition, 1));
cb.DispatchCompute(shad, CLEAR_KERNEL, 1, 1, 1);
ComputeShaderUtility.Dispatch(shad, cb, COLLECT_KERNEL, baseBuffer.clusterCount);
ComputeShaderUtility.Dispatch(shad, cb, EXECUTE_CLUSTER_KERNEL, i.clusterCount);
cb.DispatchCompute(shad, EXECUTE_POINT_KERNEL, i.clusterCount, 1, 1);
}
}
private bool DeleteRun(ref PipelineBaseBuffer baseBuffer, PipelineResources resources)
{
int targetCount = currentCount + MAXIMUMINTCOUNT;
if (targetCount >= resultLength)
{
if (resultLength > 0)
{
indexBuffer.SetData(results, currentCount, currentCount, resultLength - currentCount);
ComputeShader shader = resources.streamingShader;
shader.SetBuffer(0, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
shader.SetBuffer(1, ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
shader.SetBuffer(0, ShaderIDs._IndexBuffer, indexBuffer);
shader.SetBuffer(1, ShaderIDs._IndexBuffer, indexBuffer);
ComputeShaderUtility.Dispatch(shader, 0, resultLength, 256);
shader.Dispatch(1, resultLength, 1, 1);
}
baseBuffer.clusterCount -= indicesBuffer.Length;
indexBuffer.Dispose();
results.Dispose();
indicesBuffer.Dispose();
loading = false;
state = State.Unloaded;
return(true);
}
else
{
indexBuffer.SetData(results, currentCount, currentCount, MAXIMUMINTCOUNT);
currentCount = targetCount;
return(false);
}
}
public static void PrepareDispatch(ref CubeCullingBuffer buffer, CommandBuffer cb, ComputeShader shader, NativeArray <Vector4> positions)
{
int targetLength = positions.Length;
buffer.lightPositionBuffer.SetData(positions);
ComputeShaderUtility.Dispatch(shader, cb, ClearCluster, targetLength, 256);
ComputeShaderUtility.Dispatch(shader, cb, GetFrustumPlane, targetLength, 16);
}
public static void TransformMapPosition(int startPos)
{
if (baseBuffer.clusterCount - startPos <= 0) return;
resources.shaders.gpuFrustumCulling.SetInt(ShaderIDs._OffsetIndex, startPos);
resources.shaders.gpuFrustumCulling.SetBuffer(PipelineBaseBuffer.MoveVertex, ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
resources.shaders.gpuFrustumCulling.SetBuffer(PipelineBaseBuffer.MoveCluster, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
resources.shaders.gpuFrustumCulling.Dispatch(PipelineBaseBuffer.MoveVertex, baseBuffer.clusterCount - startPos, 1, 1);
ComputeShaderUtility.Dispatch(resources.shaders.gpuFrustumCulling, PipelineBaseBuffer.MoveCluster, baseBuffer.clusterCount - startPos, 64);
}
public void Drawer(CommandBuffer cb, Material mat, Vector4[] frustumPlanes)
{
cb.SetComputeVectorArrayParam(shader, ShaderIDs.planes, frustumPlanes);
cb.SetComputeBufferParam(shader, cull_Kernel, ShaderIDs.instanceCountBuffer, instanceCountBuffer);
cb.SetComputeBufferParam(shader, clear_Kernel, ShaderIDs.instanceCountBuffer, instanceCountBuffer);
cb.SetComputeBufferParam(shader, cull_Kernel, ShaderIDs.clusterBuffer, clusterBuffer);
cb.SetComputeBufferParam(shader, cull_Kernel, ShaderIDs.resultBuffer, resultBuffer);
cb.DispatchCompute(shader, clear_Kernel, 1, 1, 1);
ComputeShaderUtility.Dispatch(shader, cb, cull_Kernel, clusterBuffer.count, 64);
cb.SetGlobalBuffer(ShaderIDs.clusterBuffer, clusterBuffer);
cb.SetGlobalBuffer(ShaderIDs.resultBuffer, resultBuffer);
cb.SetGlobalBuffer(ShaderIDs.verticesBuffer, verticesBuffer);
cb.DrawProceduralIndirect(Matrix4x4.identity, mat, 0, MeshTopology.Triangles, instanceCountBuffer);
}
private void CoeffToRenderTexture(CommandBuffer buffer)
{
ComputeShader shader = pipelineRes.shaders.probeCoeffShader;
buffer.SetComputeBufferParam(shader, coeffToTex3DKernel, ShaderIDs._Coeff, coeff);
buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[0], currentTexture.coeff0);
buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[1], currentTexture.coeff1);
buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[2], currentTexture.coeff2);
buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[3], currentTexture.coeff3);
buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[4], currentTexture.coeff4);
buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[5], currentTexture.coeff5);
buffer.SetComputeTextureParam(shader, coeffToTex3DKernel, _CoeffIDs[6], currentTexture.coeff6);
buffer.SetComputeVectorParam(shader, ShaderIDs._Tex3DSize, new float4(currentIrr.resolution.x, currentIrr.resolution.y, currentIrr.resolution.z, 1));
ComputeShaderUtility.Dispatch(shader, buffer, coeffToTex3DKernel, len / 9, 64);
}
public static void UpdateData(ref CubeCullingBuffer buffer, PipelineBaseBuffer baseBuffer, ComputeShader shader, CommandBuffer cb, NativeArray <Vector4> positions)
{
cb.SetComputeBufferParam(shader, ClearCluster, ShaderIDs.instanceCountBuffer, buffer.indirectDrawBuffer);
cb.SetComputeBufferParam(shader, RunFrustumCull, ShaderIDs.instanceCountBuffer, buffer.indirectDrawBuffer);
cb.SetComputeBufferParam(shader, RunFrustumCull, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
cb.SetComputeBufferParam(shader, RunFrustumCull, ShaderIDs.resultBuffer, baseBuffer.resultBuffer);
cb.SetComputeBufferParam(shader, RunFrustumCull, ShaderIDs.planes, buffer.planes);
cb.SetComputeBufferParam(shader, GetFrustumPlane, ShaderIDs.planes, buffer.planes);
cb.SetComputeBufferParam(shader, GetFrustumPlane, ShaderIDs.lightPositionBuffer, buffer.lightPositionBuffer);
int targetLength = positions.Length;
buffer.lightPositionBuffer.SetData(positions);
ComputeShaderUtility.Dispatch(shader, cb, ClearCluster, targetLength, 256);
ComputeShaderUtility.Dispatch(shader, cb, GetFrustumPlane, targetLength, 16);
}
public static void MoveAllScenes(float3 delta, int offset, int clusterCount)
{
if (clusterCount <= 0)
{
return;
}
ComputeShader shad = resources.shaders.streamingShader;
CommandBuffer cb = RenderPipeline.BeforeFrameBuffer;
cb.SetComputeIntParam(shad, ShaderIDs._Offset, offset);
cb.SetComputeBufferParam(shad, EXECUTE_CLUSTER_KERNEL_MOVE_ALL, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
cb.SetComputeBufferParam(shad, EXECUTE_POINT_KERNEL_MOVE_ALL, ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
cb.SetComputeVectorParam(shad, ShaderIDs._OffsetDirection, float4(delta, 1));
ComputeShaderUtility.Dispatch(shad, cb, EXECUTE_CLUSTER_KERNEL_MOVE_ALL, clusterCount);
cb.DispatchCompute(shad, EXECUTE_POINT_KERNEL_MOVE_ALL, clusterCount, 1, 1);
}
public override void FinishJob()
{
CommandBuffer buffer = RenderPipeline.BeforeFrameBuffer;
ComputeBuffer temp = currentPosBuffer;
currentPosBuffer = lastPosBuffer;
lastPosBuffer = temp;
buffer.SetComputeBufferParam(movingShader, 0, ShaderIDs._TransformMatrices, currentPosBuffer);
buffer.SetComputeBufferParam(movingShader, 0, ShaderIDs._OriginTransformMatrices, originPosBuffer);
buffer.SetComputeTextureParam(movingShader, 0, ShaderIDs._NoiseTexture, noiseTexture);
buffer.SetComputeVectorParam(movingShader, ShaderIDs._OffsetDirection, transform.forward);
offset += Time.deltaTime * runSpeed;
offset = frac(offset);
buffer.SetComputeFloatParam(movingShader, ShaderIDs._Offset, offset * noiseTexture.height);
buffer.SetComputeVectorParam(movingShader, ShaderIDs._NoiseTexture_Size, new Vector2(noiseTexture.width, noiseTexture.height));
ComputeShaderUtility.Dispatch(movingShader, buffer, 0, currentPosBuffer.count);
}
public void DrawTerrain(CommandBuffer buffer, int pass, Vector4[] planes)
{
if (loadedBufferList.Length <= 0)
{
return;
}
buffer.SetComputeBufferParam(shader, 1, ShaderIDs._DispatchBuffer, dispatchDrawBuffer);
buffer.SetComputeBufferParam(shader, 0, ShaderIDs._DispatchBuffer, dispatchDrawBuffer);
buffer.SetComputeBufferParam(shader, 0, ShaderIDs._CullResultBuffer, culledResultsBuffer);
buffer.SetComputeBufferParam(shader, 0, ShaderIDs._TerrainChunks, loadedBuffer);
buffer.SetGlobalBuffer(ShaderIDs._TerrainChunks, loadedBuffer);
buffer.SetGlobalVector(ShaderIDs._HeightScaleOffset, float4(terrainData.heightScale, terrainData.heightOffset, 1, 1));
buffer.SetGlobalBuffer(ShaderIDs._CullResultBuffer, culledResultsBuffer);
buffer.SetComputeVectorArrayParam(shader, ShaderIDs.planes, planes);
buffer.DispatchCompute(shader, 1, 1, 1, 1);
ComputeShaderUtility.Dispatch(shader, buffer, 0, loadedBufferList.Length);
buffer.DrawProceduralIndirect(Matrix4x4.identity, terrainData.drawTerrainMaterial, pass, MeshTopology.Triangles, dispatchDrawBuffer);
}
public static void MoveScene(int sceneIndex, float3 deltaPosition, int clusterCount)
{
ComputeShader shad = resources.shaders.streamingShader;
ComputeBuffer tempBuffer = GetTempPropertyBuffer(clusterCount + 1, sizeof(uint));
CommandBuffer cb = RenderPipeline.BeforeFrameBuffer;
cb.SetComputeIntParam(shad, ShaderIDs._TargetElement, sceneIndex);
cb.SetComputeBufferParam(shad, CLEAR_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
cb.SetComputeBufferParam(shad, COLLECT_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
cb.SetComputeBufferParam(shad, COLLECT_KERNEL, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
cb.SetComputeBufferParam(shad, EXECUTE_CLUSTER_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
cb.SetComputeBufferParam(shad, EXECUTE_CLUSTER_KERNEL, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
cb.SetComputeBufferParam(shad, EXECUTE_POINT_KERNEL, ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
cb.SetComputeBufferParam(shad, EXECUTE_POINT_KERNEL, ShaderIDs._TempPropBuffer, tempBuffer);
cb.SetComputeVectorParam(shad, ShaderIDs._OffsetDirection, float4(deltaPosition, 1));
cb.DispatchCompute(shad, CLEAR_KERNEL, 1, 1, 1);
ComputeShaderUtility.Dispatch(shad, cb, COLLECT_KERNEL, baseBuffer.clusterCount);
ComputeShaderUtility.Dispatch(shad, cb, EXECUTE_CLUSTER_KERNEL, clusterCount);
cb.DispatchCompute(shad, EXECUTE_POINT_KERNEL, clusterCount, 1, 1);
}
public override void DrawClusterOccSingleCheck(ref RenderClusterOptions options, ref HizOptions hizOpts)
{
CommandBuffer buffer = options.command;
buffer.SetComputeVectorParam(options.cullingShader, ShaderIDs._CameraUpVector, hizOpts.hizData.lastFrameCameraUp);
buffer.SetComputeBufferParam(options.cullingShader, 5, ShaderIDs.clusterBuffer, baseBuffer.clusterBuffer);
buffer.SetComputeTextureParam(options.cullingShader, 5, ShaderIDs._HizDepthTex, hizOpts.hizData.historyDepth);
buffer.SetComputeVectorArrayParam(options.cullingShader, ShaderIDs.planes, options.frustumPlanes);
buffer.SetComputeBufferParam(options.cullingShader, 5, ShaderIDs.resultBuffer, baseBuffer.resultBuffer);
buffer.SetComputeBufferParam(options.cullingShader, 5, ShaderIDs.instanceCountBuffer, baseBuffer.instanceCountBuffer);
buffer.SetComputeBufferParam(options.cullingShader, PipelineBaseBuffer.ComputeShaderKernels.ClearClusterKernel, ShaderIDs.instanceCountBuffer, baseBuffer.instanceCountBuffer);
ComputeShaderUtility.Dispatch(options.cullingShader, options.command, 5, baseBuffer.clusterCount, 256);
hizOpts.hizData.lastFrameCameraUp = hizOpts.currentCameraUpVec;
buffer.SetGlobalBuffer(ShaderIDs.resultBuffer, baseBuffer.resultBuffer);
buffer.SetGlobalBuffer(ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
PipelineFunctions.RenderProceduralCommand(baseBuffer, options.proceduralMaterial, buffer);
buffer.DispatchCompute(options.cullingShader, PipelineBaseBuffer.ComputeShaderKernels.ClearClusterKernel, 1, 1, 1);
//TODO 绘制其他物体
//TODO
buffer.Blit(hizOpts.currentDepthTex, hizOpts.hizData.historyDepth, hizOpts.linearLODMaterial, 0);
hizOpts.hizDepth.GetMipMap(hizOpts.hizData.historyDepth, buffer);
}
public override void DrawCubeMap(MPointLight lit, ref RenderClusterOptions opts, ref CubeCullingBuffer buffer, int offset)
{
CommandBuffer cb = opts.command;
ComputeShader shader = opts.cullingShader;
Material depthMaterial = opts.proceduralMaterial;
cb.SetComputeIntParam(shader, ShaderIDs._LightOffset, offset);
ComputeShaderUtility.Dispatch(shader, cb, CubeFunction.RunFrustumCull, baseBuffer.clusterCount, 256);
PerspCam cam = new PerspCam();
cam.aspect = 1;
cam.farClipPlane = lit.range;
cam.nearClipPlane = 0.3f;
cam.position = lit.position;
cam.fov = 90f;
Matrix4x4 vpMatrix;
cb.SetGlobalVector(ShaderIDs._LightPos, new Vector4(lit.position.x, lit.position.y, lit.position.z, lit.range));
cb.SetGlobalBuffer(ShaderIDs.verticesBuffer, baseBuffer.verticesBuffer);
cb.SetGlobalBuffer(ShaderIDs.resultBuffer, baseBuffer.resultBuffer);
//Forward
cam.forward = Vector3.forward;
cam.up = Vector3.down;
cam.right = Vector3.left;
cam.position = lit.position;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeZ);
cb.ClearRenderTarget(true, true, Color.white);
cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
offset = offset * 20;
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
//Back
cam.forward = Vector3.back;
cam.up = Vector3.down;
cam.right = Vector3.right;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveZ);
cb.ClearRenderTarget(true, true, Color.white);
cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
//Up
cam.forward = Vector3.up;
cam.up = Vector3.back;
cam.right = Vector3.right;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveY);
cb.ClearRenderTarget(true, true, Color.white);
cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
//Down
cam.forward = Vector3.down;
cam.up = Vector3.forward;
cam.right = Vector3.right;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeY);
cb.ClearRenderTarget(true, true, Color.white);
cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
//Right
cam.forward = Vector3.right;
cam.up = Vector3.down;
cam.right = Vector3.forward;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveX);
cb.ClearRenderTarget(true, true, Color.white);
cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
//Left
cam.forward = Vector3.left;
cam.up = Vector3.down;
cam.right = Vector3.back;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeX);
cb.ClearRenderTarget(true, true, Color.white);
cb.SetGlobalMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset);
}
public void RemoveQuadTrees(NativeList <ulong> removeList)
{
void ErasePoint(TerrainQuadTree.QuadTreeNode *node)
{
node->listPosition = -1;
notUsedHeightmapIndices.Add(node->panel.heightMapIndex);
}
int length = removeList.Length;
TerrainQuadTree.QuadTreeNode **tree = (TerrainQuadTree.QuadTreeNode * *)removeList.unsafePtr;
int targetLength = referenceBuffer.Length - length;
int len = 0;
if (targetLength <= 0)
{
for (int i = 0; i < length; ++i)
{
ErasePoint(tree[i]);
}
referenceBuffer.Clear();
return;
}
for (int i = 0; i < length; ++i)
{
TerrainQuadTree.QuadTreeNode *currentNode = tree[i];
if (currentNode->listPosition >= targetLength)
{
referenceBuffer[currentNode->listPosition] = 0;
ErasePoint(currentNode);
}
}
NativeArray <int2> transformList = new NativeArray <int2>(length, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
int2 *transformPtr = transformList.Ptr();
len = 0;
int currentIndex = referenceBuffer.Length - 1;
for (int i = 0; i < length; ++i)
{
TerrainQuadTree.QuadTreeNode *treeNode = tree[i];
if (treeNode->listPosition < 0)
{
continue;
}
while (referenceBuffer[currentIndex] == 0)
{
currentIndex--;
if (currentIndex < 0)
{
goto FINALIZE;
}
}
TerrainQuadTree.QuadTreeNode *lastNode = (TerrainQuadTree.QuadTreeNode *)referenceBuffer[currentIndex];
currentIndex--;
transformPtr[len] = new int2(treeNode->listPosition, lastNode->listPosition);
len++;
lastNode->listPosition = treeNode->listPosition;
referenceBuffer[lastNode->listPosition] = (ulong)lastNode;
ErasePoint(treeNode);
}
FINALIZE:
referenceBuffer.RemoveLast(length);
if (len <= 0)
{
return;
}
if (len > removebuffer.count)
{
removebuffer.Dispose();
removebuffer = new ComputeBuffer(len, sizeof(int2));
}
removebuffer.SetData(transformList, 0, 0, len);
transformShader.SetBuffer(0, ShaderIDs._IndexBuffer, removebuffer);
transformShader.SetBuffer(0, ShaderIDs.clusterBuffer, clusterBuffer);
ComputeShaderUtility.Dispatch(transformShader, 0, len, 64);
transformList.Dispose();
}
public static void DrawShadow(MPointLight lit, CommandBuffer cb, MaterialPropertyBlock block, ref CubeCullingBuffer buffer, ref PipelineBaseBuffer baseBuffer, ComputeShader shader, int offset, Material depthMaterial)
{
cb.SetComputeIntParam(shader, ShaderIDs._LightOffset, offset);
ComputeShaderUtility.Dispatch(shader, cb, RunFrustumCull, baseBuffer.clusterCount, 64);
PerspCam cam = new PerspCam();
cam.aspect = 1;
cam.farClipPlane = lit.range;
cam.nearClipPlane = 0.3f;
cam.position = lit.position;
cam.fov = 90f;
Matrix4x4 vpMatrix;
block.SetVector(ShaderIDs._LightPos, new Vector4(lit.position.x, lit.position.y, lit.position.z, lit.range));
PipelineFunctions.SetShaderBuffer(ref baseBuffer, block);
//Forward
cam.forward = Vector3.forward;
cam.up = Vector3.down;
cam.right = Vector3.left;
cam.position = lit.position;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeZ);
cb.ClearRenderTarget(true, true, Color.white);
block.SetMatrix(ShaderIDs._VP, vpMatrix);
offset = offset * 20;
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
//Back
cam.forward = Vector3.back;
cam.up = Vector3.down;
cam.right = Vector3.right;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveZ);
cb.ClearRenderTarget(true, true, Color.white);
block.SetMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
//Up
cam.forward = Vector3.up;
cam.up = Vector3.back;
cam.right = Vector3.right;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveY);
cb.ClearRenderTarget(true, true, Color.white);
block.SetMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
//Down
cam.forward = Vector3.down;
cam.up = Vector3.forward;
cam.right = Vector3.right;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeY);
cb.ClearRenderTarget(true, true, Color.white);
block.SetMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
//Right
cam.forward = Vector3.right;
cam.up = Vector3.down;
cam.right = Vector3.forward;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.PositiveX);
cb.ClearRenderTarget(true, true, Color.white);
block.SetMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
//Left
cam.forward = Vector3.left;
cam.up = Vector3.down;
cam.right = Vector3.back;
cam.UpdateTRSMatrix();
cam.UpdateProjectionMatrix();
vpMatrix = GL.GetGPUProjectionMatrix(cam.projectionMatrix, true) * cam.worldToCameraMatrix;
cb.SetRenderTarget(lit.shadowmapTexture, 0, CubemapFace.NegativeX);
cb.ClearRenderTarget(true, true, Color.white);
block.SetMatrix(ShaderIDs._VP, vpMatrix);
cb.DrawProceduralIndirect(Matrix4x4.identity, depthMaterial, 0, MeshTopology.Triangles, buffer.indirectDrawBuffer, offset, block);
}
