BacteriumFox
BacteriumFox

URP深度法线纹理

深度法线纹理

前言

在Built-in管线下我们对深度纹理与深度法线纹理获取方式是直接通过设置摄像机和Shader全局纹理获取的，在URP下深度纹理依旧可以这样获取，但深度法线纹理在URP10版本才支持，使用URP的前置条件是升级到Unity2020版本。所以当前在Unity2019版本下是无法直接获取深度法线纹理的，但我们可以通过一些其他手段来自定义我们的深度法线纹理。

全局雾（深度纹理）

为什么将全局雾与高度雾放一起讲呢，因为在《Shader入门精要》一书中，对全局雾的讲解是使用深度纹理反向重建顶点的世界坐标。所以在实现全局雾的过程中，我们需要使用到深度纹理。

效果图

思路

  1. 我们需要和Built-in管线下一样，开启摄像机的深度纹理渲染，默认情况下摄像机的深度纹理渲染是跟随渲染管线的，所以我们需要开启渲染管线的深度纹理渲染。

开启深度纹理渲染后，即可在Frame Debug下看到渲染增加了Copy Depth流程，由于深度纹理占用的是R通道，所以纹理面板呈现红色和黑色（图中的红色比较浅，需要仔细看，红色深度是由物体和摄像机距离决定的，距离越近，颜色越深）

  1. 创建Shader——FogWithDepthTexture，在Shader中没有什么新语法，基本就是将CG语法的Shader翻译一下。

    需要注意的是我们使用了float4 _MainTex_ST;与_MainTex_TexelSize;，前者是主纹理的偏移与缩放，后者是纹理的大小，用于校验是否需要翻转坐标。

    再者是LinearEyeDepth在URP下需要我们传入线性缓冲值才能计算，该参数为_ZBufferParams，由相机参数获取而来：x 是 (1-远/近)，y 是 (远/近)，z 是 (x/远)，w 是 (y/远)。

  2. 既然是后处理脚本，自然需要集成到Volume框架中。

    • 创建FogWithDepthTexture.cs，继承VolumeComponent与IPostProcessComponent接口，用于获取属性参数
    • 修改AdditionalPostProcessData.cs和AdditionalMaterialLibrary.cs，以方便获取Shader与材质。
    • 修改AdditionPostProcessPass.cs，修改void Render(CommandBuffer cmd, ref RenderingData renderingData)方法和增加方法void SetFogWithDepthTexture(CommandBuffer cmd, Material uberMaterial, CameraData cameraData)。参考入门精要，我们可以得知想要在Shader重构世界坐标，则需要我们将近裁剪平面的4个角对应的向量传入Shader中，那么我们则需要实现在Render方法中从参数renderingData中获取到当前的渲染相机，并传入我们的新增方法进行计算。
    • 最后不要忘记将Shader赋值给管线中的AdditionalPostProcessData对象，然后就可以在Voloume组件中添加雾效了。

描边（深度法线纹理）

描边效果的实现需要我们对像素的法线、深度和邻近像素进行比较计算，以此来确定该像素是否是物体的边缘，那么这就需要用到我们的深度法线纹理。由于URP某些版本下不支持深度法线纹理（本章开头有提到），所以需要我们自己造轮子。流程上比较杂，慢慢研究吧。

效果图

思路

扩展管线功能

思路上参考当前比较常见的作法，在URP管线下，阴影渲染后和URP自带深度渲染前插入我们的自定义Pass进行深度法线纹理绘制。该Pass通过调用Built-in管线下的Shader——"Hidden/Internal-DepthNormalsTexture"进行渲染。（没错，我们在URP下使用Built-in管线的Shader，因为它方便，不然你可以看下这个Shader的源码，就知道有多复杂）最后再将绘制出来的纹理设置成管线的全局纹理，方便后续的自定义Pass渲染下的其他Shader使用。

  1. 创建DepthNormalsFeature.cs，继承自ScriptableRendererFeature，然后在URP管线的配置文件对象中添加该功能（不理解的可以看上一章博客）。
  2. 该类的逻辑我在代码中都有备注，但部分都是瞎蒙的，毕竟我也是个菜鸡，再就是逻辑上一些写法和自定义管线设置有较大关联，可以参考我之前写的SRP尝试博客。
  3. 在类中有个Shader标签，需要特别注意，该标签名后需要和场景中物体的ShaderPass标签相互配合使用，下面会讲到
ShaderTagId m_ShaderTagId = new ShaderTagId("DepthOnly");

"DepthOnly"Pass

在场景物体渲染Shader中，我们需要增加对应的一个“DepthOnly”Pass，用于给我们上步创建的管线功能进行深度纹理渲染。

  1. 该Pass可参考我们之前写的多光源阴影处理的"ShadowCaster"Pass，改动上只是去除了阴影坐标转换。为方便，场景中物体使用的Shader，暂时由我们之前的标准光照模型使用Shader扩展而来，取名为StandardLightDepthPass。

  2. 上一步我们提到过，管线扩展功能中有个Shader标签，我们在写“DepthOnly”Pass时需要将LightMode设置成对应的标签，否则在深度法线纹理中，该物体不会被绘制。

Tags { "LightMode" = "DepthOnly" }

  1. 不出意外的话，我们已经可以通过帧调试器看到我们所绘制的深度法线纹理了。注意观察，可以看到绘制时机在阴影绘制后和深度绘制前。

扩展Volume框架

既然获取法线深度纹理的前置条件都完成了，接下来就是实现我们的描边效果了。同样的作为后处理效果，我们需要集成到Volume框架中，流程也还是那几步：Shader、对应的属性参数组件、修改AdditionPostProcessPass类和AdditionalPostProcessData类、AdditionalMaterialLibrary类。

  1. 创建Shader——EdgeDetectionNormalsAndDepth，同样的该Shader由入门精要下的描边Shader翻译而来，语法上只有一个DecodeFloatRG解码RG颜色方法需要我们自己实现一下，思路上不做过多追究，代码已经实现了。

需要注意的是，从深度法线纹理中获取到的深度亮度值相比直接从深度纹理获取到的不够高，需要将获取到的深度值*1000以提升亮度

  1. 创建属性参数类——EdgeDetectionNormalsAndDepth.cs，集成Volume框架，并实现Shader所需的各种属性参数，操作和之前一样，这里就不过多讲解了。
  2. 修改AdditionalPostProcessData.cs和AdditionalMaterialLibrary.cs，以方便获取Shader与材质。
  3. 修改AdditionPostProcessPass.cs，修改void Render(CommandBuffer cmd, ref RenderingData renderingData)方法和增加方法void SetEdgeDetectionNormalsAndDepth(CommandBuffer cmd, Material uberMaterial)。参考入门精要的逻辑，我们只需要将属性参数类中的参数传入Shader即可。
  4. 最后将Shader赋值给管线中的AdditionalPostProcessData对象，然后就可以在Voloume组件中添加描边效果。

完整代码

全局雾

Shader

Shader "URP/Fog With Depth Texture"
{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" { }
        // 雾效浓度
        _FogDensity ("Fog Density", Float) = 1.0
        // 雾效颜色
        _FogColor ("Fog Color", Color) = (1, 1, 1, 1)
        // 雾效起始高度
        _FogStart ("Fog Start", Float) = 0.0
        // 雾效终止高度
        _FogEnd ("Fog End", Float) = 1.0
    }
    SubShader
    {
        Tags { "RenderPipeline" = "UniversalPipeline" }
        
        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        
        CBUFFER_START(UnityPerMaterial)
        // 近裁剪平面的四个角对应的向量
        float4x4 _FrustumCornersRay;
        
        float4 _MainTex_ST;
        float4 _MainTex_TexelSize;
        half _FogDensity;
        half4 _FogColor;
        float _FogStart;
        float _FogEnd;
        CBUFFER_END
        
        
        // 声明深度纹理，注意该名称是指定的
        TEXTURE2D(_CameraDepthTexture);
        SAMPLER(sampler_CameraDepthTexture);
        
        // 声明纹理
        TEXTURE2D(_MainTex);
        SAMPLER(sampler_MainTex);
        
        struct a2v
        {
            float4 vertex: POSITION;
            float4 texcoord: TEXCOORD0;
        };
        
        struct v2f
        {
            float4 pos: SV_POSITION;
            half2 uv: TEXCOORD0;
            half2 uv_depth: TEXCOORD1;
            // 用于存储插值后的像素向量
            float4 interpolatedRay: TEXCOORD2;
        };
        
        v2f vert(a2v v)
        {
            v2f o;
            o.pos = TransformObjectToHClip(v.vertex.xyz);
            
            o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
            o.uv_depth = o.uv;
            
            // 检测DirectX平台
            #if UNITY_UV_STARTS_AT_TOP
                // 检测Unity是否已自动翻转了坐标
                if (_MainTex_TexelSize.y < 0)
                    o.uv_depth.y = 1 - o.uv_depth.y;
            #endif
            
            int index = 0;
            if(v.texcoord.x < 0.5 && v.texcoord.y < 0.5)
            {
                index = 0;
            }
            else if(v.texcoord.x > 0.5 && v.texcoord.y < 0.5)
            {
                index = 1;
            }
            else if(v.texcoord.x > 0.5 && v.texcoord.y > 0.5)
            {
                index = 2;
            }
            else
            {
                index = 3;
            }
            
            // 检测DirectX平台
            #if UNITY_UV_STARTS_AT_TOP
                // 检测Unity是否已自动翻转了坐标
                if (_MainTex_TexelSize.y < 0)
                    index = 3 - index;
            #endif
            
            // 使用索引值获取四个顶点变量中对应顶点作为插值后的像素向量
            o.interpolatedRay = _FrustumCornersRay[index];
            
            return o;
        }
        
        half4 frag(v2f i): SV_Target
        {
            // 视角空间下的线性深度值  LinearEyeDepth：线性转换 SAMPLE_DEPTH_TEXTURE：深度纹理采样
            //float linearDepth = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv_depth));
            float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, sampler_CameraDepthTexture, i.uv_depth);
            // 通过相机的深度缓冲值计算当前像素深度 _ZBufferParams：用于线性化 Z 缓冲区值。
            float linearDepth = LinearEyeDepth(depth, _ZBufferParams) ;
            // 世界空间下的深度值    _WorldSpaceCameraPos：世界空间下相机位置
            float3 worldPos = _WorldSpaceCameraPos + linearDepth * i.interpolatedRay.xyz;
            
            // 高度雾效系数 = （终止高度 - 当前像素高度）/（终止高度 - 起始高度）
            float fogDensity = (_FogEnd - worldPos.y) / (_FogEnd - _FogStart);
            // 计算浓度     saturate：截取到0-1
            fogDensity = saturate(fogDensity * _FogDensity);
            
            // 原始颜色
            half4 finalColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv);
            // 插值原始颜色，与雾效颜色，使用雾效系数作为参数
            finalColor.rgb = lerp(finalColor.rgb, _FogColor.rgb, fogDensity);
            
            return finalColor;
        }
        
        ENDHLSL
        
        Pass
        {
            Tags { "RenderPipeline" = "UniversalPipeline" }
            ZTest Always Cull Off ZWrite Off
            
            HLSLPROGRAM
            
            #pragma vertex vert
            #pragma fragment frag
            
            ENDHLSL
            
        }
    }
    FallBack Off
}

