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 depthAlphaTestDrawSettings = new DrawingSettings(new ShaderTagId("Depth"),
new SortingSettings(cam.cam)
{
criteria = SortingCriteria.QuantizedFrontToBack
})
{
perObjectData = UnityEngine.Rendering.PerObjectData.None,
enableDynamicBatching = false,
enableInstancing = false
};
DrawingSettings depthOpaqueDrawSettings = new DrawingSettings(new ShaderTagId("Depth"),
new SortingSettings(cam.cam)
{
criteria = SortingCriteria.QuantizedFrontToBack
})
{
perObjectData = UnityEngine.Rendering.PerObjectData.None,
enableDynamicBatching = false,
enableInstancing = false,
overrideMaterial = proper.overrideOpaqueMaterial,
overrideMaterialPassIndex = 1
};
DrawingSettings drawSettings = new DrawingSettings(new ShaderTagId("GBuffer"), new SortingSettings(cam.cam)
{
criteria = SortingCriteria.SortingLayer | SortingCriteria.RenderQueue | SortingCriteria.OptimizeStateChanges
})
{
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
};
//Draw Depth Prepass
data.buffer.SetRenderTarget(ShaderIDs._DepthBufferTexture);
data.buffer.ClearRenderTarget(true, false, Color.black);
cullHandle.Complete();
var lst = CustomDrawRequest.allEvents;
foreach (var i in gbufferCullResults)
{
lst[i].DrawDepthPrepass(buffer);
}
SceneController.RenderScene(ref data, ref opaqueFilter, ref depthOpaqueDrawSettings, ref proper.cullResults);
data.context.DrawRenderers(proper.cullResults, ref depthAlphaTestDrawSettings, ref alphaTestFilter);
//Draw GBuffer
data.buffer.SetRenderTarget(colors: cam.targets.gbufferIdentifier, depth: ShaderIDs._DepthBufferTexture);
data.buffer.ClearRenderTarget(false, true, Color.black);
HizOcclusionData hizOccData;
if (useHiZ)
{
hizOccData = IPerCameraData.GetProperty(cam, () => new HizOcclusionData());
SceneController.DrawCluster_LastFrameDepthHiZ(ref options, hizOccData, clusterMat, cam);
}
foreach (var i in gbufferCullResults)
{
lst[i].DrawGBuffer(buffer);
}
SceneController.RenderScene(ref data, ref opaqueFilter, ref drawSettings, ref proper.cullResults);
if (useHiZ)
{
SceneController.DrawCluster_RecheckHiz(ref options, ref hizDepth, hizOccData, clusterMat, linearMat, cam);
}
//Draw AlphaTest
/* SortingSettings st = drawSettings.sortingSettings;
* st.criteria = SortingCriteria.SortingLayer | SortingCriteria.RenderQueue | SortingCriteria.OptimizeStateChanges;
* drawSettings.sortingSettings = st;*/
SceneController.RenderScene(ref data, ref alphaTestFilter, ref drawSettings, ref proper.cullResults);
//Draw Depth
data.buffer.Blit(ShaderIDs._DepthBufferTexture, ShaderIDs._CameraDepthTexture);
//Draw Motion Vector
data.buffer.SetRenderTarget(color: ShaderIDs._CameraMotionVectorsTexture, depth: ShaderIDs._DepthBufferTexture);
foreach (var i in gbufferCullResults)
{
lst[i].DrawMotionVector(buffer);
}
SceneController.RenderScene(ref data, ref mvFilter, ref mvDraw, ref proper.cullResults);
//Draw Static Global Motion Vector
data.buffer.DrawMesh(GraphicsUtility.mesh, Matrix4x4.identity, motionVecMat, 0, 0);
//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 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 depthAlphaTestDrawSettings = new DrawingSettings(new ShaderTagId("Depth"),
new SortingSettings(cam.cam)
{
criteria = SortingCriteria.QuantizedFrontToBack | SortingCriteria.OptimizeStateChanges
}
)
{
perObjectData = UnityEngine.Rendering.PerObjectData.None,
enableDynamicBatching = false,
enableInstancing = false
};
DrawingSettings depthOpaqueDrawSettings = new DrawingSettings(new ShaderTagId("Depth"),
new SortingSettings(cam.cam)
{
criteria = SortingCriteria.QuantizedFrontToBack
})
{
perObjectData = UnityEngine.Rendering.PerObjectData.None,
enableDynamicBatching = false,
enableInstancing = false,
overrideMaterial = proper.overrideOpaqueMaterial,
overrideMaterialPassIndex = 1
};
DrawingSettings drawSettings = new DrawingSettings(new ShaderTagId("GBuffer"), new SortingSettings(cam.cam)
{
criteria = SortingCriteria.RenderQueue | SortingCriteria.OptimizeStateChanges
})
{
perObjectData = UnityEngine.Rendering.PerObjectData.Lightmaps,
enableDynamicBatching = false,
enableInstancing = false
};
DrawingSettings mvDraw = new DrawingSettings(new ShaderTagId("MotionVector"), new SortingSettings {
criteria = SortingCriteria.OptimizeStateChanges
})
{
perObjectData = UnityEngine.Rendering.PerObjectData.None,
enableDynamicBatching = false,
enableInstancing = false
};
//Draw Depth Prepass
data.buffer.SetRenderTarget(ShaderIDs._DepthBufferTexture);
data.buffer.ClearRenderTarget(true, false, Color.black);
cullHandle.Complete();
var lst = CustomDrawRequest.allEvents;
foreach (var i in gbufferCullResults)
{
lst[i].DrawDepthPrepass(buffer);
}
HizOcclusionData hizOccData = null;
PipelineFunctions.UpdateFrustumMinMaxPoint(buffer, proper.frustumMinPoint, proper.frustumMaxPoint);
if (useHiZ && SceneController.gpurpEnabled)
{
#if UNITY_EDITOR
if (Application.isPlaying)
{
#endif
hizOccData = IPerCameraData.GetProperty(cam, () => new HizOcclusionData());
SceneController.CullCluster_LastFrameDepthHiZ(ref options, hizOccData, cam);
buffer.DrawProceduralIndirect(Matrix4x4.identity, clusterMat, 2, MeshTopology.Triangles, SceneController.baseBuffer.instanceCountBuffer, 0);
#if UNITY_EDITOR
}
#endif
}
SceneController.RenderScene(ref data, ref opaqueFilter, ref depthOpaqueDrawSettings, ref proper.cullResults);
data.context.DrawRenderers(proper.cullResults, ref depthAlphaTestDrawSettings, ref alphaTestFilter);
decalEvt.FrameUpdate(cam, ref data);
//Draw GBuffer
data.buffer.SetRenderTarget(colors: cam.targets.gbufferIdentifier, depth: ShaderIDs._DepthBufferTexture);
data.buffer.ClearRenderTarget(false, true, Color.black);
foreach (var i in gbufferCullResults)
{
lst[i].DrawGBuffer(buffer);
}
if (useHiZ && SceneController.gpurpEnabled)
{
#if UNITY_EDITOR
if (Application.isPlaying)
{
#endif
buffer.SetGlobalBuffer(ShaderIDs._MaterialBuffer, data.resources.clusterResources.vmManager.materialBuffer);
buffer.SetGlobalTexture(ShaderIDs._GPURPMainTex, data.resources.clusterResources.albedoPool.rt);
buffer.SetGlobalTexture(ShaderIDs._GPURPSpecularMap, data.resources.clusterResources.smoPool.rt);
buffer.SetGlobalTexture(ShaderIDs._GPURPEmissionMap, data.resources.clusterResources.emissionPool.rt);
buffer.SetGlobalTexture(ShaderIDs._GPURPBumpMap, data.resources.clusterResources.normalPool.rt);
buffer.SetGlobalTexture(ShaderIDs._GPURPHeightMap, data.resources.clusterResources.heightPool.rt);
buffer.DrawProceduralIndirect(Matrix4x4.identity, clusterMat, 0, MeshTopology.Triangles, SceneController.baseBuffer.instanceCountBuffer, 0);
#if UNITY_EDITOR
}
#endif
}
SceneController.RenderScene(ref data, ref opaqueFilter, ref drawSettings, ref proper.cullResults);
if (useHiZ && SceneController.gpurpEnabled)
{
#if UNITY_EDITOR
if (Application.isPlaying)
#endif
SceneController.DrawCluster_RecheckHiz(ref options, ref hizDepth, hizOccData, clusterMat, linearMat, cam);
}
if (MTerrain.current)
{
MTerrain.current.DrawTerrain(buffer, 0, proper.frustumPlanes);
}
//Draw AlphaTest
/* SortingSettings st = drawSettings.sortingSettings;
* st.criteria = SortingCriteria.SortingLayer | SortingCriteria.RenderQueue | SortingCriteria.OptimizeStateChanges;
* drawSettings.sortingSettings = st;*/
SceneController.RenderScene(ref data, ref alphaTestFilter, ref drawSettings, ref proper.cullResults);
//Draw Depth
data.buffer.Blit(ShaderIDs._DepthBufferTexture, ShaderIDs._CameraDepthTexture);
//Draw Motion Vector
data.buffer.SetRenderTarget(color: ShaderIDs._CameraMotionVectorsTexture, depth: ShaderIDs._DepthBufferTexture);
foreach (var i in gbufferCullResults)
{
lst[i].DrawMotionVector(buffer);
}
SceneController.RenderScene(ref data, ref mvFilter, ref mvDraw, ref proper.cullResults);
//Draw Static Global Motion Vector
data.buffer.DrawMesh(GraphicsUtility.mesh, Matrix4x4.identity, motionVecMat, 0, 0);
}
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data)
{
CommandBuffer buffer = data.buffer;
ComputeShader scatter = data.resources.volumetricScattering;
if (cbdr.lightFlag == 0)
{
cbdr.cubemapShadowArray = null;
cbdr.dirLightShadowmap = null;
return;
}
int pass = 0;
if (cbdr.cubemapShadowArray != null)
{
pass |= 0b001;
}
if (cbdr.dirLightShadowmap != null)
{
pass |= 0b010;
}
buffer.SetGlobalFloat(ShaderIDs._MaxDistance, availableDistance);
buffer.SetGlobalInt(ShaderIDs._FrameCount, Time.frameCount);
HistoryVolumetric historyVolume = IPerCameraData.GetProperty(cam, () => new HistoryVolumetric());
//Volumetric Light
RenderTextureDescriptor desc = new RenderTextureDescriptor
{
autoGenerateMips = false,
bindMS = false,
colorFormat = RenderTextureFormat.ARGBHalf,
depthBufferBits = 0,
dimension = TextureDimension.Tex3D,
enableRandomWrite = true,
height = downSampledSize.y,
width = downSampledSize.x,
memoryless = RenderTextureMemoryless.None,
msaaSamples = 1,
shadowSamplingMode = ShadowSamplingMode.None,
sRGB = false,
useMipMap = false,
volumeDepth = downSampledSize.z,
vrUsage = VRTextureUsage.None
};
buffer.GetTemporaryRT(ShaderIDs._VolumeTex, desc, FilterMode.Bilinear);
if (!historyVolume.lastVolume)
{
historyVolume.lastVolume = new RenderTexture(desc);
historyVolume.lastVolume.filterMode = FilterMode.Bilinear;
historyVolume.lastVolume.wrapMode = TextureWrapMode.Clamp;
historyVolume.lastVolume.Create();
buffer.SetGlobalFloat(ShaderIDs._TemporalWeight, 0);
}
else
{
if (historyVolume.lastVolume.volumeDepth != desc.volumeDepth)
{
historyVolume.lastVolume.Release();
historyVolume.lastVolume.volumeDepth = desc.volumeDepth;
historyVolume.lastVolume.Create();
buffer.SetGlobalFloat(ShaderIDs._TemporalWeight, 0);
}
else
{
buffer.SetGlobalFloat(ShaderIDs._TemporalWeight, 0.7f);
}
}
buffer.SetGlobalVector(ShaderIDs._NearFarClip, new Vector4(cam.cam.farClipPlane / availableDistance, cam.cam.nearClipPlane / availableDistance, cam.cam.nearClipPlane));
buffer.SetGlobalVector(ShaderIDs._Screen_TexelSize, new Vector4(1f / cam.cam.pixelWidth, 1f / cam.cam.pixelHeight, cam.cam.pixelWidth, cam.cam.pixelHeight));
buffer.SetComputeBufferParam(scatter, pass, ShaderIDs._AllPointLight, cbdr.allPointLightBuffer);
buffer.SetComputeTextureParam(scatter, pass, ShaderIDs._FroxelTileLightList, cbdr.froxelTileLightList);
buffer.SetComputeBufferParam(scatter, pass, ShaderIDs._RandomBuffer, randomBuffer);
buffer.SetComputeTextureParam(scatter, pass, ShaderIDs._VolumeTex, ShaderIDs._VolumeTex);
buffer.SetComputeTextureParam(scatter, scatterPass, ShaderIDs._VolumeTex, ShaderIDs._VolumeTex);
buffer.SetComputeTextureParam(scatter, pass, ShaderIDs._LastVolume, historyVolume.lastVolume);
buffer.SetComputeTextureParam(scatter, pass, ShaderIDs._DirShadowMap, cbdr.dirLightShadowmap);
buffer.SetComputeTextureParam(scatter, pass, ShaderIDs._CubeShadowMapArray, cbdr.cubemapShadowArray);
buffer.SetGlobalVector(ShaderIDs._RandomSeed, (float4)(rand.NextDouble4() * 1000 + 100));
cbdr.cubemapShadowArray = null;
cbdr.dirLightShadowmap = null;
buffer.SetComputeIntParam(scatter, ShaderIDs._LightFlag, (int)cbdr.lightFlag);
buffer.DispatchCompute(scatter, pass, downSampledSize.x / 8, downSampledSize.y / 2, downSampledSize.z / marchStep);
buffer.CopyTexture(ShaderIDs._VolumeTex, historyVolume.lastVolume);
buffer.DispatchCompute(scatter, scatterPass, downSampledSize.x / 32, downSampledSize.y / 2, 1);
buffer.BlitSRT(cam.targets.renderTargetIdentifier, volumeMat, 0);
buffer.ReleaseTemporaryRT(ShaderIDs._VolumeTex);
cbdr.lightFlag = 0;
PipelineFunctions.ExecuteCommandBuffer(ref data);
}
public override void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data)
{
LastVPData lastData = IPerCameraData.GetProperty <LastVPData>(cam, getLastVP);
//Calculate Last VP for motion vector and Temporal AA
Matrix4x4 nonJitterVP = GL.GetGPUProjectionMatrix(cam.cam.nonJitteredProjectionMatrix, false) * cam.cam.worldToCameraMatrix;
ref Matrix4x4 lastVp = ref lastData.lastVP;
public static bool GetProperty <T>(PipelineCamera camera, out IPerCameraData data)
{
return(camera.postDatas.TryGetValue(typeof(T), out data));
}
public void PreRender(PipelineCamera cam)
{
prevDepthData = IPerCameraData.GetProperty(cam, (cc) => new PreviousDepthData(new Vector2Int(cc.cam.pixelWidth, cc.cam.pixelHeight)));
prevDepthData.targetObject = this;
}
