Exemplo n.º 1
0
    void RenderObjects(ScriptableRenderContext renderContext, CommandBuffer cmd, Material overrideMaterial, int passIndex, CompareFunction depthCompare, CullingResults cullingResult, HDCamera hdCamera, StencilState?overrideStencil = null)
    {
        // Render the objects in the layer blur mask into a mask buffer with their materials so we keep the alpha-clip and transparency if there is any.
        var result = new UnityEngine.Rendering.RendererUtils.RendererListDesc(shaderTags, cullingResult, hdCamera.camera)
        {
            rendererConfiguration      = PerObjectData.None,
            renderQueueRange           = RenderQueueRange.all,
            sortingCriteria            = SortingCriteria.BackToFront,
            excludeObjectMotionVectors = false,
            overrideMaterial           = overrideMaterial,
            overrideMaterialPassIndex  = passIndex,
            layerMask  = seeThroughLayer,
            stateBlock = new RenderStateBlock(RenderStateMask.Depth)
            {
                depthState = new DepthState(true, depthCompare)
            },
        };

        if (overrideStencil != null)
        {
            var block = result.stateBlock.Value;
            block.mask        |= RenderStateMask.Stencil;
            block.stencilState = overrideStencil.Value;
            result.stateBlock  = block;
        }

        CoreUtils.DrawRendererList(renderContext, cmd, renderContext.CreateRendererList(result));
    }
        void ExecuteNormalBufferBlur(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, RTHandle cameraColor, RTHandle cameraDepth, RTHandle cameraNormal, CullingResults cullingResults)
        {
            if (!EnsureMaterial(ref passMaterial, NAME_SHADER))
            {
                return;
            }

            if (layerMask == 0)
            {
                return;
            }

            if (!hdCamera.frameSettings.IsEnabled(FrameSettingsField.Decals))
            {
                return;
            }

            int bufferW = cameraColor.rt.width;
            int bufferH = cameraColor.rt.height;

            // allocate temporary buffers
            cmd.GetTemporaryRT(rtRegions, bufferW, bufferH, (int)DepthBits.None, FilterMode.Point, RenderTextureFormat.R8, RenderTextureReadWrite.Linear, 1, false);
            cmd.GetTemporaryRT(rtDecoded, bufferW, bufferH, (int)DepthBits.None, FilterMode.Point, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear, 1, false);

            // render decals to mark blur regions
            CoreUtils.SetRenderTarget(cmd,
                                      rtRegions, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
                                      cameraDepth, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store,
                                      ClearFlag.Color, Color.white
                                      );
            CoreUtils.SetViewport(cmd, cameraDepth);

            RendererListDesc renderListDesc = new RendererListDesc(NAME_PASS_REPLACE_TAG, cullingResults, hdCamera.camera)
            {
                rendererConfiguration      = PerObjectData.None,
                renderQueueRange           = GetRenderQueueRange(queue),
                sortingCriteria            = SortingCriteria.None,
                layerMask                  = layerMask,
                overrideMaterial           = passMaterial,
                overrideMaterialPassIndex  = PASS_MARK,
                stateBlock                 = null,
                excludeObjectMotionVectors = false,
            };

#if UNITY_2021_2_OR_NEWER
            CoreUtils.DrawRendererList(renderContext, cmd, renderContext.CreateRendererList(renderListDesc));
#elif UNITY_2020_2_OR_NEWER
            CoreUtils.DrawRendererList(renderContext, cmd, RendererList.Create(renderListDesc));
#else
            HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(renderListDesc));
#endif

            // decode normal buffer in marked regions
            CoreUtils.SetRenderTarget(cmd,
                                      rtDecoded, RenderBufferLoadAction.DontCare, RenderBufferStoreAction.Store,
                                      cameraDepth, RenderBufferLoadAction.Load, RenderBufferStoreAction.DontCare,
                                      ClearFlag.None
                                      );
            CoreUtils.SetViewport(cmd, cameraDepth);

            cmd.SetRandomWriteTarget(2, cameraNormal);
            cmd.DrawProcedural(Matrix4x4.identity, passMaterial, PASS_DECODE, MeshTopology.Triangles, 3, 1);
            cmd.ClearRandomWriteTargets();

            // blur and re-encode normals in marked regions
            cmd.SetGlobalTexture(rtRegions, rtRegions);
            cmd.SetGlobalTexture(rtDecoded, rtDecoded);

            if (dbufferNormalMaskRTIDs != null)
            {
                CoreUtils.SetRenderTarget(cmd,
                                          dbufferNormalMaskRTIDs,
                                          cameraDepth,
                                          ClearFlag.None);
                CoreUtils.SetViewport(cmd, cameraDepth);

                cmd.SetRandomWriteTarget(2, cameraNormal);
                cmd.DrawProcedural(Matrix4x4.identity, passMaterial, PASS_BLUR_AND_ENCODE_AND_DECAL, MeshTopology.Triangles, 3, 1);
                cmd.ClearRandomWriteTargets();
            }
            else
            {
                CoreUtils.SetRenderTarget(cmd,
                                          cameraDepth, RenderBufferLoadAction.Load, RenderBufferStoreAction.Store,
                                          ClearFlag.None
                                          );
                CoreUtils.SetViewport(cmd, cameraDepth);

                cmd.SetRandomWriteTarget(2, cameraNormal);
                cmd.DrawProcedural(Matrix4x4.identity, passMaterial, PASS_BLUR_AND_ENCODE, MeshTopology.Triangles, 3, 1);
                cmd.ClearRandomWriteTargets();
            }

            // free temporary buffers
            cmd.ReleaseTemporaryRT(rtRegions);
            cmd.ReleaseTemporaryRT(rtDecoded);
        }