属性参数组件

using System;

// 通用渲染管线程序集
namespace UnityEngine.Rendering.Universal
{
    // 实例化类     添加到Volume组件菜单中
    [Serializable, VolumeComponentMenu("Addition-Post-processing/FogWithDepthTexture")]
    // 集成VolumeComponent组件和IPostProcessComponent接口，用以继承Volume框架
    public class FogWithDepthTexture : VolumeComponent, IPostProcessComponent
    {
        // 在框架下的属性与Unity常规属性不一样，例如 Int 由 ClampedIntParameter 取代。

        [Tooltip("开关")]
        public BoolParameter _Switch = new BoolParameter(false);

        [Tooltip("密度")]
        public ClampedFloatParameter fogDensity = new ClampedFloatParameter(1f, 0, 100);
        [Tooltip("颜色")]
        public ColorParameter fogColor = new ColorParameter(Color.gray);
        [Tooltip("起始高度")]
        public ClampedFloatParameter fogStart = new ClampedFloatParameter(0f, -50f, 50);
        [Tooltip("终止高度")]
        public ClampedFloatParameter fogEnd = new ClampedFloatParameter(0f, -50f, 50);


        // 实现接口
        public bool IsActive() => _Switch.value;

        public bool IsTileCompatible()
        {
            return false;
        }
    }

}

修改AdditionalPostProcessData与AdditionalMaterialLibrary

using System;

namespace UnityEngine.Rendering.Universal
{
    /// 
    /// 附加后处理数据
    /// 
    [Serializable]
    public class AdditionalPostProcessData : ScriptableObject
    {
        [Serializable]
        public sealed class Shaders
        {
            public Shader brightnessSaturationContrast;
            public Shader fogWithDepthTexture;
        }
        public Shaders shaders;
    }   
}

namespace UnityEngine.Rendering.Universal
{
    /// 
    /// 材质列表
    /// 
    public class AdditionalMaterialLibrary
    {
        public readonly Material brightnessSaturationContrast;
        public readonly Material fogWithDepthTexture;

        /// 
        /// 初始化时从配置文件中获取材质
        /// 
        /// 
        public AdditionalMaterialLibrary(AdditionalPostProcessData data)
        {
            brightnessSaturationContrast = Load(data.shaders.brightnessSaturationContrast);
            fogWithDepthTexture = Load(data.shaders.fogWithDepthTexture);
        }

        Material Load(Shader shader)
        {
            if (shader == null)
            {
                Debug.LogErrorFormat($"丢失 shader. {GetType().DeclaringType.Name} 渲染通道将不会执行。检查渲染器资源中是否缺少引用。");
                return null;
            }
            else if (!shader.isSupported)
            {
                return null;
            }
            return CoreUtils.CreateEngineMaterial(shader);
        }

        internal void Cleanup()
        {
            CoreUtils.Destroy(brightnessSaturationContrast);
        }
    }
}

修改AdditionPostProcessPass

using UnityEngine.Experimental.Rendering;

namespace UnityEngine.Rendering.Universal
{
    /// 
    /// 附加的后处理Pass
    /// 
    public class AdditionPostProcessPass : ScriptableRenderPass
    {
        //标签名，用于续帧调试器中显示缓冲区名称
        const string CommandBufferTag = "AdditionalPostProcessing Pass";

        // 用于后处理的材质
        Material m_BlitMaterial;
        AdditionalMaterialLibrary m_Materials;
        AdditionalPostProcessData m_Data;

        // 主纹理信息
        RenderTargetIdentifier m_Source;
        // 深度信息
        RenderTargetIdentifier m_Depth;
        // 当前帧的渲染纹理描述
        RenderTextureDescriptor m_Descriptor;
        // 目标相机信息
        RenderTargetHandle m_Destination;

        // 临时的渲染目标
        RenderTargetHandle m_TemporaryColorTexture01;


        // 属性参数组件
        BrightnessSaturationContrast m_BrightnessSaturationContrast;
        FogWithDepthTexture m_FogWithDepthTexture;
        EdgeDetectionNormalsAndDepth m_EdgeDetectionNormalsAndDepth;


        public AdditionPostProcessPass(RenderPassEvent evt, AdditionalPostProcessData data, Material blitMaterial = null)
        {
            renderPassEvent = evt;
            m_Data = data;
            m_Materials = new AdditionalMaterialLibrary(data);
            m_BlitMaterial = blitMaterial;
        }

        public void Setup(in RenderTextureDescriptor baseDescriptor, in RenderTargetIdentifier source, in RenderTargetIdentifier depth, in RenderTargetHandle destination)
        {
            m_Descriptor = baseDescriptor;
            m_Source = source;

            m_Depth = depth;
            m_Destination = destination;
        }


        /// 
        /// URP会自动调用该执行方法
        /// 
        /// 
        /// 
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            // 从Volume框架中获取所有堆栈
            var stack = VolumeManager.instance.stack;
            // 从堆栈中查找对应的属性参数组件
            m_BrightnessSaturationContrast = stack.GetComponent();
            m_FogWithDepthTexture = stack.GetComponent();
            m_EdgeDetectionNormalsAndDepth = stack.GetComponent();

            // 从命令缓冲区池中获取一个带标签的渲染命令，该标签名可以在后续帧调试器中见到
            var cmd = CommandBufferPool.Get(CommandBufferTag);

            // 调用渲染函数
            Render(cmd, ref renderingData);

            // 执行命令缓冲区
            context.ExecuteCommandBuffer(cmd);
            // 释放命令缓存
            CommandBufferPool.Release(cmd);
        }

        // 渲染
        void Render(CommandBuffer cmd, ref RenderingData renderingData)
        {
            ref var cameraData = ref renderingData.cameraData;
            bool m_IsStereo = renderingData.cameraData.isStereoEnabled;
            bool isSceneViewCamera = cameraData.isSceneViewCamera;

            // VolumeComponent是否开启，且非Scene视图摄像机
            if (m_BrightnessSaturationContrast.IsActive() && !isSceneViewCamera)
            {
                SetBrightnessSaturationContrast(cmd, m_Materials.brightnessSaturationContrast);
            }
            // VolumeComponent是否开启，且非Scene视图摄像机
            if (m_FogWithDepthTexture.IsActive() && !isSceneViewCamera)
            {
                SetFogWithDepthTexture(cmd, m_Materials.fogWithDepthTexture, cameraData);
            }
        }

        RenderTextureDescriptor GetStereoCompatibleDescriptor(int width, int height, int depthBufferBits = 0)
        {
            var desc = m_Descriptor;
            desc.depthBufferBits = depthBufferBits;
            desc.msaaSamples = 1;
            desc.width = width;
            desc.height = height;
            return desc;
        }



        #region 处理材质渲染
        // 亮度、饱和度、对比度渲染
        void SetBrightnessSaturationContrast(CommandBuffer cmd, Material uberMaterial)
        {
            // 写入参数
            uberMaterial.SetFloat("_Brightness", m_BrightnessSaturationContrast.brightness.value);
            uberMaterial.SetFloat("_Saturation", m_BrightnessSaturationContrast.saturation.value);
            uberMaterial.SetFloat("_Contrast", m_BrightnessSaturationContrast.contrast.value);

            // 通过目标相机的渲染信息创建临时缓冲区
            //RenderTextureDescriptor opaqueDesc = m_Descriptor;
            //opaqueDesc.depthBufferBits = 0;
            //cmd.GetTemporaryRT(m_TemporaryColorTexture01.id, opaqueDesc);
            //or
            int tw = m_Descriptor.width;
            int th = m_Descriptor.height;
            var desc = GetStereoCompatibleDescriptor(tw, th);
            cmd.GetTemporaryRT(m_TemporaryColorTexture01.id, desc, FilterMode.Bilinear);

            // 通过材质，将计算结果存入临时缓冲区
            cmd.Blit(m_Source, m_TemporaryColorTexture01.Identifier(), uberMaterial);
            // 再从临时缓冲区存入主纹理
            cmd.Blit(m_TemporaryColorTexture01.Identifier(), m_Source);

            // 释放临时RT
            cmd.ReleaseTemporaryRT(m_TemporaryColorTexture01.id);
        }
        // 全局高度雾
        void SetFogWithDepthTexture(CommandBuffer cmd, Material uberMaterial, CameraData cameraData)
        {
            Matrix4x4 frustumCorners = Matrix4x4.identity;
            Camera camera = cameraData.camera;
            // FOV是相机的竖直方向的视角范围
            float fov = camera.fieldOfView;
            // Near是相机的近裁剪平面的距离
            float near = camera.nearClipPlane;
            // Aspect是相机的宽高比（宽度除以高度）
            float aspect = camera.aspect;

            // 近裁剪面中心
            float halfHeight = near * Mathf.Tan(fov * 0.5f * Mathf.Deg2Rad);
            // 相机正右方
            Vector3 toRight = camera.transform.right * halfHeight * aspect;
            // 相机正上方
            Vector3 toTop = camera.transform.up * halfHeight;

            // 左上角相对于相机的方向
            Vector3 topLeft = camera.transform.forward * near + toTop - toRight;

            float scale = topLeft.magnitude / near;

            topLeft.Normalize();
            // 左上角距离摄像机的欧式距离dist
            topLeft *= scale;

            Vector3 topRight = camera.transform.forward * near + toRight + toTop;
            topRight.Normalize();
            topRight *= scale;

            Vector3 bottomLeft = camera.transform.forward * near - toTop - toRight;
            bottomLeft.Normalize();
            bottomLeft *= scale;

            Vector3 bottomRight = camera.transform.forward * near + toRight - toTop;
            bottomRight.Normalize();
            bottomRight *= scale;

            // 将近裁剪平面的四个角对应的向量存储到矩阵类型的变量中（存入顺序是非常重要的）
            frustumCorners.SetRow(0, bottomLeft);
            frustumCorners.SetRow(1, bottomRight);
            frustumCorners.SetRow(2, topRight);
            frustumCorners.SetRow(3, topLeft);

            // 将参数写入材质
            uberMaterial.SetMatrix("_FrustumCornersRay", frustumCorners);

            // 写入参数
            uberMaterial.SetFloat("_FogDensity", m_FogWithDepthTexture.fogDensity.value);
            uberMaterial.SetColor("_FogColor", m_FogWithDepthTexture.fogColor.value);
            uberMaterial.SetFloat("_FogStart", m_FogWithDepthTexture.fogStart.value);
            uberMaterial.SetFloat("_FogEnd", m_FogWithDepthTexture.fogEnd.value);

            int tw = m_Descriptor.width;
            int th = m_Descriptor.height;
            var desc = GetStereoCompatibleDescriptor(tw, th);
            cmd.GetTemporaryRT(m_TemporaryColorTexture01.id, desc);

            // 通过材质，将计算结果存入临时缓冲区
            cmd.Blit(m_Source, m_TemporaryColorTexture01.Identifier(), uberMaterial);
            // 再从临时缓冲区存入主纹理
            cmd.Blit(m_TemporaryColorTexture01.Identifier(), m_Source);

            // 释放临时RT
            cmd.ReleaseTemporaryRT(m_TemporaryColorTexture01.id);
        }
        #endregion
    }
}

描边

DepthNormalsFeature

