public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data)
{
CommandBuffer buffer = data.buffer;
RenderClusterOptions options = new RenderClusterOptions
{
command = buffer,
frustumPlanes = proper.frustumPlanes,
cullingShader = data.resources.shaders.gpuFrustumCulling,
terrainCompute = data.resources.shaders.terrainCompute
};
FilteringSettings alphaTestFilter = new FilteringSettings
{
layerMask = cam.cam.cullingMask,
renderingLayerMask = 1,
renderQueueRange = new RenderQueueRange(2450, 2499)
};
FilteringSettings opaqueFilter = new FilteringSettings
{
layerMask = cam.cam.cullingMask,
renderingLayerMask = 1,
renderQueueRange = new RenderQueueRange(2000, 2449)
};
FilteringSettings mvFilter = new FilteringSettings
{
layerMask = cam.cam.cullingMask,
renderingLayerMask = 1,
renderQueueRange = RenderQueueRange.opaque
};
DrawingSettings depthPrePassDrawSettings = new DrawingSettings(new ShaderTagId("Depth"), new SortingSettings(cam.cam)
{
criteria = SortingCriteria.QuantizedFrontToBack
})
{
perObjectData = UnityEngine.Rendering.PerObjectData.None,
enableDynamicBatching = false,
enableInstancing = false
};
DrawingSettings drawSettings = new DrawingSettings(new ShaderTagId("GBuffer"), new SortingSettings(cam.cam)
{
criteria = SortingCriteria.CommonOpaque
})
{
perObjectData = UnityEngine.Rendering.PerObjectData.Lightmaps,
enableDynamicBatching = false,
enableInstancing = false
};
DrawingSettings mvDraw = new DrawingSettings(new ShaderTagId("MotionVector"), new SortingSettings {
criteria = SortingCriteria.None
})
{
perObjectData = UnityEngine.Rendering.PerObjectData.None,
enableDynamicBatching = false,
enableInstancing = false
};
data.buffer.SetRenderTarget(colors: cam.targets.gbufferIdentifier, depth: ShaderIDs._DepthBufferTexture);
data.buffer.ClearRenderTarget(true, true, Color.black);
HizOcclusionData hizOccData;
if (useHiZ)
{
hizOccData = IPerCameraData.GetProperty(cam, () => new HizOcclusionData());
SceneController.DrawCluster_LastFrameDepthHiZ(ref options, hizOccData, clusterMat, cam);
}
SceneController.RenderScene(ref data, ref opaqueFilter, ref drawSettings, ref proper.cullResults);
if (useHiZ)
{
SceneController.DrawCluster_RecheckHiz(ref options, ref hizDepth, hizOccData, clusterMat, linearMat, cam);
}
data.buffer.SetRenderTarget(ShaderIDs._DepthBufferTexture);
SceneController.RenderScene(ref data, ref alphaTestFilter, ref depthPrePassDrawSettings, ref proper.cullResults);
data.buffer.SetRenderTarget(colors: cam.targets.gbufferIdentifier, depth: ShaderIDs._DepthBufferTexture);
SortingSettings st = drawSettings.sortingSettings;
st.criteria = SortingCriteria.SortingLayer | SortingCriteria.RenderQueue;
drawSettings.sortingSettings = st;
SceneController.RenderScene(ref data, ref alphaTestFilter, ref drawSettings, ref proper.cullResults);
data.buffer.Blit(ShaderIDs._DepthBufferTexture, ShaderIDs._CameraDepthTexture);
data.buffer.SetRenderTarget(color: ShaderIDs._CameraMotionVectorsTexture, depth: ShaderIDs._DepthBufferTexture);
SceneController.RenderScene(ref data, ref mvFilter, ref mvDraw, ref proper.cullResults);
data.buffer.DrawMesh(GraphicsUtility.mesh, Matrix4x4.identity, motionVecMat, 0, 0);
decal.FrameUpdate(cam, ref data);
//Generate DownSampled GBuffer
if ((ao != null && ao.Enabled) || (reflection != null && reflection.Enabled && reflection.ssrEvents.enabled))
{
int2 res = int2(cam.cam.pixelWidth, cam.cam.pixelHeight) / 2;
data.buffer.GetTemporaryRT(ShaderIDs._DownSampledGBuffer1, res.x, res.y, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear, 1, false);
data.buffer.GetTemporaryRT(ShaderIDs._DownSampledGBuffer2, res.x, res.y, 0, FilterMode.Point, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear, 1, false);
data.buffer.GetTemporaryRT(ShaderIDs._DownSampledDepthTexture, res.x, res.y, 0, FilterMode.Point, RenderTextureFormat.RHalf, RenderTextureReadWrite.Linear, 1, false);
downSampledGBuffers[0] = ShaderIDs._DownSampledDepthTexture;
downSampledGBuffers[1] = ShaderIDs._DownSampledGBuffer1;
downSampledGBuffers[2] = ShaderIDs._DownSampledGBuffer2;
data.buffer.SetRenderTarget(colors: downSampledGBuffers, depth: downSampledGBuffers[0]);
data.buffer.DrawMesh(GraphicsUtility.mesh, Matrix4x4.identity, downSampleMat, 0, 0);
RenderPipeline.ReleaseRTAfterFrame(ShaderIDs._DownSampledGBuffer1);
RenderPipeline.ReleaseRTAfterFrame(ShaderIDs._DownSampledGBuffer2);
RenderPipeline.ReleaseRTAfterFrame(ShaderIDs._DownSampledDepthTexture);
//TODO
}
}
public void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data)
{
CommandBuffer buffer = data.buffer;
if (!Decal.decalDatas.isCreated)
{
buffer.SetGlobalInt(_EnableDecal, 0);
return;
}
buffer.SetGlobalInt(_EnableDecal, 1);
handle.Complete();
if (cullJob.count > decalBuffer.count)
{
int oldCount = decalBuffer.count;
decalBuffer.Dispose();
decalBuffer = new ComputeBuffer((int)max(oldCount * 1.5f, cullJob.count), sizeof(DecalStrct));
}
if (!minMaxBoundMat)
{
minMaxBoundMat = new Material(data.resources.shaders.minMaxDepthBounding);
}
int pixelWidth = cam.cam.pixelWidth;
int pixelHeight = cam.cam.pixelHeight;
decalBuffer.SetDataPtr(sortJob.sortedDecalDatas.unsafePtr, 0, cullJob.count);
buffer.GetTemporaryRT(_DownSampledDepth0, pixelWidth / 2, pixelHeight / 2, 0, FilterMode.Point, RenderTextureFormat.RGHalf, RenderTextureReadWrite.Linear, 1, false, RenderTextureMemoryless.None, false);
buffer.GetTemporaryRT(_DownSampledDepth1, pixelWidth / 4, pixelHeight / 4, 0, FilterMode.Point, RenderTextureFormat.RGHalf, RenderTextureReadWrite.Linear, 1, false, RenderTextureMemoryless.None, false);
buffer.GetTemporaryRT(_DownSampledDepth2, pixelWidth / 8, pixelHeight / 8, 0, FilterMode.Point, RenderTextureFormat.RGHalf, RenderTextureReadWrite.Linear, 1, false, RenderTextureMemoryless.None, false);
buffer.GetTemporaryRT(_DownSampledDepth3, pixelWidth / 16, pixelHeight / 16, 0, FilterMode.Point, RenderTextureFormat.RGHalf, RenderTextureReadWrite.Linear, 1, false, RenderTextureMemoryless.None, false);
buffer.BlitSRT(_DownSampledDepth0, minMaxBoundMat, 0);
buffer.SetGlobalTexture(ShaderIDs._TargetDepthTexture, _DownSampledDepth0);
buffer.BlitSRT(_DownSampledDepth1, minMaxBoundMat, 1);
buffer.SetGlobalTexture(ShaderIDs._TargetDepthTexture, _DownSampledDepth1);
buffer.BlitSRT(_DownSampledDepth2, minMaxBoundMat, 1);
buffer.SetGlobalTexture(ShaderIDs._TargetDepthTexture, _DownSampledDepth2);
buffer.BlitSRT(_DownSampledDepth3, minMaxBoundMat, 1);
int2 tileSize = int2(pixelWidth / 16, pixelHeight / 16);
RenderTextureDescriptor lightTileDisc = new RenderTextureDescriptor
{
autoGenerateMips = false,
bindMS = false,
colorFormat = RenderTextureFormat.RInt,
depthBufferBits = 0,
dimension = TextureDimension.Tex3D,
enableRandomWrite = true,
width = tileSize.x,
height = tileSize.y,
msaaSamples = 1,
volumeDepth = CBDRSharedData.MAXLIGHTPERTILE
};
buffer.GetTemporaryRT(ShaderIDs._DecalTile, lightTileDisc);
tileSizeArray[0] = tileSize.x;
tileSizeArray[1] = tileSize.y;
float3 * corners = stackalloc float3[4];
PerspCam perspCam = new PerspCam
{
fov = cam.cam.fieldOfView,
up = cam.cam.transform.up,
right = cam.cam.transform.right,
forward = cam.cam.transform.forward,
position = cam.cam.transform.position,
aspect = cam.cam.aspect,
};
PipelineFunctions.GetFrustumCorner(ref perspCam, 1, corners);
for (int i = 0; i < 4; ++i)
{
frustumCorners[i] = float4(corners[i], 1);
}
buffer.SetComputeVectorArrayParam(cbdrShader, ShaderIDs._FrustumCorners, frustumCorners);
buffer.SetComputeVectorParam(cbdrShader, ShaderIDs._CameraPos, cam.cam.transform.position);
buffer.SetComputeIntParams(cbdrShader, ShaderIDs._TileSize, tileSizeArray);
buffer.SetGlobalVector(ShaderIDs._TileSize, new Vector4(tileSize.x, tileSize.y));
buffer.SetComputeVectorParam(cbdrShader, ShaderIDs._CameraForward, cam.cam.transform.forward);
buffer.SetComputeTextureParam(cbdrShader, CBDRSharedData.DecalCull, ShaderIDs._DepthBoundTexture, new RenderTargetIdentifier(_DownSampledDepth3));
buffer.SetComputeTextureParam(cbdrShader, CBDRSharedData.DecalCull, ShaderIDs._DecalTile, new RenderTargetIdentifier(ShaderIDs._DecalTile));
buffer.SetComputeBufferParam(cbdrShader, CBDRSharedData.DecalCull, ShaderIDs._AllDecals, decalBuffer);
buffer.SetComputeIntParam(cbdrShader, ShaderIDs._DecalCount, cullJob.count);
buffer.SetGlobalBuffer(ShaderIDs._AllDecals, decalBuffer);
buffer.DispatchCompute(cbdrShader, CBDRSharedData.DecalCull, Mathf.CeilToInt(tileSize.x / 8f), Mathf.CeilToInt(tileSize.y / 8f), 1);
buffer.ReleaseTemporaryRT(_DownSampledDepth0);
buffer.ReleaseTemporaryRT(_DownSampledDepth1);
buffer.ReleaseTemporaryRT(_DownSampledDepth2);
buffer.ReleaseTemporaryRT(_DownSampledDepth3);
RenderPipeline.ReleaseRTAfterFrame(ShaderIDs._DecalTile);
decalCullResults.Dispose();
decalCompareResults.Dispose();
}
