public void RenderReflectionsT1(HDCamera hdCamera, CommandBuffer cmd, RTHandleSystem.RTHandle outputTexture, ScriptableRenderContext renderContext, int frameCount) { // First thing to check is: Do we have a valid ray-tracing environment? HDRaytracingEnvironment rtEnvironment = m_RaytracingManager.CurrentEnvironment(); HDRenderPipeline renderPipeline = m_RaytracingManager.GetRenderPipeline(); BlueNoise blueNoise = m_RaytracingManager.GetBlueNoiseManager(); ComputeShader reflectionFilter = m_PipelineAsset.renderPipelineRayTracingResources.reflectionBilateralFilterCS; RayTracingShader reflectionShader = m_PipelineAsset.renderPipelineRayTracingResources.reflectionRaytracing; bool invalidState = rtEnvironment == null || blueNoise == null || reflectionFilter == null || reflectionShader == null || m_PipelineResources.textures.owenScrambledTex == null || m_PipelineResources.textures.scramblingTex == null; // If no acceleration structure available, end it now if (invalidState) { return; } var settings = VolumeManager.instance.stack.GetComponent <ScreenSpaceReflection>(); LightCluster lightClusterSettings = VolumeManager.instance.stack.GetComponent <LightCluster>(); // Grab the acceleration structures and the light cluster to use RayTracingAccelerationStructure accelerationStructure = m_RaytracingManager.RequestAccelerationStructure(rtEnvironment.reflLayerMask); HDRaytracingLightCluster lightCluster = m_RaytracingManager.RequestLightCluster(rtEnvironment.reflLayerMask); // Compute the actual resolution that is needed base on the quality string targetRayGen = m_RayGenHalfResName; // Define the shader pass to use for the reflection pass cmd.SetRayTracingShaderPass(reflectionShader, "IndirectDXR"); // Set the acceleration structure for the pass cmd.SetRayTracingAccelerationStructure(reflectionShader, HDShaderIDs._RaytracingAccelerationStructureName, accelerationStructure); // Inject the ray-tracing sampling data cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._OwenScrambledTexture, m_PipelineResources.textures.owenScrambledTex); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._ScramblingTexture, m_PipelineResources.textures.scramblingTex); // Global reflection parameters cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingIntensityClamp, settings.clampValue.value); cmd.SetRayTracingFloatParams(reflectionShader, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value); cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingReflectSky, settings.reflectSky.value ? 1 : 0); // Inject the ray generation data cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayBias, rtEnvironment.rayBias); cmd.SetGlobalFloat(HDShaderIDs._RaytracingRayMaxLength, settings.rayLength.value); cmd.SetRayTracingIntParams(reflectionShader, HDShaderIDs._RaytracingNumSamples, settings.numSamples.value); int frameIndex = hdCamera.IsTAAEnabled() ? hdCamera.taaFrameIndex : (int)frameCount % 8; cmd.SetGlobalInt(HDShaderIDs._RaytracingFrameIndex, frameIndex); // Set the data for the ray generation cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrLightingTextureRW, m_LightingTexture); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrHitPointTexture, m_HitPdfTexture); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer()); // Set ray count tex cmd.SetRayTracingIntParam(reflectionShader, HDShaderIDs._RayCountEnabled, m_RaytracingManager.rayCountManager.RayCountIsEnabled()); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._RayCountTexture, m_RaytracingManager.rayCountManager.rayCountTexture); // Compute the pixel spread value float pixelSpreadAngle = Mathf.Atan(2.0f * Mathf.Tan(hdCamera.camera.fieldOfView * Mathf.PI / 360.0f) / Mathf.Min(hdCamera.actualWidth, hdCamera.actualHeight)); cmd.SetRayTracingFloatParam(reflectionShader, HDShaderIDs._RaytracingPixelSpreadAngle, pixelSpreadAngle); // LightLoop data cmd.SetGlobalBuffer(HDShaderIDs._RaytracingLightCluster, lightCluster.GetCluster()); cmd.SetGlobalBuffer(HDShaderIDs._LightDatasRT, lightCluster.GetLightDatas()); cmd.SetGlobalVector(HDShaderIDs._MinClusterPos, lightCluster.GetMinClusterPos()); cmd.SetGlobalVector(HDShaderIDs._MaxClusterPos, lightCluster.GetMaxClusterPos()); cmd.SetGlobalInt(HDShaderIDs._LightPerCellCount, lightClusterSettings.maxNumLightsPercell.value); cmd.SetGlobalInt(HDShaderIDs._PunctualLightCountRT, lightCluster.GetPunctualLightCount()); cmd.SetGlobalInt(HDShaderIDs._AreaLightCountRT, lightCluster.GetAreaLightCount()); // Note: Just in case, we rebind the directional light data (in case they were not) cmd.SetGlobalBuffer(HDShaderIDs._DirectionalLightDatas, renderPipeline.m_LightLoopLightData.directionalLightData); cmd.SetGlobalInt(HDShaderIDs._DirectionalLightCount, renderPipeline.m_lightList.directionalLights.Count); // Evaluate the clear coat mask texture based on the lit shader mode RenderTargetIdentifier clearCoatMaskTexture = hdCamera.frameSettings.litShaderMode == LitShaderMode.Deferred ? m_GbufferManager.GetBuffersRTI()[2] : TextureXR.GetBlackTexture(); cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture); // Set the data for the ray miss cmd.SetRayTracingTextureParam(reflectionShader, HDShaderIDs._SkyTexture, m_SkyManager.skyReflection); // Compute the actual resolution that is needed base on the quality uint widthResolution = (uint)hdCamera.actualWidth / 2; uint heightResolution = (uint)hdCamera.actualHeight / 2; // Force to disable specular lighting cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, 0); // Run the computation cmd.DispatchRays(reflectionShader, targetRayGen, widthResolution, heightResolution, 1); // Restore the previous state of specular lighting cmd.SetGlobalInt(HDShaderIDs._EnableSpecularLighting, hdCamera.frameSettings.IsEnabled(FrameSettingsField.SpecularLighting) ? 1 : 0); using (new ProfilingSample(cmd, "Filter Reflection", CustomSamplerId.RaytracingFilterReflection.GetSampler())) { // Fetch the right filter to use int currentKernel = reflectionFilter.FindKernel("RaytracingReflectionFilter"); // Inject all the parameters for the compute cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrLightingTextureRW, m_LightingTexture); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrHitPointTexture, m_HitPdfTexture); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._DepthTexture, m_SharedRTManager.GetDepthStencilBuffer()); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._NormalBufferTexture, m_SharedRTManager.GetNormalBuffer()); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_NoiseTexture", blueNoise.textureArray16RGB); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_VarianceTexture", m_VarianceBuffer); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_MinColorRangeTexture", m_MinBoundBuffer); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_MaxColorRangeTexture", m_MaxBoundBuffer); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_RaytracingReflectionTexture", outputTexture); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._ScramblingTexture, m_PipelineResources.textures.scramblingTex); cmd.SetComputeIntParam(reflectionFilter, HDShaderIDs._SpatialFilterRadius, settings.spatialFilterRadius.value); cmd.SetComputeFloatParam(reflectionFilter, HDShaderIDs._RaytracingReflectionMinSmoothness, settings.minSmoothness.value); // Texture dimensions int texWidth = outputTexture.rt.width; int texHeight = outputTexture.rt.height; // Evaluate the dispatch parameters int areaTileSize = 8; int numTilesXHR = (texWidth + (areaTileSize - 1)) / areaTileSize; int numTilesYHR = (texHeight + (areaTileSize - 1)) / areaTileSize; // Bind the right texture for clear coat support cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._SsrClearCoatMaskTexture, clearCoatMaskTexture); // Compute the texture cmd.DispatchCompute(reflectionFilter, currentKernel, numTilesXHR, numTilesYHR, 1); int numTilesXFR = (texWidth + (areaTileSize - 1)) / areaTileSize; int numTilesYFR = (texHeight + (areaTileSize - 1)) / areaTileSize; RTHandleSystem.RTHandle history = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection) ?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.RaytracedReflection, ReflectionHistoryBufferAllocatorFunction, 1); // Fetch the right filter to use currentKernel = reflectionFilter.FindKernel("TemporalAccumulationFilter"); cmd.SetComputeFloatParam(reflectionFilter, HDShaderIDs._TemporalAccumuationWeight, settings.temporalAccumulationWeight.value); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._AccumulatedFrameTexture, history); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, HDShaderIDs._CurrentFrameTexture, outputTexture); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_MinColorRangeTexture", m_MinBoundBuffer); cmd.SetComputeTextureParam(reflectionFilter, currentKernel, "_MaxColorRangeTexture", m_MaxBoundBuffer); cmd.DispatchCompute(reflectionFilter, currentKernel, numTilesXFR, numTilesYFR, 1); } }
public void setup(RenderTargetIdentifier source) { this.Sour = source; }
/// <summary> /// Configure the pass with the source and destination to execute on. /// </summary> /// <param name="source">Source Render Target</param> /// <param name="destination">Destination Render Target</param> public void Setup(RenderTargetIdentifier source, UnityEngine.Rendering.Universal.RenderTargetHandle destination, RenderTexture setTexTo) { this.source = source; this.destination = destination; this.setMainTexTo = setTexTo; }
public static void CopyDepthTexture(this CommandBuffer cmd, RenderTargetIdentifier source, RenderTargetIdentifier dest, Material mat, int pass = 0, bool clear = false) { cmd.SetGlobalTexture(ShaderIDs.CameraDepthBuffer, source); cmd.SetRenderTarget(dest, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store); if (clear) { cmd.ClearRenderTarget(true, true, Color.clear); } cmd.DrawMesh(fullScreenTriangle, Matrix4x4.identity, mat, 0, pass); }
public void ProcessImage(PostProcessingContext context, CommandBuffer cb, ref Settings settings, RenderTargetIdentifier source, RenderTargetIdentifier destination, Material material) { const float kMaxBlurRadius = 5f; // Calculate the maximum blur radius in pixels. int maxBlurPixels = (int)(kMaxBlurRadius * context.height / 100); // Calculate the TileMax size. // It should be a multiple of 8 and larger than maxBlur. int tileSize = ((maxBlurPixels - 1) / 8 + 1) * 8; // Pass 1 - Velocity/depth packing // Motion vectors are scaled by an empirical factor of 1.45. var velocityScale = settings.shutterAngle / 360f * 1.45f; cb.SetGlobalFloat(Uniforms._VelocityScale, velocityScale); cb.SetGlobalFloat(Uniforms._MaxBlurRadius, maxBlurPixels); int vbuffer = Uniforms._VelocityTex; cb.GetTemporaryRT(vbuffer, context.width, context.height, 0, FilterMode.Point, m_PackedRTFormat, RenderTextureReadWrite.Linear); cb.Blit((Texture)null, vbuffer, material, (int)Pass.VelocitySetup); // Pass 2 - First TileMax filter (1/4 downsize) int tile4 = Uniforms._Tile4RT; cb.GetTemporaryRT(tile4, context.width / 4, context.height / 4, 0, FilterMode.Point, m_VectorRTFormat, RenderTextureReadWrite.Linear); cb.SetGlobalTexture(Uniforms._MainTex, vbuffer); cb.Blit(vbuffer, tile4, material, (int)Pass.TileMax4); // Pass 3 - Second TileMax filter (1/2 downsize) int tile8 = Uniforms._Tile8RT; cb.GetTemporaryRT(tile8, context.width / 8, context.height / 8, 0, FilterMode.Point, m_VectorRTFormat, RenderTextureReadWrite.Linear); cb.SetGlobalTexture(Uniforms._MainTex, tile4); cb.Blit(tile4, tile8, material, (int)Pass.TileMax2); cb.ReleaseTemporaryRT(tile4); // Pass 4 - Third TileMax filter (reduce to tileSize) var tileMaxOffs = Vector2.one * (tileSize / 8f - 1f) * -0.5f; cb.SetGlobalVector(Uniforms._TileMaxOffs, tileMaxOffs); cb.SetGlobalFloat(Uniforms._TileMaxLoop, (int)(tileSize / 8f)); int tile = Uniforms._TileVRT; cb.GetTemporaryRT(tile, context.width / tileSize, context.height / tileSize, 0, FilterMode.Point, m_VectorRTFormat, RenderTextureReadWrite.Linear); cb.SetGlobalTexture(Uniforms._MainTex, tile8); cb.Blit(tile8, tile, material, (int)Pass.TileMaxV); cb.ReleaseTemporaryRT(tile8); // Pass 5 - NeighborMax filter int neighborMax = Uniforms._NeighborMaxTex; int neighborMaxWidth = context.width / tileSize; int neighborMaxHeight = context.height / tileSize; cb.GetTemporaryRT(neighborMax, neighborMaxWidth, neighborMaxHeight, 0, FilterMode.Point, m_VectorRTFormat, RenderTextureReadWrite.Linear); cb.SetGlobalTexture(Uniforms._MainTex, tile); cb.Blit(tile, neighborMax, material, (int)Pass.NeighborMax); cb.ReleaseTemporaryRT(tile); // Pass 6 - Reconstruction pass cb.SetGlobalFloat(Uniforms._LoopCount, Mathf.Clamp(settings.sampleCount / 2, 1, 64)); cb.SetGlobalFloat(Uniforms._MaxBlurRadius, maxBlurPixels); cb.SetGlobalTexture(Uniforms._MainTex, source); cb.Blit(source, destination, material, m_UseUnrolledShader ? (int)Pass.ReconstructionUnroll : (int)Pass.Reconstruction); cb.ReleaseTemporaryRT(vbuffer); cb.ReleaseTemporaryRT(neighborMax); }
static private void RenderShadows(CommandBuffer cmdBuffer, int layerToRender, Light2D light, float shadowIntensity, RenderTargetIdentifier renderTexture) { // Render light's shadows cmdBuffer.SetRenderTarget(s_ShadowsRenderTarget.Identifier()); // This isn't efficient if this light doesn't cast shadow. cmdBuffer.ClearRenderTarget(true, true, Color.black); cmdBuffer.SetGlobalFloat("_ShadowIntensity", 1 - light.shadowIntensity); cmdBuffer.SetGlobalFloat("_ShadowVolumeIntensity", 1 - light.shadowVolumeIntensity); // TODO: We need an alternate (more efficient) code path if the light has a shadowIntensity of 0 if (shadowIntensity > 0) { BoundingSphere lightBounds = light.GetBoundingSphere(); // Gets the local bounding sphere... cmdBuffer.SetGlobalVector("_LightPos", light.transform.position); cmdBuffer.SetGlobalFloat("_LightRadius", lightBounds.radius); Material shadowMaterial = GetShadowMaterial(1); Material removeSelfShadowMaterial = GetRemoveSelfShadowMaterial(1); List <ShadowCasterGroup2D> shadowCasterGroups = ShadowCasterGroup2DManager.shadowCasterGroups; if (shadowCasterGroups != null && shadowCasterGroups.Count > 0) { int previousShadowGroupIndex = -1; int incrementingGroupIndex = 0; for (int group = 0; group < shadowCasterGroups.Count; group++) { ShadowCasterGroup2D shadowCasterGroup = shadowCasterGroups[group]; List <ShadowCaster2D> shadowCasters = shadowCasterGroup.GetShadowCasters(); int shadowGroupIndex = shadowCasterGroup.GetShadowGroup(); if (LightUtility.CheckForChange(shadowGroupIndex, ref previousShadowGroupIndex) || shadowGroupIndex == 0) { incrementingGroupIndex++; shadowMaterial = GetShadowMaterial(incrementingGroupIndex); removeSelfShadowMaterial = GetRemoveSelfShadowMaterial(incrementingGroupIndex); } if (shadowCasters != null) { // Draw the shadow casting group first, then draw the silhouttes.. for (int i = 0; i < shadowCasters.Count; i++) { ShadowCaster2D shadowCaster = (ShadowCaster2D)shadowCasters[i]; if (shadowCaster != null && shadowMaterial != null && shadowCaster.IsShadowedLayer(layerToRender)) { if (shadowCaster.castsShadows) { cmdBuffer.DrawMesh(shadowCaster.mesh, shadowCaster.transform.localToWorldMatrix, shadowMaterial); } } } for (int i = 0; i < shadowCasters.Count; i++) { ShadowCaster2D shadowCaster = (ShadowCaster2D)shadowCasters[i]; if (shadowCaster != null && shadowMaterial != null && shadowCaster.IsShadowedLayer(layerToRender)) { if (shadowCaster.useRendererSilhouette) { Renderer renderer = shadowCaster.GetComponent <Renderer>(); if (renderer != null) { if (!shadowCaster.selfShadows) { cmdBuffer.DrawRenderer(renderer, removeSelfShadowMaterial); } else { cmdBuffer.DrawRenderer(renderer, shadowMaterial, 0, 1); } } } else { if (!shadowCaster.selfShadows) { Matrix4x4 meshMat = shadowCaster.transform.localToWorldMatrix; cmdBuffer.DrawMesh(shadowCaster.mesh, meshMat, removeSelfShadowMaterial); } } } } } } } } cmdBuffer.SetRenderTarget(renderTexture); }
static private void RenderLightVolumeSet(Camera camera, int blendStyleIndex, CommandBuffer cmdBuffer, int layerToRender, RenderTargetIdentifier renderTexture, List <Light2D> lights) { if (lights.Count > 0) { for (int i = 0; i < lights.Count; i++) { Light2D light = lights[i]; int topMostLayer = light.GetTopMostLitLayer(); if (layerToRender == topMostLayer) { if (light != null && light.lightType != Light2D.LightType.Global && light.volumeOpacity > 0.0f && light.blendStyleIndex == blendStyleIndex && light.IsLitLayer(layerToRender) && light.IsLightVisible(camera)) { Material lightVolumeMaterial = GetLightMaterial(light, true); if (lightVolumeMaterial != null) { Mesh lightMesh = light.GetMesh(); if (lightMesh != null) { RenderShadows(cmdBuffer, layerToRender, light, light.shadowVolumeIntensity, renderTexture); if (light.lightType == Light2D.LightType.Sprite && light.lightCookieSprite != null && light.lightCookieSprite.texture != null) { cmdBuffer.SetGlobalTexture("_CookieTex", light.lightCookieSprite.texture); } cmdBuffer.SetGlobalFloat("_FalloffIntensity", light.falloffIntensity); cmdBuffer.SetGlobalFloat("_FalloffDistance", light.shapeLightFalloffSize); cmdBuffer.SetGlobalVector("_FalloffOffset", light.shapeLightFalloffOffset); cmdBuffer.SetGlobalColor("_LightColor", light.intensity * light.color); cmdBuffer.SetGlobalFloat("_VolumeOpacity", light.volumeOpacity); // Is this needed if (light.useNormalMap || light.lightType == Light2D.LightType.Point) { RendererLighting.SetPointLightShaderGlobals(cmdBuffer, light); } // Could be combined... if (light.lightType == Light2D.LightType.Parametric || light.lightType == Light2D.LightType.Freeform || light.lightType == Light2D.LightType.Sprite) { cmdBuffer.DrawMesh(lightMesh, light.transform.localToWorldMatrix, lightVolumeMaterial); } else if (light.lightType == Light2D.LightType.Point) { Vector3 scale = new Vector3(light.pointLightOuterRadius, light.pointLightOuterRadius, light.pointLightOuterRadius); Matrix4x4 matrix = Matrix4x4.TRS(light.transform.position, Quaternion.identity, scale); cmdBuffer.DrawMesh(lightMesh, matrix, lightVolumeMaterial); } } } } } } } }
public void RenderSky(HDCamera camera, Light sunLight, RenderTargetIdentifier colorBuffer, RenderTargetIdentifier depthBuffer, CommandBuffer cmd) { using (new Utilities.ProfilingSample("Sky Pass", cmd)) { if (IsSkyValid()) { m_BuiltinParameters.commandBuffer = cmd; m_BuiltinParameters.sunLight = sunLight; m_BuiltinParameters.invViewProjMatrix = camera.viewProjMatrix.inverse; m_BuiltinParameters.cameraPosWS = camera.camera.transform.position; m_BuiltinParameters.screenSize = camera.screenSize; m_BuiltinParameters.skyMesh = BuildSkyMesh(camera.camera.GetComponent <Transform>().position, m_BuiltinParameters.invViewProjMatrix); m_BuiltinParameters.colorBuffer = colorBuffer; m_BuiltinParameters.depthBuffer = depthBuffer; m_Renderer.SetRenderTargets(m_BuiltinParameters); m_Renderer.RenderSky(m_BuiltinParameters, skySettings, false); } } }
public static void RenderPostProcess(CommandBuffer cmd, PostProcessRenderContext context, ref CameraData cameraData, RenderTextureFormat colorFormat, RenderTargetIdentifier source, RenderTargetIdentifier dest, bool opaqueOnly) { context.Reset(); context.camera = cameraData.camera; context.source = source; context.sourceFormat = colorFormat; context.destination = dest; context.command = cmd; context.flip = cameraData.camera.targetTexture == null; if (opaqueOnly) { cameraData.postProcessLayer.RenderOpaqueOnly(context); } else { cameraData.postProcessLayer.Render(context); } }
void DoColorCorrect(RenderTargetIdentifier source, RenderTargetIdentifier dest) { Draw(source, dest, Pass.ColorCorrect); }
void DoGrayscale(RenderTargetIdentifier source, RenderTargetIdentifier dest) { Draw(source, dest, Pass.Grayscale); }
public void Prepare(RenderTargetIdentifier ping, RenderTargetIdentifier pong) { _ping = ping; _pong = pong; }
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.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); }
private void renderDeferredShading() { CommandBuffer _bufA = null; CameraEvent _evA = CameraEvent.AfterForwardOpaque; if (this.m_cameraCommandBuffers.ContainsKey(_evA)) { _bufA = this.m_cameraCommandBuffers[_evA]; _bufA.Clear(); } else { _bufA = new CommandBuffer(); _bufA.name = "Override Eye"; this.m_cameraCommandBuffers.Add(_evA, _bufA); this.m_camera.AddCommandBuffer(_evA, _bufA); } OverrideEyeSystem system = OverrideEyeSystem.instance; int _rt0 = Shader.PropertyToID("_rt0"); int _rt1 = Shader.PropertyToID("_rt1"); int _rt2 = Shader.PropertyToID("_rt2"); int _rt3 = Shader.PropertyToID("_rt3"); _bufA.GetTemporaryRT(_rt0, -1, -1, 24, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default); _bufA.GetTemporaryRT(_rt1, -1, -1, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default); _bufA.GetTemporaryRT(_rt2, -1, -1, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default); _bufA.GetTemporaryRT(_rt3, -1, -1, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default); RenderTargetIdentifier[] _rts = new RenderTargetIdentifier[4] { _rt0, _rt1, _rt2, _rt3 }; _bufA.SetRenderTarget(_rts, new RenderTargetIdentifier(_rt0)); _bufA.ClearRenderTarget(true, true, Color.clear); foreach (OverrideEye eyeObj in system.m_eyeObjs) { if (eyeObj.Type == OverrideEye.RenderType.MASK) { this.drawOverrideEyeMat(_bufA, eyeObj, 0); } else if (eyeObj.Type == OverrideEye.RenderType.OVERRIDE) { this.drawSlefMat(_bufA, eyeObj, 0); } } // Clip int _rt4 = Shader.PropertyToID("_rt4"); _bufA.GetTemporaryRT(_rt4, -1, -1, 24, FilterMode.Point, RenderTextureFormat.R8, RenderTextureReadWrite.Default); _bufA.SetRenderTarget(_rt4, _rt4); _bufA.ClearRenderTarget(true, true, Color.clear); foreach (OverrideEye eyeObj in system.m_eyeObjs) { if (eyeObj.Type == OverrideEye.RenderType.CLIP) { this.drawOverrideEyeMat(_bufA, eyeObj, 5); } else { this.drawOverrideEyeMat(_bufA, eyeObj, 0); } } _bufA.SetGlobalTexture("_DeferredClipTex", _rt4); // Mask int _rt5 = Shader.PropertyToID("_rt5"); _bufA.GetTemporaryRT(_rt5, -1, -1, 24, FilterMode.Point, RenderTextureFormat.R8, RenderTextureReadWrite.Default); _bufA.SetRenderTarget(_rt5, _rt5); _bufA.ClearRenderTarget(true, true, Color.clear); foreach (OverrideEye eyeObj in system.m_eyeObjs) { if (eyeObj.Type == OverrideEye.RenderType.MASK) { drawOverrideEyeMat(_bufA, eyeObj, 0); } else if (eyeObj.Type == OverrideEye.RenderType.OVERRIDE) { drawOverrideEyeMat(_bufA, eyeObj, 5); } } _bufA.SetGlobalTexture("_DeferredMaskTex", _rt5); // for StandardShader //_bufA.Blit(_rt0, BuiltinRenderTextureType.GBuffer0, this.m_overrideEyeMat, 1); //_bufA.Blit(_rt1, BuiltinRenderTextureType.GBuffer1, this.m_overrideEyeMat, 2); //_bufA.Blit(_rt2, BuiltinRenderTextureType.GBuffer2, this.m_overrideEyeMat, 3); //_bufA.Blit(_rt3, BuiltinRenderTextureType.CameraTarget, this.m_overrideEyeMat, 4); // for unitychanShader _bufA.Blit(_rt0, BuiltinRenderTextureType.CameraTarget, this.m_overrideEyeMat, 1); _bufA.ReleaseTemporaryRT(_rt0); _bufA.ReleaseTemporaryRT(_rt1); _bufA.ReleaseTemporaryRT(_rt2); _bufA.ReleaseTemporaryRT(_rt3); _bufA.ReleaseTemporaryRT(_rt4); _bufA.ReleaseTemporaryRT(_rt5); }
public void GenerateAOMap(CommandBuffer cmd, Camera camera, RenderTargetIdentifier destination, RenderTargetIdentifier?depthMap, bool invert) { }
public void SetDepthTexture(RenderTargetIdentifier depth) { _depth = depth; }
// This particular case is for blitting a camera-scaled texture into a non scaling texture. So we setup the full viewport (implicit in cmd.Blit) but have to scale the input UVs. public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RTHandleSystem.RTHandle source, RenderTargetIdentifier destination) { cmd.Blit(source, destination, new Vector2(camera.viewportScale.x, camera.viewportScale.y), Vector2.zero); }
public void Setup(RenderTargetIdentifier source) { this.source = source; material = new Material(Shader.Find("SnapshotProURP/SNES")); }
static private bool RenderLightSet(Camera camera, int blendStyleIndex, CommandBuffer cmdBuffer, int layerToRender, RenderTargetIdentifier renderTexture, List <Light2D> lights) { bool renderedAnyLight = false; foreach (var light in lights) { if (light != null && light.lightType != Light2D.LightType.Global && light.blendStyleIndex == blendStyleIndex && light.IsLitLayer(layerToRender) && light.IsLightVisible(camera)) { // Render light Material lightMaterial = GetLightMaterial(light, false); if (lightMaterial != null) { Mesh lightMesh = light.GetMesh(); if (lightMesh != null) { RenderShadows(cmdBuffer, layerToRender, light, light.shadowIntensity, renderTexture); renderedAnyLight = true; if (light.lightType == Light2D.LightType.Sprite && light.lightCookieSprite != null && light.lightCookieSprite.texture != null) { cmdBuffer.SetGlobalTexture("_CookieTex", light.lightCookieSprite.texture); } cmdBuffer.SetGlobalFloat("_FalloffIntensity", light.falloffIntensity); cmdBuffer.SetGlobalFloat("_FalloffDistance", light.shapeLightFalloffSize); cmdBuffer.SetGlobalVector("_FalloffOffset", light.shapeLightFalloffOffset); cmdBuffer.SetGlobalColor("_LightColor", light.intensity * light.color); cmdBuffer.SetGlobalFloat("_VolumeOpacity", light.volumeOpacity); if (light.useNormalMap || light.lightType == Light2D.LightType.Point) { RendererLighting.SetPointLightShaderGlobals(cmdBuffer, light); } // Light code could be combined... if (light.lightType == Light2D.LightType.Parametric || light.lightType == Light2D.LightType.Freeform || light.lightType == Light2D.LightType.Sprite) { cmdBuffer.DrawMesh(lightMesh, light.transform.localToWorldMatrix, lightMaterial); } else if (light.lightType == Light2D.LightType.Point) { Vector3 scale = new Vector3(light.pointLightOuterRadius, light.pointLightOuterRadius, light.pointLightOuterRadius); Matrix4x4 matrix = Matrix4x4.TRS(light.transform.position, Quaternion.identity, scale); cmdBuffer.DrawMesh(lightMesh, matrix, lightMaterial); } } } } } return(renderedAnyLight); }
public static void DrawFullScreen(this CommandBuffer CmdBuffer, RTHandle Source, RenderTargetIdentifier Desc, MaterialPropertyBlock MaterialPropertyBlock = null) { CmdBuffer.SetRenderTarget(Desc); MaterialPropertyBlock.SetTexture(InfinityShaderIDs.RT_MainTexture, Source); CmdBuffer.DrawMesh(FullScreenMesh, Matrix4x4.identity, BlitMaterial, 0, 1, MaterialPropertyBlock); }
static public void RenderLightVolumes(Camera camera, CommandBuffer cmdBuffer, int layerToRender, RenderTargetIdentifier renderTarget) { for (int i = 0; i < s_BlendStyles.Length; ++i) { if (!s_BlendStyles[i].enabled) { continue; } string sampleName = s_BlendStyles[i].name; cmdBuffer.BeginSample(sampleName); RenderLightVolumeSet( camera, i, cmdBuffer, layerToRender, renderTarget, Light2D.GetLightsByBlendStyle(i) ); cmdBuffer.EndSample(sampleName); } }
public static void DrawFullScreen(this CommandBuffer CmdBuffer, RenderTargetIdentifier Source, RenderTargetIdentifier Desc, int DrawPass) { CmdBuffer.SetRenderTarget(Desc); CmdBuffer.SetGlobalTexture(InfinityShaderIDs.RT_MainTexture, Source); CmdBuffer.DrawMesh(FullScreenMesh, Matrix4x4.identity, BlitMaterial, 0, DrawPass); }
public void BlendFrames(CommandBuffer cb, float strength, RenderTargetIdentifier source, RenderTargetIdentifier destination, Material material) { var t = Time.time; var f1 = GetFrameRelative(-1); var f2 = GetFrameRelative(-2); var f3 = GetFrameRelative(-3); var f4 = GetFrameRelative(-4); cb.SetGlobalTexture(Uniforms._History1LumaTex, f1.lumaTexture); cb.SetGlobalTexture(Uniforms._History2LumaTex, f2.lumaTexture); cb.SetGlobalTexture(Uniforms._History3LumaTex, f3.lumaTexture); cb.SetGlobalTexture(Uniforms._History4LumaTex, f4.lumaTexture); cb.SetGlobalTexture(Uniforms._History1ChromaTex, f1.chromaTexture); cb.SetGlobalTexture(Uniforms._History2ChromaTex, f2.chromaTexture); cb.SetGlobalTexture(Uniforms._History3ChromaTex, f3.chromaTexture); cb.SetGlobalTexture(Uniforms._History4ChromaTex, f4.chromaTexture); cb.SetGlobalFloat(Uniforms._History1Weight, f1.CalculateWeight(strength, t)); cb.SetGlobalFloat(Uniforms._History2Weight, f2.CalculateWeight(strength, t)); cb.SetGlobalFloat(Uniforms._History3Weight, f3.CalculateWeight(strength, t)); cb.SetGlobalFloat(Uniforms._History4Weight, f4.CalculateWeight(strength, t)); cb.SetGlobalTexture(Uniforms._MainTex, source); cb.Blit(source, destination, material, m_UseCompression ? (int)Pass.FrameBlendingChroma : (int)Pass.FrameBlendingRaw); }
public static void DrawFullScreen(this CommandBuffer CmdBuffer, RenderTargetIdentifier ColorBuffer, Material DrawMaterial, int DrawPass, MaterialPropertyBlock MaterialPropertyBlock = null) { CmdBuffer.SetRenderTarget(ColorBuffer); CmdBuffer.DrawMesh(FullScreenMesh, Matrix4x4.identity, DrawMaterial, 0, DrawPass, MaterialPropertyBlock); }
public void Process(CommandBuffer cmd, RenderTargetIdentifier rt) { Process(cmd, rt, 0, CurrentWidth, 0, CurrentHeight, 0, 0); }
public static void DrawFullScreen(this CommandBuffer CmdBuffer, RenderTargetIdentifier ColorBuffer, RenderTargetIdentifier DepthBuffer, Material DrawMaterial, int DrawPass) { CmdBuffer.SetRenderTarget(ColorBuffer, DepthBuffer); CmdBuffer.DrawMesh(FullScreenMesh, Matrix4x4.identity, DrawMaterial, 0, DrawPass); }
/// <summary> /// Configure the pass with the source and destination to execute on. /// </summary> /// <param name="source">Source Render Target</param> /// <param name="destination">Destination Render Target</param> public void Setup(RenderTargetIdentifier source, UnityEngine.Rendering.Universal.RenderTargetHandle destination) { this.source = source; this.destination = destination; }
void PushUpsampleCommands(CommandBuffer cmd, int lowResDepth, int interleavedAO, int highResDepth, int?highResAO, RenderTargetIdentifier dest, Vector3 lowResDepthSize, Vector2 highResDepthSize, bool invert = false) { var cs = m_Resources.computeShaders.multiScaleAOUpsample; int kernel = cs.FindKernel(highResAO == null ? invert ? "main_invert" : "main" : "main_blendout"); float stepSize = 1920f / lowResDepthSize.x; float bTolerance = 1f - Mathf.Pow(10f, m_Settings.blurTolerance.value) * stepSize; bTolerance *= bTolerance; float uTolerance = Mathf.Pow(10f, m_Settings.upsampleTolerance.value); float noiseFilterWeight = 1f / (Mathf.Pow(10f, m_Settings.noiseFilterTolerance.value) + uTolerance); cmd.SetComputeVectorParam(cs, "InvLowResolution", new Vector2(1f / lowResDepthSize.x, 1f / lowResDepthSize.y)); cmd.SetComputeVectorParam(cs, "InvHighResolution", new Vector2(1f / highResDepthSize.x, 1f / highResDepthSize.y)); cmd.SetComputeVectorParam(cs, "AdditionalParams", new Vector4(noiseFilterWeight, stepSize, bTolerance, uTolerance)); cmd.SetComputeTextureParam(cs, kernel, "LoResDB", lowResDepth); cmd.SetComputeTextureParam(cs, kernel, "HiResDB", highResDepth); cmd.SetComputeTextureParam(cs, kernel, "LoResAO1", interleavedAO); if (highResAO != null) { cmd.SetComputeTextureParam(cs, kernel, "HiResAO", highResAO.Value); } cmd.SetComputeTextureParam(cs, kernel, "AoResult", dest); int xcount = ((int)highResDepthSize.x + 17) / 16; int ycount = ((int)highResDepthSize.y + 17) / 16; cmd.DispatchCompute(cs, kernel, xcount, ycount, 1); }
/// <summary> /// Configure the pass with the source and destination to execute on. /// </summary> /// <param name="source">Source Render Target</param> /// <param name="destination">Destination Render Target</param> public void Setup(RenderTargetIdentifier source, RenderTargetHandle destination) { this.source = source; this.destination = destination; }
public static void RenderNormals(this IRenderPass2D pass, ScriptableRenderContext context, RenderingData renderingData, DrawingSettings drawSettings, FilteringSettings filterSettings, RenderTargetIdentifier depthTarget, CommandBuffer cmd, LightStats lightStats) { using (new ProfilingScope(cmd, m_ProfilingSampler)) { // figure out the scale var normalRTScale = 0.0f; if (depthTarget != BuiltinRenderTextureType.None) { normalRTScale = 1.0f; } else { normalRTScale = Mathf.Clamp(pass.rendererData.lightRenderTextureScale, 0.01f, 1.0f); } pass.CreateNormalMapRenderTexture(renderingData, cmd, normalRTScale); if (depthTarget != BuiltinRenderTextureType.None) { cmd.SetRenderTarget( pass.rendererData.normalsRenderTarget.Identifier(), RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store, depthTarget, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store); } else { cmd.SetRenderTarget(pass.rendererData.normalsRenderTarget.Identifier(), RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store); } cmd.ClearRenderTarget(false, true, k_NormalClearColor); context.ExecuteCommandBuffer(cmd); cmd.Clear(); drawSettings.SetShaderPassName(0, k_NormalsRenderingPassName); context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filterSettings); } }