using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class DepthNormalsFeature : ScriptableRendererFeature
{
    class DepthNormalsPass : ScriptableRenderPass
    {
        // 深度缓冲块大小
        int kDepthBufferBits = 32;
        /// 深度法线纹理
        private RenderTargetHandle depthAttachmentHandle { get; set; }
        /// 目标相机渲染信息
        internal RenderTextureDescriptor descriptor { get; private set; }

        /// 材质
        private Material depthNormalsMaterial = null;
        /// 筛选设置
        private FilteringSettings m_FilteringSettings;

        // 该Pass在帧分析器显示的标签
        string m_ProfilerTag = "Depth Normals Pre Pass";
        // Pass绘制标签，在Shader中只有声明了相同绘制标签的Pass才能被调用绘制
        ShaderTagId m_ShaderTagId = new ShaderTagId("DepthOnly");

        /// 
        /// 构造函数
        /// 
        /// 渲染队列
        /// 渲染对象层级
        /// 材质
        public DepthNormalsPass(RenderQueueRange renderQueueRange, LayerMask layerMask, Material material)
        {
            m_FilteringSettings = new FilteringSettings(renderQueueRange, layerMask);
            depthNormalsMaterial = material;
        }

        /// 
        /// 参数设置
        /// 
        /// 目标相机渲染信息
        /// 深度法线纹理
        public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle depthAttachmentHandle)
        {
            // 设置纹理
            this.depthAttachmentHandle = depthAttachmentHandle;
            // 设置渲染目标信息
            baseDescriptor.colorFormat = RenderTextureFormat.ARGB32;
            baseDescriptor.depthBufferBits = kDepthBufferBits;
            descriptor = baseDescriptor;
        }

        // 该方法在执行渲染通道之前被调用。
        // 它可以用来配置渲染目标和它们的清除状态。也创建临时渲染目标纹理。
        // 当为空时，这个渲染通道将渲染到激活的摄像机渲染目标。
        // 你不应该调用CommandBuffer.SetRenderTarget。调用ConfigureTarget and  configurecclear 。
        // 渲染管道将确保目标设置和清除以性能方式进行。
        public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
        {
            // 获取一个临时RT（深度法线纹理、目标信息、滤波模式）
            cmd.GetTemporaryRT(depthAttachmentHandle.id, descriptor, FilterMode.Point);
            // 配置目标
            ConfigureTarget(depthAttachmentHandle.Identifier());
            // 清楚未渲染配置为黑色
            ConfigureClear(ClearFlag.All, Color.black);
        }

        //这里你可以实现渲染逻辑。
        //使用ScriptableRenderContext来发出绘图命令或执行命令缓冲区
        // https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
        //你不必调用ScriptableRenderContext。提交时，渲染管道会在管道中的特定点调用它。
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            // 获取命令缓冲区
            CommandBuffer cmd = CommandBufferPool.Get(m_ProfilerTag);

            using (new ProfilingScope(cmd, new ProfilingSampler(m_ProfilerTag)))
            {
                // 执行命令缓存
                context.ExecuteCommandBuffer(cmd);
                // 清楚数据缓存
                cmd.Clear();

                // 相机的排序标志
                var sortFlags = renderingData.cameraData.defaultOpaqueSortFlags;
                // 创建绘制设置
                var drawSettings = CreateDrawingSettings(m_ShaderTagId, ref renderingData, sortFlags);
                // 设置对象数据
                drawSettings.perObjectData = PerObjectData.None;

                // 检测是否是VR设备
                ref CameraData cameraData = ref renderingData.cameraData;
                Camera camera = cameraData.camera;
                if (cameraData.isStereoEnabled)
                    context.StartMultiEye(camera);

                // 设置覆盖材质
                drawSettings.overrideMaterial = depthNormalsMaterial;

                // 绘制渲染器
                context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref m_FilteringSettings);

                // 设置全局纹理
                cmd.SetGlobalTexture("_CameraDepthNormalsTexture", depthAttachmentHandle.id);
            }
            // 执行命令缓冲区
            context.ExecuteCommandBuffer(cmd);
            // 释放命令缓冲区
            CommandBufferPool.Release(cmd);
        }

        // 清除此呈现传递执行期间创建的任何已分配资源。
        public override void FrameCleanup(CommandBuffer cmd)
        {
            if (depthAttachmentHandle != RenderTargetHandle.CameraTarget)
            {
                cmd.ReleaseTemporaryRT(depthAttachmentHandle.id);
                depthAttachmentHandle = RenderTargetHandle.CameraTarget;
            }
        }
    }
    // 深度法线Pass
    DepthNormalsPass depthNormalsPass;
    // 深度法线纹理
    RenderTargetHandle depthNormalsTexture;
    // 处理材质
    Material depthNormalsMaterial;

    public override void Create()
    {
        // 通过Built-it管线中的Shader创建材质
        depthNormalsMaterial = CoreUtils.CreateEngineMaterial("Hidden/Internal-DepthNormalsTexture");
        // 获取Pass（渲染队列，渲染对象，材质）
        depthNormalsPass = new DepthNormalsPass(RenderQueueRange.opaque, -1, depthNormalsMaterial);
        // 设置渲染时机 = 预渲染通道后
        depthNormalsPass.renderPassEvent = RenderPassEvent.AfterRenderingPrePasses;
        // 设置纹理名
        depthNormalsTexture.Init("_CameraDepthNormalsTexture");
    }

    //这里你可以在渲染器中注入一个或多个渲染通道。
    //这个方法在设置渲染器时被调用。
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {
        // 对Pass进行参数设置（当前渲染相机信息，深度法线纹理）
        depthNormalsPass.Setup(renderingData.cameraData.cameraTargetDescriptor, depthNormalsTexture);
        // 写入渲染管线队列
        renderer.EnqueuePass(depthNormalsPass);
    }
}

物体Shader_StandardLightDepthPass

Shader "URP/StandardLightDepthPass"
{
    Properties
    {
        // 基础纹理
        [MainColor] _BaseColor ("Color", Color) = (0.5, 0.5, 0.5, 1)
        [MainTexture] _BaseMap ("Albedo", 2D) = "white" { }
        
        // 透明度裁剪
        [Toggle(_ALPHATEST_ON)] _EnableAlphaTest ("Alpha Cutoff", Float) = 0.0
        _Cutoff ("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
        
        // 法线贴图
        [Toggle(_NORMALMAP)] _EnableBumpMap ("Bump Map", Float) = 0.0
        _BumpScale ("Normal Scale", Float) = 1.0
        _BumpMap ("Normal Map", 2D) = "bump" { }
        
        // 漫反射叠加颜色
        _Diffuse ("Diffuse", Color) = (1, 1, 1, 1)
        // 高光反射叠加颜色
        _Specular ("Specular", Color) = (1, 1, 1, 1)
        // 高光系数
        _Gloss ("Gloss", Range(8.0, 256)) = 20
        
        // 是否计算多光源
        [Toggle(_AdditionalLights)] _AddLights ("AddLights", Float) = 1
    }
    SubShader
    {
        Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline" }
             LOD 300
        
        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        
        CBUFFER_START(UnityPerMaterial)
        float4 _BaseColor;
        float4 _BaseMap_ST;
        half _Cutoff;
        float4 _BumpMap_ST;
        float _BumpScale;
        float4 _Diffuse;
        float4 _Specular;
        float _Gloss;
        CBUFFER_END
        ENDHLSL
        
        Pass
        {
            Tags { "LightMode" = "UniversalForward" }
            Cull Off
            HLSLPROGRAM
            
            // 设置关键字
            #pragma shader_feature _NORMALMAP
            #pragma shader_feature _ALPHATEST_ON
            #pragma shader_feature _AdditionalLights
            
            // 接收阴影所需关键字
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
            #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
            #pragma multi_compile _ _SHADOWS_SOFT
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
            
            
            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);
            TEXTURE2D(_BumpMap);
            SAMPLER(sampler_BumpMap);
            
            
            struct Attributes
            {
                float4 positionOS: POSITION;//位置
                float3 normalOS: NORMAL;//法线
                float4 tangentOS: TANGENT;//切线
                float2 texcoord: TEXCOORD0;//纹理坐标
            };
            
            struct Varyings
            {
                float4 positionCS: SV_POSITION;
                float2 uv: TEXCOORD0;
                float3 positionWS: TEXCOORD1;
                
                #ifdef _NORMALMAP//如果使用了法线贴图
                    float4 normalWS: TEXCOORD3;    // xyz: normal, w: viewDir.x
                    float4 tangentWS: TEXCOORD4;    // xyz: tangent, w: viewDir.y
                    float4 bitangentWS: TEXCOORD5;    // xyz: bitangent, w: viewDir.z
                #else
                    float3 normalWS: TEXCOORD3;
                    float3 viewDirWS: TEXCOORD4;
                #endif
            };
            
            
            
            Varyings vert(Attributes v)
            {
                Varyings o;
                // 获取不同空间下坐标信息
                VertexPositionInputs positionInputs = GetVertexPositionInputs(v.positionOS.xyz);
                o.positionCS = positionInputs.positionCS;
                o.positionWS = positionInputs.positionWS;
                
                
                o.uv = TRANSFORM_TEX(v.texcoord, _BaseMap);
                
                // 获取世界空间下法线相关向量
                VertexNormalInputs normalInput = GetVertexNormalInputs(v.normalOS, v.tangentOS);
                // 视角方向
                half3 viewDirWS = GetCameraPositionWS() - positionInputs.positionWS;
                
                #ifdef _NORMALMAP// 如果使用了法线贴图
                    o.normalWS = half4(normalInput.normalWS, viewDirWS.x);
                    o.tangentWS = half4(normalInput.tangentWS, viewDirWS.y);
                    o.bitangentWS = half4(normalInput.bitangentWS, viewDirWS.z);
                #else
                    o.normalWS = NormalizeNormalPerVertex(normalInput.normalWS);
                    o.viewDirWS = viewDirWS;
                #endif
                
                return o;
            }
            
            /// albedo：反射系数
            /// lightColor：光源颜色
            /// lightDirectionWS：世界空间下光线方向
            /// lightAttenuation：光照衰减
            /// normalWS：世界空间下法线
            /// viewDirectionWS：世界空间下视角方向
            half3 LightingBased(half3 albedo, half3 lightColor, half3 lightDirectionWS, half lightAttenuation, half3 normalWS, half3 viewDirectionWS)
            {
                // 兰伯特漫反射计算
                half NdotL = saturate(dot(normalWS, lightDirectionWS));
                half3 radiance = lightColor * (lightAttenuation * NdotL) * _Diffuse.rgb;
                // BlinnPhong高光反射
                half3 halfDir = normalize(lightDirectionWS + viewDirectionWS);
                half3 specular = lightColor * pow(saturate(dot(normalWS, halfDir)), _Gloss) * _Specular.rgb;
                
                return(radiance + specular) * albedo;
            }
            // 计算漫反射与高光
            half3 LightingBased(half3 albedo, Light light, half3 normalWS, half3 viewDirectionWS)
            {
                // 注意light.distanceAttenuation * light.shadowAttenuation，这里已经将距离衰减与阴影衰减进行了计算
                return LightingBased(albedo, light.color, light.direction, light.distanceAttenuation * light.shadowAttenuation, normalWS, viewDirectionWS);
            }
            
            half4 frag(Varyings i): SV_Target
            {
                half3 viewDirWS ;
                half3 normalWS;
                
                #ifdef _NORMALMAP// 是否使用法线纹理
                    viewDirWS = half3(i.normalWS.w, i.tangentWS.w, i.bitangentWS.w);
                    //可以使用该方法替代下面的法线纹理采样，但是需要引用函数库ShaderLibrary/SurfaceInput.hlsl
                    //half3 normalTS = SampleNormal(i.uv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap), _BumpScale);
                    //or
                    half3 normalTS = UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, i.uv), _BumpScale);
                    normalWS = TransformTangentToWorld(normalTS, half3x3(i.tangentWS.xyz, i.bitangentWS.xyz, i.normalWS.xyz));
                #else
                    viewDirWS = i.viewDirWS;
                    normalWS = i.normalWS;
                #endif
                
                normalWS = NormalizeNormalPerPixel(normalWS);
                viewDirWS = SafeNormalize(viewDirWS);
                
                //纹理采样
                //可以使用该方法替代下面的纹理采集操作，但是需要引用函数库ShaderLibrary/SurfaceInput.hlsl
                //half4 albedoAlpha = SampleAlbedoAlpha(i.uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap));
                // or
                half4 albedoAlpha = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv);
                
                // 透明度裁剪
                //可以使用该方法替代下面的裁剪操作，但是需要引用函数库ShaderLibrary/SurfaceInput.hlsl
                //half alpha = Alpha(albedoAlpha.a, _BaseColor, _Cutoff);
                //or
                #if defined(_ALPHATEST_ON)
                    clip(albedoAlpha.a - _Cutoff);
                #endif
                
                // 漫反射系数
                //half3 albedo = albedoAlpha.rgb * _BaseColor.rgb;
                // or
                half3 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv).rgb * _BaseColor.rgb;
                
                // 获取阴影坐标
                float4 shadowCoord = TransformWorldToShadowCoord(i.positionWS.xyz);
                
                // 计算主光源与阴影
                Light mainLight = GetMainLight(shadowCoord);
                half3 diffuse = LightingBased(albedo, mainLight, normalWS, viewDirWS);
                
                // 计算其他光源与阴影
                // 需要将光源组件的ShadowType参数打开，并且将管线中的CastShadows勾选，副光源才会产生阴影
                #ifdef _AdditionalLights
                    uint pixelLightCount = GetAdditionalLightsCount();
                    for (uint lightIndex = 0u; lightIndex < pixelLightCount; ++ lightIndex)
                    {
                        Light light = GetAdditionalLight(lightIndex, i.positionWS);
                        diffuse += LightingBased(albedo, light, normalWS, viewDirWS);
                    }
                #endif
                
                // 计算环境光
                half3 ambient = SampleSH(normalWS) * albedo;
                return half4(ambient + diffuse, 1.0);
            }
            
            ENDHLSL
            
        }
        
        // 计算阴影的Pass
        Pass
        {
            Name "ShadowCaster"
            Tags { "LightMode" = "ShadowCaster" }
            Cull Off
            ZWrite On
            ZTest LEqual
            
            HLSLPROGRAM
            
            // 设置关键字
            #pragma shader_feature _ALPHATEST_ON
            
            #pragma vertex vert
            #pragma fragment frag
            
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/CommonMaterial.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Shadows.hlsl"
            
            float3 _LightDirection;
            
            struct Attributes
            {
                float4 positionOS: POSITION;
                float3 normalOS: NORMAL;
                float2 texcoord: TEXCOORD0;
            };
            
            struct Varyings
            {
                float2 uv: TEXCOORD0;
                float4 positionCS: SV_POSITION;
            };
            
            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);
            
            // 获取裁剪空间下的阴影坐标
            float4 GetShadowPositionHClips(Attributes input)
            {
                float3 positionWS = TransformObjectToWorld(input.positionOS.xyz);
                float3 normalWS = TransformObjectToWorldNormal(input.normalOS);
                // 获取阴影专用裁剪空间下的坐标
                float4 positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, _LightDirection));
                
                // 判断是否是在DirectX平台翻转过坐标
                #if UNITY_REVERSED_Z
                    positionCS.z = min(positionCS.z, positionCS.w * UNITY_NEAR_CLIP_VALUE);
                #else
                    positionCS.z = max(positionCS.z, positionCS.w * UNITY_NEAR_CLIP_VALUE);
                #endif
                
                return positionCS;
            }
            
            Varyings vert(Attributes input)
            {
                Varyings output;
                output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
                output.positionCS = GetShadowPositionHClips(input);
                return output;
            }
            
            
            half4 frag(Varyings input): SV_TARGET
            {
                //可以使用该方法替代下面的裁剪操作，但是需要引用函数库ShaderLibrary/SurfaceInput.hlsl
                //Alpha(SampleAlbedoAlpha(input.uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap)).a, _BaseColor, _Cutoff);
                //or
                half4 albedoAlpha = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
                #if defined(_ALPHATEST_ON)
                    clip(albedoAlpha.a - _Cutoff);
                #endif
                
                return 0;
            }
            
            ENDHLSL            
        }

         // 用于渲染深度纹理
        Pass
        {
            Name "DepthOnly"
            Tags { "LightMode" = "DepthOnly" }
            
            // 开启深度写入
            ZWrite On
            // 用于控制Pass不写入任何颜色通道
            ColorMask 0
            Cull Off
            
            HLSLPROGRAM
            
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            
            #pragma vertex DepthOnlyVertex
            #pragma fragment DepthOnlyFragment
            
            struct Attributes
            {
                float4 position: POSITION;
                float2 texcoord: TEXCOORD0;
            };
            
            struct Varyings
            {
                float2 uv: TEXCOORD0;
                float4 positionCS: SV_POSITION;
            };
            
            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);
            
            Varyings DepthOnlyVertex(Attributes input)
            {
                Varyings output = (Varyings)0;
                
                output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
                output.positionCS = TransformObjectToHClip(input.position.xyz);
                return output;
            }
            
            half4 DepthOnlyFragment(Varyings input): SV_TARGET
            {
                //可以使用该方法替代下面的裁剪操作，但是需要引用函数库ShaderLibrary/SurfaceInput.hlsl
                //Alpha(SampleAlbedoAlpha(input.uv, TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap)).a, _BaseColor, _Cutoff);
                //or
                half4 albedoAlpha = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, input.uv);
                #if defined(_ALPHATEST_ON)
                    clip(albedoAlpha.a - _Cutoff);
                #endif
                
                return 0;
            }
            
            ENDHLSL
            
        }
    }
    FallBack "Packages/com.unity.render-pipelines.universal/FallbackError"
}

后处理Shader_EdgeDetectionNormalsAndDepth

Shader "URP/Edge Detection Normals And Depth"
{
    Properties
    {
        _MainTex ("Base (RGB)", 2D) = "white" { }
        // 描边强度
        _EdgeOnly ("Edge Only", Float) = 1.0
        // 描边颜色
        _EdgeColor ("Edge Color", Color) = (0, 0, 0, 1)
        // 背景色
        _BackgroundColor ("Background Color", Color) = (1, 1, 1, 1)
        // 用于控制深度+发现纹理采样时，使用的采样距离。
        _SampleDistance ("Sample Distance", Float) = 1.0
        // xy对应了法线和深度检测的灵敏度
        _Sensitivity ("Sensitivity", Vector) = (1, 1, 1, 1)
    }
    SubShader
    {
        Tags { "RenderPipeline" = "UniversalPipeline" }
        
        HLSLINCLUDE
        #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
        
        CBUFFER_START(UnityPerMaterial)
        half4 _MainTex_ST;
        half4 _MainTex_TexelSize;
        half _EdgeOnly;
        half4 _EdgeColor;
        half4 _BackgroundColor;
        float _SampleDistance;
        half4 _Sensitivity;
        CBUFFER_END
        
        
        // 声明深度法线纹理，注意该名称是指定的
        TEXTURE2D(_CameraDepthNormalsTexture);
        SAMPLER(sampler_CameraDepthNormalsTexture);
        
        // 声明纹理
        TEXTURE2D(_MainTex);
        SAMPLER(sampler_MainTex);
        
        struct a2v
        {
            float4 vertex: POSITION;
            float4 texcoord: TEXCOORD0;
        };
        
        struct v2f
        {
            float4 pos: SV_POSITION;
            
            // 第一个坐标存储了屏幕颜色图像的采样纹理
            // 后面四个坐标存储了使用Roberts算子时需要采样的纹理坐标。
            half2 uv[5]: TEXCOORD0;
        };
        
        v2f vert(a2v v)
        {
            v2f o;
            o.pos = TransformObjectToHClip(v.vertex.xyz);
            
            // 对纹理进行采样，并放入第一个坐标中
            half2 uv = TRANSFORM_TEX(v.texcoord, _MainTex);
            o.uv[0] = uv;
            
            // 检测DirectX平台
            #if UNITY_UV_STARTS_AT_TOP
                // 检测Unity是否已自动翻转了坐标
                if (_MainTex_TexelSize.y < 0)
                    uv.y = 1 - uv.y;
            #endif
            
            // 对纹理领域进行采样，并用_SampleDistance控制采样距离
            o.uv[1] = uv + _MainTex_TexelSize.xy * half2(1, 1) * _SampleDistance;
            o.uv[2] = uv + _MainTex_TexelSize.xy * half2(-1, -1) * _SampleDistance;
            o.uv[3] = uv + _MainTex_TexelSize.xy * half2(-1, 1) * _SampleDistance;
            o.uv[4] = uv + _MainTex_TexelSize.xy * half2(1, -1) * _SampleDistance;
            
            return o;
        }
        // 解码深度
        inline float DecodeFloatRG(float2 enc)
        {
            float2 kDecodeDot = float2(1.0, 1 / 255.0);
            return dot(enc, kDecodeDot);
        }
        
        // 解码法线
        float3 DecodeNormal(float4 enc)
        {
            float kScale = 1.7777;
            float3 nn = enc.xyz * float3(2 * kScale, 2 * kScale, 0) + float3(-kScale, -kScale, 1);
            float g = 2.0 / dot(nn.xyz, nn.xyz);
            float3 n;
            n.xy = g * nn.xy;
            n.z = g - 1;
            return n;
        }
        
        inline  void  DecodeDepthNormal(float4 enc, out float depth, out float3 normal)
        {
            depth = DecodeFloatRG(enc.zw);
            normal = DecodeNormal(enc);
        }
        
        half CheckSame(half4 center, half4 sample)
        {
            
            // 获取法线近似值
            half2 centerNormal = center.xy;
            // DecodeFloatRG：解码RG颜色到float
            float centerDepth = DecodeFloatRG(center.zw);
            half2 sampleNormal = sample.xy;
            float sampleDepth = DecodeFloatRG(sample.zw);
            
            // 法线差异 = 两个采样点对应值相减后乘以灵敏度
            half2 diffNormal = abs(centerNormal - sampleNormal) * _Sensitivity.x;
            // 将分量相加与阈值比较来判断是否存在边界
            int isSameNormal = (diffNormal.x + diffNormal.y) < 0.1;
            
            // 深度差异 = 两个采样点对应值相减后乘以灵敏度
            float diffDepth = abs(centerDepth - sampleDepth) * _Sensitivity.y;
            // 将深度差异与阈值比较得到是否存在边界结果
            int isSameDepth = diffDepth < 0.1 * centerDepth;
            
            // 将深度与法线结果相乘得到最终结果
            // return:
            // 1 - 如果法线和深度足够相似，即不存在边界
            // 0 - 否则
            return isSameNormal * isSameDepth ? 1.0: 0.0;
        }
        
        
        half4 fragRobertsCrossDepthAndNormal(v2f i): SV_Target
        {
            // 使用纹理坐标，对深度+法线纹理进行采样
            half4 sample1 = SAMPLE_TEXTURE2D(_CameraDepthNormalsTexture, sampler_CameraDepthNormalsTexture, i.uv[1]);
            half4 sample2 = SAMPLE_TEXTURE2D(_CameraDepthNormalsTexture, sampler_CameraDepthNormalsTexture, i.uv[2]);
            half4 sample3 = SAMPLE_TEXTURE2D(_CameraDepthNormalsTexture, sampler_CameraDepthNormalsTexture, i.uv[3]);
            half4 sample4 = SAMPLE_TEXTURE2D(_CameraDepthNormalsTexture, sampler_CameraDepthNormalsTexture, i.uv[4]);
            half4 sample = SAMPLE_TEXTURE2D(_CameraDepthNormalsTexture, sampler_CameraDepthNormalsTexture, i.uv[0]);
            /*
            float depth;
            float3 normal;
            DecodeDepthNormal(sample, depth, normal);
            //输出深度，从深度法线纹理中获取到的深度亮度值相比直接从深度纹理获取到的不够高，需要将获取到的深度值*1000以提升亮度
            return depth*1000;
            //输出法线
            return float4(normal, 1);
            */
            half edge = 1.0;
            
            // 计算对角线两个纹理的插值     CheckSame：返回0或1
            edge *= CheckSame(sample1, sample2);
            edge *= CheckSame(sample3, sample4);
            
            // 插值描边颜色
            half4 withEdgeColor = lerp(_EdgeColor, SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.uv[0]), edge);
            // 插值背景颜色
            half4 onlyEdgeColor = lerp(_EdgeColor, _BackgroundColor, edge);
            
            // 插值描边与背景颜色，由描边强度控制
            return lerp(withEdgeColor, onlyEdgeColor, _EdgeOnly);
        }
        
        
        
        ENDHLSL
        
        Pass
        {
            Tags { "RenderPipeline" = "UniversalPipeline" }
            ZTest Always Cull Off ZWrite Off
            
            HLSLPROGRAM
            
            #pragma vertex vert
            #pragma fragment fragRobertsCrossDepthAndNormal
            
            ENDHLSL
            
        }
    }
    FallBack Off
}

属性参数组件

using System;

// 通用渲染管线程序集
namespace UnityEngine.Rendering.Universal
{
    // 实例化类     添加到Volume组件菜单中
    [Serializable, VolumeComponentMenu("Addition-Post-processing/EdgeDetectionNormalsAndDepth")]
    // 集成VolumeComponent组件和IPostProcessComponent接口，用以继承Volume框架
    public class EdgeDetectionNormalsAndDepth : VolumeComponent, IPostProcessComponent
    {
        // 在框架下的属性与Unity常规属性不一样，例如 Int 由 ClampedIntParameter 取代。

        [Tooltip("开关")]
        public BoolParameter _Switch = new BoolParameter(false);

        [Tooltip("描边强度")]
        public ClampedFloatParameter edgesOnly = new ClampedFloatParameter(0f, 0, 1);
        [Tooltip("描边颜色")]
        public ColorParameter edgeColor = new ColorParameter(Color.black);
        [Tooltip("背景颜色")]
        public ColorParameter backgroundColor = new ColorParameter(Color.white);
        [Tooltip("采样距离")]
        public ClampedFloatParameter sampleDistance = new ClampedFloatParameter(1f, -10f, 10);
        [Tooltip("深度差")]
        public ClampedFloatParameter sensitivityDepth = new ClampedFloatParameter(1f, -10f, 10);
        [Tooltip("法线差")]
        public ClampedFloatParameter sensitivityNormals = new ClampedFloatParameter(1f, -10f, 10);



        // 实现接口
        public bool IsActive() => _Switch.value;

        public bool IsTileCompatible()
        {
            return false;
        }
    }

}

修改AdditionalPostProcessData与AdditionalMaterialLibrary

using System;

namespace UnityEngine.Rendering.Universal
{
    /// 
    /// 附加后处理数据
    /// 
    [Serializable]
    public class AdditionalPostProcessData : ScriptableObject
    {
        [Serializable]
        public sealed class Shaders
        {
            public Shader brightnessSaturationContrast;
            public Shader fogWithDepthTexture;
            public Shader edgeDetectionNormalsAndDepth;
        }
        public Shaders shaders;
    }   
}

namespace UnityEngine.Rendering.Universal
{
    /// 
    /// 材质列表
    /// 
    public class AdditionalMaterialLibrary
    {
        public readonly Material brightnessSaturationContrast;
        public readonly Material fogWithDepthTexture;
        public readonly Material edgeDetectionNormalsAndDepth;

        /// 
        /// 初始化时从配置文件中获取材质
        /// 
        /// 
        public AdditionalMaterialLibrary(AdditionalPostProcessData data)
        {
            brightnessSaturationContrast = Load(data.shaders.brightnessSaturationContrast);
            fogWithDepthTexture = Load(data.shaders.fogWithDepthTexture);
            edgeDetectionNormalsAndDepth = Load(data.shaders.edgeDetectionNormalsAndDepth);
        }

        Material Load(Shader shader)
        {
            if (shader == null)
            {
                Debug.LogErrorFormat($"丢失 shader. {GetType().DeclaringType.Name} 渲染通道将不会执行。检查渲染器资源中是否缺少引用。");
                return null;
            }
            else if (!shader.isSupported)
            {
                return null;
            }
            return CoreUtils.CreateEngineMaterial(shader);
        }

        internal void Cleanup()
        {
            CoreUtils.Destroy(brightnessSaturationContrast);
        }
    }
}

修改AdditionPostProcessPass

using UnityEngine.Experimental.Rendering;

namespace UnityEngine.Rendering.Universal
{
    /// 
    /// 附加的后处理Pass
    /// 
    public class AdditionPostProcessPass : ScriptableRenderPass
    {
        //标签名，用于续帧调试器中显示缓冲区名称
        const string CommandBufferTag = "AdditionalPostProcessing Pass";

        // 用于后处理的材质
        Material m_BlitMaterial;
        AdditionalMaterialLibrary m_Materials;
        AdditionalPostProcessData m_Data;

        // 主纹理信息
        RenderTargetIdentifier m_Source;
        // 深度信息
        RenderTargetIdentifier m_Depth;
        // 当前帧的渲染纹理描述
        RenderTextureDescriptor m_Descriptor;
        // 目标相机信息
        RenderTargetHandle m_Destination;

        // 临时的渲染目标
        RenderTargetHandle m_TemporaryColorTexture01;


        // 属性参数组件
        BrightnessSaturationContrast m_BrightnessSaturationContrast;
        FogWithDepthTexture m_FogWithDepthTexture;
        EdgeDetectionNormalsAndDepth m_EdgeDetectionNormalsAndDepth;


        public AdditionPostProcessPass(RenderPassEvent evt, AdditionalPostProcessData data, Material blitMaterial = null)
        {
            renderPassEvent = evt;
            m_Data = data;
            m_Materials = new AdditionalMaterialLibrary(data);
            m_BlitMaterial = blitMaterial;
        }

        public void Setup(in RenderTextureDescriptor baseDescriptor, in RenderTargetIdentifier source, in RenderTargetIdentifier depth, in RenderTargetHandle destination)
        {
            m_Descriptor = baseDescriptor;
            m_Source = source;

            m_Depth = depth;
            m_Destination = destination;
        }


        /// 
        /// URP会自动调用该执行方法
        /// 
        /// 
        /// 
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            // 从Volume框架中获取所有堆栈
            var stack = VolumeManager.instance.stack;
            // 从堆栈中查找对应的属性参数组件
            m_BrightnessSaturationContrast = stack.GetComponent();
            m_FogWithDepthTexture = stack.GetComponent();
            m_EdgeDetectionNormalsAndDepth = stack.GetComponent();

            // 从命令缓冲区池中获取一个带标签的渲染命令，该标签名可以在后续帧调试器中见到
            var cmd = CommandBufferPool.Get(CommandBufferTag);

            // 调用渲染函数
            Render(cmd, ref renderingData);

            // 执行命令缓冲区
            context.ExecuteCommandBuffer(cmd);
            // 释放命令缓存
            CommandBufferPool.Release(cmd);
        }

        // 渲染
        void Render(CommandBuffer cmd, ref RenderingData renderingData)
        {
            ref var cameraData = ref renderingData.cameraData;
            bool m_IsStereo = renderingData.cameraData.isStereoEnabled;
            bool isSceneViewCamera = cameraData.isSceneViewCamera;

            // VolumeComponent是否开启，且非Scene视图摄像机
            // 亮度、对比度、饱和度
            if (m_BrightnessSaturationContrast.IsActive() && !isSceneViewCamera)
            {
                SetBrightnessSaturationContrast(cmd, m_Materials.brightnessSaturationContrast);
            }
            // 全局雾
            if (m_FogWithDepthTexture.IsActive() && !isSceneViewCamera)
            {
                SetFogWithDepthTexture(cmd, m_Materials.fogWithDepthTexture, cameraData);
            }
            // 描边
            if (m_EdgeDetectionNormalsAndDepth.IsActive() && !isSceneViewCamera)
            {
                SetEdgeDetectionNormalsAndDepth(cmd, m_Materials.edgeDetectionNormalsAndDepth);
            }
        }

        RenderTextureDescriptor GetStereoCompatibleDescriptor(int width, int height, int depthBufferBits = 0)
        {
            var desc = m_Descriptor;
            desc.depthBufferBits = depthBufferBits;
            desc.msaaSamples = 1;
            desc.width = width;
            desc.height = height;
            return desc;
        }



        #region 处理材质渲染
        // 亮度、饱和度、对比度渲染
        void SetBrightnessSaturationContrast(CommandBuffer cmd, Material uberMaterial)
        {
            // 写入参数
            uberMaterial.SetFloat("_Brightness", m_BrightnessSaturationContrast.brightness.value);
            uberMaterial.SetFloat("_Saturation", m_BrightnessSaturationContrast.saturation.value);
            uberMaterial.SetFloat("_Contrast", m_BrightnessSaturationContrast.contrast.value);

            // 通过目标相机的渲染信息创建临时缓冲区
            //RenderTextureDescriptor opaqueDesc = m_Descriptor;
            //opaqueDesc.depthBufferBits = 0;
            //cmd.GetTemporaryRT(m_TemporaryColorTexture01.id, opaqueDesc);
            //or
            int tw = m_Descriptor.width;
            int th = m_Descriptor.height;
            var desc = GetStereoCompatibleDescriptor(tw, th);
            cmd.GetTemporaryRT(m_TemporaryColorTexture01.id, desc, FilterMode.Bilinear);

            // 通过材质，将计算结果存入临时缓冲区
            cmd.Blit(m_Source, m_TemporaryColorTexture01.Identifier(), uberMaterial);
            // 再从临时缓冲区存入主纹理
            cmd.Blit(m_TemporaryColorTexture01.Identifier(), m_Source);

            // 释放临时RT
            cmd.ReleaseTemporaryRT(m_TemporaryColorTexture01.id);
        }
        // 全局高度雾
        void SetFogWithDepthTexture(CommandBuffer cmd, Material uberMaterial, CameraData cameraData)
        {
            Matrix4x4 frustumCorners = Matrix4x4.identity;
            Camera camera = cameraData.camera;
            // FOV是相机的竖直方向的视角范围
            float fov = camera.fieldOfView;
            // Near是相机的近裁剪平面的距离
            float near = camera.nearClipPlane;
            // Aspect是相机的宽高比（宽度除以高度）
            float aspect = camera.aspect;

            // 近裁剪面中心
            float halfHeight = near * Mathf.Tan(fov * 0.5f * Mathf.Deg2Rad);
            // 相机正右方
            Vector3 toRight = camera.transform.right * halfHeight * aspect;
            // 相机正上方
            Vector3 toTop = camera.transform.up * halfHeight;

            // 左上角相对于相机的方向
            Vector3 topLeft = camera.transform.forward * near + toTop - toRight;

            float scale = topLeft.magnitude / near;

            topLeft.Normalize();
            // 左上角距离摄像机的欧式距离dist
            topLeft *= scale;

            Vector3 topRight = camera.transform.forward * near + toRight + toTop;
            topRight.Normalize();
            topRight *= scale;

            Vector3 bottomLeft = camera.transform.forward * near - toTop - toRight;
            bottomLeft.Normalize();
            bottomLeft *= scale;

            Vector3 bottomRight = camera.transform.forward * near + toRight - toTop;
            bottomRight.Normalize();
            bottomRight *= scale;

            // 将近裁剪平面的四个角对应的向量存储到矩阵类型的变量中（存入顺序是非常重要的）
            frustumCorners.SetRow(0, bottomLeft);
            frustumCorners.SetRow(1, bottomRight);
            frustumCorners.SetRow(2, topRight);
            frustumCorners.SetRow(3, topLeft);

            // 将参数写入材质
            uberMaterial.SetMatrix("_FrustumCornersRay", frustumCorners);

            // 写入参数
            uberMaterial.SetFloat("_FogDensity", m_FogWithDepthTexture.fogDensity.value);
            uberMaterial.SetColor("_FogColor", m_FogWithDepthTexture.fogColor.value);
            uberMaterial.SetFloat("_FogStart", m_FogWithDepthTexture.fogStart.value);
            uberMaterial.SetFloat("_FogEnd", m_FogWithDepthTexture.fogEnd.value);

            int tw = m_Descriptor.width;
            int th = m_Descriptor.height;
            var desc = GetStereoCompatibleDescriptor(tw, th);
            cmd.GetTemporaryRT(m_TemporaryColorTexture01.id, desc);

            // 通过材质，将计算结果存入临时缓冲区
            cmd.Blit(m_Source, m_TemporaryColorTexture01.Identifier(), uberMaterial);
            // 再从临时缓冲区存入主纹理
            cmd.Blit(m_TemporaryColorTexture01.Identifier(), m_Source);

            // 释放临时RT
            cmd.ReleaseTemporaryRT(m_TemporaryColorTexture01.id);
        }
        // 描边
        void SetEdgeDetectionNormalsAndDepth(CommandBuffer cmd, Material uberMaterial)
        {
            // 写入参数
            uberMaterial.SetFloat("_EdgeOnly", m_EdgeDetectionNormalsAndDepth.edgesOnly.value);
            uberMaterial.SetColor("_EdgeColor", m_EdgeDetectionNormalsAndDepth.edgeColor.value);
            uberMaterial.SetColor("_BackgroundColor", m_EdgeDetectionNormalsAndDepth.backgroundColor.value);
            uberMaterial.SetFloat("_SampleDistance", m_EdgeDetectionNormalsAndDepth.sampleDistance.value);
            uberMaterial.SetVector("_Sensitivity", new Vector4(m_EdgeDetectionNormalsAndDepth.sensitivityNormals.value, m_EdgeDetectionNormalsAndDepth.sensitivityDepth.value, 0.0f, 0.0f));

            int tw = m_Descriptor.width;
            int th = m_Descriptor.height;
            var desc = GetStereoCompatibleDescriptor(tw, th);
            cmd.GetTemporaryRT(m_TemporaryColorTexture01.id, desc, FilterMode.Bilinear);

            // 通过材质，将计算结果存入临时缓冲区
            cmd.Blit(m_Source, m_TemporaryColorTexture01.Identifier(), uberMaterial);
            // 再从临时缓冲区存入主纹理
            cmd.Blit(m_TemporaryColorTexture01.Identifier(), m_Source);

            // 释放临时RT
            cmd.ReleaseTemporaryRT(m_TemporaryColorTexture01.id);
        }
        #endregion
    }
}

你可能感兴趣的:(URP深度法线纹理)

  • 【Python】一文详细介绍 py格式 文件 高斯小哥 Python基础【高质量合集】python新手入门学习
    【Python】一文详细介绍py格式文件个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文章目录一、py格式文件简介二、如何创建和编辑py格式文件三、如何运行py
  • 【转载】SSD测试第一神器——FIO running_sheep
    转自：[http://www.ssdfans.com]对于SSD性能测试来说，最好的工具莫过于FIO了。FIO是Jens开发的一个开源测试工具，功能非常强大，本文就只介绍其中一些基本功能。线程，队列深度，Offset，同步异步，DirectIO，BIO使用FIO之前，首先要有一些SSD性能测试的基础知识。线程指的是同时有多少个读或写任务在并行执行，一般来说，CPU里面的一个核心同一时间只能运行一个
  • 大创项目推荐 深度学习 opencv python 公式识别(图像识别 机器视觉) laafeer python
    文章目录0前言1课题说明2效果展示3具体实现4关键代码实现5算法综合效果6最后0前言优质竞赛项目系列，今天要分享的是基于深度学习的数学公式识别算法实现该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：4分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1课题
  • python清华大学出版社答案_Python机器学习及实践 weixin_39805119 python清华大学出版社答案
    第1章机器学习的基础知识1.1何谓机器学习1.1.1传感器和海量数据1.1.2机器学习的重要性1.1.3机器学习的表现1.1.4机器学习的主要任务1.1.5选择合适的算法1.1.6机器学习程序的步骤1.2综合分类1.3推荐系统和深度学习1.3.1推荐系统1.3.2深度学习1.4何为Python1.4.1使用Python软件的由来1.4.2为什么使用Python1.4.3Python设计定位1.4.
  • 深度学习项目-基于深度学习的股票价格预测研究 雅致教育 计算机毕业设计深度学习人工智能
    概要  随着经济的发展，中国股票市场的规模持续扩大，早已成为金融投资的重要部分，掌握股票市场的变化规律无论是对监管者还是投资者都具有极其重要的意义。正因如此，人们不断探索着股票市场的变化规律，其中使用深度学习预测股价是当前国内国际研究与应用的热点。  本文首先从有效市场假说和分形市场假说两个角度讨论了中国股票市场的有效性，说明股票市场具有复杂的非线性特征。其次，结合股票市场特征对比了当前的预测方法
  • DCGAN中的生成器和识别器代码详解 YYLin-AI DCGAN深度学习celebatensorflow
    #DCGAN中的生成器我自己写的有一个封装好的用于生成器和识别器的卷积操作但是在这个代码中我没有使用我自己的代码#原因想绍一下tensorflow自带的函数所以找了一个以前在书上的代码申明一下这个不是原创但是原来代码中有几处不符合DCGAN的要求所以就做了一些修改转载链接没有就直接写成原创建议看代码之前先看看DCGAN的特点，然后再看代码中如何实这些特点的这样会更有帮助DCGAN（深度卷积的对抗生
  • ChatGPT技巧大揭秘：AI写代码新境界 2401_83550420 chatgpt4.0chatgptchatgpt人工智能AI写作
    ChatGPT无限次数:点击直达ChatGPT技巧大揭秘：AI写代码新境界随着人工智能技术的不断进步，开发人员现在有了更多有趣的工具来提高他们的工作效率。其中，ChatGPT作为一种基于深度学习的自然语言处理模型，已经成为许多开发者的新宠。在本文中，我们将揭秘使用ChatGPT来帮助编写代码的技巧，探索AI在编程领域的新境界。ChatGPT简介ChatGPT是一种基于大型神经网络的对话生成模型，它
  • AI大模型学习：开启智能时代的新篇章 游向大厂的咸鱼 人工智能学习
    随着人工智能技术的不断发展，AI大模型已经成为当今领先的技术之一，引领着智能时代的发展。这些大型神经网络模型，如OpenAI的GPT系列、Google的BERT等，在自然语言处理、图像识别、智能推荐等领域展现出了令人瞩目的能力。然而，这些模型的背后是一系列复杂的学习过程，深度学习技术的不断演进推动了AI大模型学习的发展。首先，AI大模型学习的基础是深度学习技术。深度学习是一种模仿人类大脑结构的机器
  • 【Python】成功解决ModuleNotFoundError: No module named ‘torchinfo‘ 高斯小哥 BUG解决方案合集pythonpytorch新手入门学习debug
    【Python】成功解决ModuleNotFoundError:Nomodulenamed‘torchinfo’个人主页：高斯小哥高质量专栏：Matplotlib之旅：零基础精通数据可视化、Python基础【高质量合集】、PyTorch零基础入门教程希望得到您的订阅和支持~创作高质量博文(平均质量分92+)，分享更多关于深度学习、PyTorch、Python领域的优质内容！（希望得到您的关注~）文
  • ChatGPT神技：AI成为你的编程良友 2401_83481083 chatgpt4.0chatgptchatgpt人工智能AI写作
    ChatGPT无限次数:点击直达ChatGPT神技：AI成为你的编程良友近年来，人工智能技术的发展迅猛，ChatGPT作为其中一项创新技术，正逐渐走进我们的生活。在编程领域，AI不仅可以助力我们提高效率，还能成为我们的良友，帮助解决各种编程难题。一、ChatGPT简介ChatGPT是一种基于自然语言处理技术的人工智能模型，它能够生成类人对话。ChatGPT通过深度学习模型，能够理解输入的文本并生成
  • 什么软件可以改IP地址 bafnpa123 服务器运维
    什么软件可以改IP地址在现代网络环境中，有时候我们需要更换IP地址来进行网络操作。IP地址是网络通信的基石，它标识了计算机在互联网上的唯一身份。下面，我将向您介绍几种常见的换IP地址的方法：方法一：使用深度ip转换器ip转换器是一种可以在公共网络上建立加密通道的技术。通过ip转换器，您可以更换您的IP地址，从而隐藏您的真实IP，提高网络安全性。在选择ip转换器服务时，请务必选择信誉良好、速度稳定的
  • 深度学习如何入门？ 科学的N次方 深度学习
    入门深度学习需要系统性的学习和实践经验积累，以下是一份详细的入门指南，包含了关键的学习步骤和资源：预备知识：•编程基础：熟悉Python编程语言，它是深度学习领域最常用的编程语言。确保掌握变量、条件语句、循环、函数等基本概念，并学习如何使用Python处理数据和文件操作。•数学基础：理解线性代数（矩阵运算、向量空间等）、微积分（导数、梯度求解等）、概率论与统计学（期望、方差、概率分布、最大似然估计
  • 深度学习与（复杂系统）事物的属性 科学禅道 深度学习模型专栏深度学习人工智能
    深度学习与复杂系统中事物属性的关系体现在：特征学习与表示:深度学习通过多层神经网络结构，能够自动从原始输入数据中学习和提取出丰富的特征表示。每一层神经网络都可能对应着事物属性的不同抽象层次，底层可能对应简单直观的属性，而随着网络深度的增加，顶层可以学习到更抽象、复杂的属性及其相互关系。非线性关系建模:深度学习特别擅长处理非线性关系，而在复杂系统中，事物属性间的相互作用往往表现为非线性，例如，某些属
  • 蓝桥杯day10刷题日记 jia_jia_LL 蓝桥杯蓝桥杯算法图论dfs刷题笔记数据结构
    P8604[蓝桥杯2013国C]危险系数思路：dfs，用深度优先搜索查找一次所有的线路，过程中记录每个点走过的次数，最后在与总路线数比较，相同即为每次必过的点，即关键点#includeusingnamespacestd;intn,m;inta[1010][1010],b[1010];intu,v;intcnt[1010],sum,ans;voiddfs(intx){if(x==v){sum++;f
  • 影评 ‖ 踏上救赎之路，做回自我——观《千与千寻》 游山恋一个字
    文/游山恋一个字01一直以来，对宫崎骏的作品特别钟爱。在其影片中，流淌着美好、和平、人与自然的和谐人、人与人之间的爱，贴近生活，治愈人生。宫崎骏曾言：我希望能够再次借着更具深度的作品，拯救人类坠落的灵魂。因而他的每部作品所选题材虽然不同，但却将梦想、环保、人生、生存融入作品中，使作品拥有了动漫巨作的高度。这些主题借助于一定的艺术形式进行包装，让读者观众从中领略到一种别样的风景，并得到精神疗养。每每
  • 智合同如何助力建筑行业合同智能化管理 智合同（小智） 合同智能应用AI技术降本增效提质人工智能自然语言处理知识图谱深度学习大数据
    #建筑行业#人工智能#AI#合同智能应用#深度学习#自然语言处理技术#知识图谱智合同-采用深度学习、自然语言处理技术、知识图谱等人工智能技术，为企业提供专业的合同相关的智能服务。其主要服务包含：合同智能审查、合同要素智能提取、合同版本对比、合同智能起草、ICR智能识别、合同履约追踪、文本一致性对比、广告审查、合同范本库等服务。智合同在助力建筑行业合同智能化管理方面具有显著的优势。首先，智合同利用A
  • 神经网络（深度学习，计算机视觉，得分函数，损失函数，前向传播，反向传播，激活函数） MarkHD 深度学习神经网络计算机视觉
    神经网络，特别是深度学习，在计算机视觉等领域有着广泛的应用。以下是关于你提到的几个关键概念的详细解释：神经网络：神经网络是一种模拟人脑神经元结构的计算模型，用于处理复杂的数据和模式识别任务。它由多个神经元（或称为节点）组成，这些神经元通过权重和偏置进行连接，并可以学习调整这些参数以优化性能。深度学习：深度学习是神经网络的一个子领域，主要关注于构建和训练深度神经网络（即具有多个隐藏层的神经网络）。通
  • 被看见的孩子 WonderLiwen
    趁周末回家几天，与家人深度沟通，内心充盈丰实。最让我感觉踏实的，便是我的家人们"很有条理"地接受我全新的人生选择，支持我去做我喜欢的事，并对我提出了更高的要求。之所以说是很有条理，是因为这是一个循序渐进，有前提假设，有质疑和鼓励的深度沟通过程。他们要看的是，我有没有真正想清楚。早早吃完丰盛的早餐，我又去躺在了外公的床上。就着和煦的晨风，我在床上伸展手脚，摆着各种奇怪的姿势，想到我潜意识里的那棵大榕
  • MATLAB 2023a：强化学习算法的实战演练与性能评估 zmjia111 机器学习matlabmatlab算法开发语言深度学习机器学习yolo
    在深度学习领域，MATLAB2023版深度学习工具箱以其完整的工具链和高效的运行环境，为研究人员和开发者提供了前所未有的便利。这一工具箱不仅集成了建模、训练和部署的全部功能，更以其简洁易用的语法和强大的算法库，为深度学习任务的快速实现铺平了道路。相较于Python等编程语言，MATLAB的语法更为直观，上手更为迅速。无需繁琐的环境配置和库安装，用户只需打开MATLAB界面，即可轻松开始深度学习之旅
  • Flink 面试题总结及答案 wending-Y Flink入门到实践flink大数据
    基础state的分类keystate和operatestatestate的重分布Flink状态管理详解：KeyedState和OperatorListState深度解析-掘金checkpoint和savepointhttps://zhuanlan.zhihu.com/p/79526638flinkjob的容错策略如果在没有持续消息输出的情况下，如何定时输出主要是现实有可能不会一直有消息输入，但是要
  • 动手学习深度学习——2.5 自动微分 X_Imagine 动手学习深度学习深度学习人工智能自动微分
    2.5自动微分  正如【2.4微积分】所说，微分是深度学习中几乎所有最优化算法的关键步骤。虽然求这些导数的计算过程很简单，只需要一些基本的微积分知识。但对于复杂的模型，手工计算参数的更新可能很痛苦(而且经常容易出错)。深度学习框架通过自动计算导数加快了这一工作，即自动微分（AutomaticDifferentiation）。在实践中，基于我们设计的模型，系统构建了一个计算图，跟踪哪些数据结合哪些操
  • 生成式AI竞赛：开源还是闭源，谁将主宰未来？ 新加坡内哥谈技术 人工智能
    每周跟踪AI热点新闻动向和震撼发展想要探索生成式人工智能的前沿进展吗？订阅我们的简报，深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同，从行业内部的深度分析和实用指南中受益。不要错过这个机会，成为AI领域的领跑者。点击订阅，与未来同行！订阅：https://rengongzhineng.io/对于一些行业观察家来说，这场战斗似乎还没开始就已结束。当ChatGPT成为有史以来增长最
  • 飞桨科学计算套件PaddleScience skywalk8163 人工智能paddlepaddle人工智能飞桨
    PaddleScience是一个基于深度学习框架PaddlePaddle开发的科学计算套件，利用深度神经网络的学习能力和PaddlePaddle框架的自动(高阶)微分机制，解决物理、化学、气象等领域的问题。支持物理机理驱动、数据驱动、数理融合三种求解方式，并提供了基础API和详尽文档供用户使用与二次开发。安装当然要先安装好飞桨PaddlePaddle，再安装PaddleSciencepipinst
  • 深度分析 | 2024年四川大学信息资源管理考研初试成绩数据分析 是希望 川大667信息管理导论川大972信息检索信息资源管理复试数据分析667972四川大学考研复试考研成绩
    摘要本文深入分析了2024年四川大学信息资源管理考研复试成绩，提供了关于考生成绩分布、各科目成绩表现以及科目成绩与总分之间的相关性的详细见解。分析显示，复试考生的平均总分为380.63分，标准差为12分，反映出成绩分布相对集中且波动适中。特别地，专业课972与总分的相关性最高，达到了0.82，明显影响了考生的总分表现。此外，通过比较高分组和低分组的表现，我们发现专业课成绩是区分高低分考生的关键因素
  • 直返APP与电商行业的融合:机遇与挑战 氧惠好物
    直返，简单来说，是一种让购物变得更有“回报”的消费模式。它通过与各大电商平台和品牌商家的深度合作，为消费者提供了一个全新的购物体验。在这里，购物不再只是单纯的消费行为，而是一种能为你带来实际收益的方式。氧惠APP（带货领导者）——是与以往完全不同的抖客+淘客app！2023全新模式，我的直推也会放到你下面。主打：带货高补贴，深受各位带货团队长喜爱（每天出单带货几十万单）。注册即可享受高补贴+0撸+
  • MAC电脑运行windows程序或者游戏怎么办，crossover介绍， 山外有山a macos游戏
    CrossOver是一款特别为Mac设计的应用程序，它基于Wine项目，可以直接在macOS上运行许多Windows应用程序，而无需安装完整的Windows操作系统。是一款由CodeWeavers公司开发的商业软件，它基于开源项目Wine，并对其进行了深度优化和增强。该软件的主要目的是让非Windows操作系统的用户能够在MacOSX、Linux以及ChromeOS等平台上运行Windows应用程
  • 深度阅读学习及实践后的flag 沐沐798
    图片发自App首先一定要将深度阅读的学习并实践坚持到底。（不能坚持到底还谈什么以后？）随着深度阅读和每日思考，我相信自己的文学素养会越来越高，写作水平也会日益增长。我会在每日头条，等自媒体平台写一些书评或者读后感来创建自媒体个人IP，此为管道之一。然后就是开设线上和线下读书会，此为管道之二。至于再长远的，能出本畅销书最好了。
  • Vue监视属性 pilgrim11
    监视属性watch：1、当被监视的属性变化时，回调函数自动调用，进行相关操作。2、监视的属性必须存在，才能进行监视。3、监视的两种写法：（1）newVue时传入watch配置（2）通过vm.$watch监视。深度监视：（1）Vue中的watch默认不监测对象内部值的改变（一层）。（2）配置deep：true可以监测对象内部值的改变（多层）。备注：（1）Vue自身可以监测对象内部值的改变，但Vue提
  • Copilot with GPT-4与文心一言4.0：AI技术的未来 嘻嘻爱编码 copilot文心一言人工智能
    CopilotwithGPT-4的深度分析CopilotwithGPT-4是基于OpenAI的GPT-4模型，它是一个多功能的AI助手，能够在多种语言中进行交流和创作。GPT-4模型的强大之处在于其庞大的数据训练基础，这使得它在理解语境、生成文本以及执行复杂任务方面表现出色。CopilotwithGPT-4不仅能够提供信息和回答问题，还能够帮助用户编写代码、创作文学作品，甚至模拟对话。特点多语言支
  • 最新ChatGPT支持下的PyTorch机器学习与深度学习 zkzhzy ChatGPT机器学习python机器学习深度学习pytorchchatgpt数据分析人工智能
    近年来，随着AlphaGo、无人驾驶汽车、医学影像智慧辅助诊疗、ImageNet竞赛等热点事件的发生，人工智能迎来了新一轮的发展浪潮。尤其是深度学习技术，在许多行业都取得了颠覆性的成果。另外，近年来，Pytorch深度学习框架受到越来越多科研人员的关注和喜爱。郁磊（副教授）主要从事AI人工智能、大语言模型及软件开发、生理系统建模与仿真、生物医学信号处理，具有丰富的科研经验，主编《MATLAB智能算
  • mongodb3.03开启认证 21jhf mongodb
    下载了最新mongodb3.03版本，当使用--auth 参数命令行开启mongodb用户认证时遇到很多问题，现总结如下： （百度上搜到的基本都是老版本的，看到db.addUser的就是，请忽略） Windows下我做了一个bat文件，用来启动mongodb，命令行如下： mongod --dbpath db\data --port 27017 --directoryperdb --logp
  • 【Spark103】Task not serializable bit1129 Serializable
    Task not serializable是Spark开发过程最令人头疼的问题之一，这里记录下出现这个问题的两个实例，一个是自己遇到的，另一个是stackoverflow上看到。等有时间了再仔细探究出现Task not serialiazable的各种原因以及出现问题后如何快速定位问题的所在，至少目前阶段碰到此类问题，没有什么章法 1.   package spark.exampl
  • 你所熟知的 LRU(最近最少使用) dalan_123 java
    关于LRU这个名词在很多地方或听说，或使用，接下来看下lru缓存回收的实现 1、大体的想法     a、查询出最近最晚使用的项     b、给最近的使用的项做标记 通过使用链表就可以完成这两个操作，关于最近最少使用的项只需要返回链表的尾部；标记最近使用的项，只需要将该项移除并放置到头部，那么难点就出现 你如何能够快速在链表定位对应的该项？ 这时候多
  • Javascript 跨域 周凡杨 JavaScriptjsonp跨域cross-domain
                                       
  • linux下安装apache服务器 g21121 apache
    安装apache 下载windows版本apache，下载地址：http://httpd.apache.org/download.cgi   1.windows下安装apache Windows下安装apache比较简单，注意选择路径和端口即可，这里就不再赘述了。 2.linux下安装apache： 下载之后上传到linux的相关目录，这里指定为/home/apach
  • FineReport的JS编辑框和URL地址栏语法简介 老A不折腾 finereportweb报表报表软件语法总结
      JS编辑框： 1.FineReport的js。 作为一款BS产品，browser端的JavaScript是必不可少的。 FineReport中的js是已经调用了finereport.js的。 大家知道，预览报表时，报表servlet会将cpt模板转为html，在这个html的head头部中会引入FineReport的js，这个finereport.js中包含了许多内置的fun
  • 根据STATUS信息对MySQL进行优化 墙头上一根草 status
    mysql  查看当前正在执行的操作，即正在执行的sql语句的方法为:      show processlist 命令   mysql> show global status;可以列出MySQL服务器运行各种状态值，我个人较喜欢的用法是show status like '查询值%';一、慢查询mysql> show variab
  • 我的spring学习笔记7-Spring的Bean配置文件给Bean定义别名 aijuans Spring 3
    本文介绍如何给Spring的Bean配置文件的Bean定义别名？ 原始的 <bean id="business" class="onlyfun.caterpillar.device.Business"> <property name="writer"> <ref b
  • 高性能mysql 之 性能剖析 annan211 性能mysqlmysql 性能剖析剖析
    1 定义性能优化 mysql服务器性能，此处定义为 响应时间。 在解释性能优化之前，先来消除一个误解，很多人认为，性能优化就是降低cpu的利用率或者减少对资源的使用。 这是一个陷阱。 资源时用来消耗并用来工作的，所以有时候消耗更多的资源能够加快查询速度，保持cpu忙绿，这是必要的。很多时候发现 编译进了新版本的InnoDB之后，cpu利用率上升的很厉害，这并不
  • 主外键和索引唯一性约束 百合不是茶 索引唯一性约束主外键约束联机删除
    目标;第一步;创建两张表 用户表和文章表         第二步;发表文章       1,建表; ---用户表 BlogUsers --userID唯一的 --userName --pwd --sex create
  • 线程的调度 bijian1013 java多线程thread线程的调度java多线程
    1.       Java提供一个线程调度程序来监控程序中启动后进入可运行状态的所有线程。线程调度程序按照线程的优先级决定应调度哪些线程来执行。   2.       多数线程的调度是抢占式的（即我想中断程序运行就中断，不需要和将被中断的程序协商） a) 
  • 查看日志常用命令 bijian1013 linux命令unix
    一.日志查找方法，可以用通配符查某台主机上的所有服务器grep "关键字" /wls/applogs/custom-*/error.log   二.查看日志常用命令1.grep '关键字' error.log：在error.log中搜索'关键字'2.grep -C10 '关键字' error.log：显示关键字前后10行记录3.grep '关键字' error.l
  • 【持久化框架MyBatis3一】MyBatis版HelloWorld bit1129 helloworld
    MyBatis这个系列的文章，主要参考《Java Persistence with MyBatis 3》。   样例数据 本文以MySQL数据库为例，建立一个STUDENTS表，插入两条数据，然后进行单表的增删改查     CREATE TABLE STUDENTS ( stud_id int(11) NOT NULL AUTO_INCREMENT,
  • 【Hadoop十五】Hadoop Counter bit1129 hadoop
       1. 只有Map任务的Map Reduce Job File System Counters FILE: Number of bytes read=3629530 FILE: Number of bytes written=98312 FILE: Number of read operations=0 FILE: Number of lar
  • 解决Tomcat数据连接池无法释放 ronin47 tomcat 连接池　优化
    近段时间，公司的检测中心报表系统(SMC)的开发人员时不时找到我，说用户老是出现无法登录的情况。前些日子因为手头上 有Jboss集群的测试工作，发现用户不能登录时，都是在Tomcat中将这个项目Reload一下就好了，不过只是治标而已，因为大概几个小时之后又会 再次出现无法登录的情况。 今天上午，开发人员小毛又找到我，要我协助将这个问题根治一下，拖太久用户难保不投诉。 简单分析了一
  • java-75-二叉树两结点的最低共同父结点 bylijinnan java
    import java.util.LinkedList; import java.util.List; import ljn.help.*; public class BTreeLowestParentOfTwoNodes { public static void main(String[] args) { /* * node data is stored in
  • 行业垂直搜索引擎网页抓取项目 carlwu LuceneNutchHeritrixSolr
    公司有一个搜索引擎项目，希望各路高人有空来帮忙指导，谢谢！ 这是详细需求： （1） 通过提供的网站地址(大概100-200个网站)，网页抓取程序能不断抓取网页和其它类型的文件（如Excel、PDF、Word、ppt及zip类型），并且程序能够根据事先提供的规则，过滤掉不相干的下载内容。 （2） 程序能够搜索这些抓取的内容，并能对这些抓取文件按照油田名进行分类，然后放到服务器不同的目录中。
  • [通讯与服务]在总带宽资源没有大幅增加之前,不适宜大幅度降低资费 comsci 资源
          降低通讯服务资费，就意味着有更多的用户进入，就意味着通讯服务提供商要接待和服务更多的用户，在总体运维成本没有由于技术升级而大幅下降的情况下，这种降低资费的行为将导致每个用户的平均带宽不断下降，而享受到的服务质量也在下降，这对用户和服务商都是不利的。。。。。。。。     &nbs
  • Java时区转换及时间格式 Cwind java
    本文介绍Java API 中 Date, Calendar, TimeZone和DateFormat的使用，以及不同时区时间相互转化的方法和原理。   问题描述： 向处于不同时区的服务器发请求时需要考虑时区转换的问题。譬如，服务器位于东八区（北京时间，GMT+8:00），而身处东四区的用户想要查询当天的销售记录。则需把东四区的“今天”这个时间范围转换为服务器所在时区的时间范围。
  • readonly,只读，不可用 dashuaifu jsjspdisablereadOnlyreadOnly
    readOnly 和 readonly 不同，在做js开发时一定要注意函数大小写和jsp黄线的警告！！！我就经历过这么一件事： 使用readOnly在某些浏览器或同一浏览器不同版本有的可以实现“只读”功能，有的就不行，而且函数readOnly有黄线警告！！！就这样被折磨了不短时间！！！（期间使用过disable函数，但是发现disable函数之后后台接收不到前台的的数据！！！）  
  • LABjs、RequireJS、SeaJS 介绍 dcj3sjt126com jsWeb
    LABjs 的核心是 LAB（Loading and Blocking）：Loading 指异步并行加载，Blocking 是指同步等待执行。LABjs 通过优雅的语法（script 和 wait）实现了这两大特性，核心价值是性能优化。LABjs 是一个文件加载器。RequireJS 和 SeaJS 则是模块加载器，倡导的是一种模块化开发理念，核心价值是让 JavaScript 的模块化开发变得更
  • [应用结构]入口脚本 dcj3sjt126com PHPyii2
    入口脚本 入口脚本是应用启动流程中的第一环，一个应用（不管是网页应用还是控制台应用）只有一个入口脚本。终端用户的请求通过入口脚本实例化应用并将将请求转发到应用。 Web 应用的入口脚本必须放在终端用户能够访问的目录下，通常命名为 index.php，也可以使用 Web 服务器能定位到的其他名称。 控制台应用的入口脚本一般在应用根目录下命名为 yii（后缀为.php），该文
  • haoop shell命令 eksliang hadoophadoop shell
    cat chgrp chmod chown copyFromLocal copyToLocal cp du dus expunge get getmerge ls lsr mkdir movefromLocal mv put rm rmr setrep stat tail test text
  • MultiStateView不同的状态下显示不同的界面 gundumw100 android
    只要将指定的view放在该控件里面，可以该view在不同的状态下显示不同的界面，这对ListView很有用，比如加载界面，空白界面，错误界面。而且这些见面由你指定布局，非常灵活。 PS：ListView虽然可以设置一个EmptyView，但使用起来不方便，不灵活，有点累赘。 <com.kennyc.view.MultiStateView xmlns:android=&qu
  • jQuery实现页面内锚点平滑跳转 ini JavaScripthtmljqueryhtml5css
    平时我们做导航滚动到内容都是通过锚点来做，刷的一下就直接跳到内容了，没有一丝的滚动效果，而且 url 链接最后会有“小尾巴”，就像#keleyi，今天我就介绍一款 jquery 做的滚动的特效，既可以设置滚动速度，又可以在 url 链接上没有“小尾巴”。   效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/37.htmHTML文件代码： &
  • kafka offset迁移 kane_xie kafka
    在早前的kafka版本中（0.8.0），offset是被存储在zookeeper中的。   到当前版本（0.8.2）为止，kafka同时支持offset存储在zookeeper和offset manager（broker）中。   从官方的说明来看，未来offset的zookeeper存储将会被弃用。因此现有的基于kafka的项目如果今后计划保持更新的话，可以考虑在合适
  • android > 搭建 cordova 环境 mft8899 android
      1 , 安装 node.js        http://nodejs.org      node -v   查看版本   2, 安装 npm   可以先从  https://github.com/isaacs/npm/tags  下载 源码 解压到
  • java封装的比较器，比较是否全相同，获取不同字段名字 qifeifei
     非常实用的java比较器，贴上代码： import java.util.HashSet; import java.util.List; import java.util.Set; import net.sf.json.JSONArray; import net.sf.json.JSONObject; import net.sf.json.JsonConfig; i
  • 记录一些函数用法 .Aky. 位运算PHP数据库函数IP
    高手们照旧忽略。 想弄个全天朝IP段数据库，找了个今天最新更新的国内所有运营商IP段，copy到文件，用文件函数，字符串函数把玩下。分割出startIp和endIp这样格式写入.txt文件，直接用phpmyadmin导入.csv文件的形式导入。（生命在于折腾，也许你们觉得我傻X，直接下载人家弄好的导入不就可以，做自己的菜鸟，让别人去说吧） 当然用到了ip2long()函数把字符串转为整型数
  • sublime text 3 rust wudixiaotie Sublime Text
    1.sublime text 3 => install package => Rust 2.cd ~/.config/sublime-text-3/Packages 3.mkdir rust 4.git clone https://github.com/sp0/rust-style 5.cd rust-style 6.cargo build --release 7.ctrl
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他