Chapter13 深度和法线纹理——Shader入门精要学习笔记

🕗 发布于 2024-07-19 06:14 学习笔记

Chapter13 深度和法线纹理

一、深度和法线纹理的原理和获取
二、再谈运动模糊
三、全局雾效 —— 屏幕后处理
四、再谈边缘检测
- 1.EdgeDetect.cs
- 2.EdgeDetectShader

一、深度和法线纹理的原理和获取

1.背后的原理

①深度纹理

定义：是一张存储深度信息的纹理图像，像素值代表像素点到摄像机的距离
生成原理：
- 深度值来源于顶点变换后得到的归一化设备坐标 NDC中顶点坐标的z分量的值
- 如下图，最左侧为投影变换前；中间为应用透视裁剪矩阵后的变换结果，即顶点着色器输出的顶点变换结果；右侧是底层硬件进行了透视除法后得到的归一化设备坐标（透视投影是非线性的，正交投影是线性的）
- 需要进行线性映射才能存储在纹理中： $0.5\cdot z_{ndc} + 0.5$ （d为深度纹理中的像素值， $z_{ndc}$ 为NDC坐标中的z分量值
精度通常为24位或16位

②法线纹理

定义：是一张存储法线信息的纹理图像，像素值代表像素点在世界空间中的法线方向
生成原理：
- 在延迟渲染中，法线信息存储在G-buffer中，可以直接获取
- 在前向渲染中，Unity会使用单独的Pass对场景进行渲染，并生成法线纹理
如果选择生成一张深度+法线纹理，Unity会创建一张与屏幕分辨率相同、精度为32位（每个通道为8位）的纹理，其中观察空间下的法线信息会被编码到纹理的R和G通道，深度信息会进B和A通道

2.如何获取

设置摄像机：通过脚本设置摄像机的 depthTextureMode 属性，可以选择生成深度纹理或者深度+法线纹理
- camera.depthTextureMode = DepthTextureMode.Depth;
- camera.depthTextureMode = DepthTextureMode.DepthNormals;
在Shader中访问：使用预定义变量访问 _CameraDepthTexture、_CameraDepthNormalsTexture
- 绝大多数下可以直接使用 tex2D 函数进行采样，也可以使用SAMPLE_DEPTH_TEXTURE ，处理平台差异化float d = SAMPLE_DEPTH_TEXTURE (CameraDepthTexture, i.uv);
深度值转换：在计算过程中通常需要线性的深度值，即要把投影后的深度值变换到线性空间下。可以使用 LinearEyeDepth 和 Linear01Depth 函数进行转换
- LinearEyeDepth：负责把深度纹理采样结果转换到视角空间下的深度值——线性的
- Linear01Depth：返回一个范围在[0,1]的线性深度值
法线值解码：可以直接使用 tex2D 对 _CameraDepthNormalsTexture 直接进行采样，再使用 DecodeDepthNormal 函数进行解码，解码后得到的是 [0,1]范围内的线性深度值 和 视角空间下的法线方向，也可以用DecodeFloatRG 和 DecodeViewNormalStereo 来解码深度+法线纹理中的信息

3.查看深度和法线纹理

利用 frame debugger 帧调试器来查看（看到的是非线性空间的深度值）
可以再片元着色器中输出转换或解码后的深度和法线值

float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
float linearDepth = Linear01Depth(depth);
return fixed4(linearDepth,linearDepth,linearDepth,1.0);

fixed3 normal = DecodeViewNormalStereo(tex2D(_CameraDepthNormalsTexture, i.uv).xy);
return fixed4(normal * 0.5 + 0.5, 1.0);

在这里插入图片描述

二、再谈运动模糊

1.速度映射

步骤
- 利用深度纹理再片元着色器中为每个像素计算其在世界空间中的位置——使用当前 视角 * 投影矩阵的逆矩阵 对NDC下的顶点坐标进行变换得到的
- 得到世界空间中的位置后，使用 前一帧的视角*投影矩阵 对其进行变换，得到该位置在前一帧中的NDC坐标
- 计算前一帧和当前帧的位置差，生成该像素的速度
优点：可以在一个屏幕后处理步骤中完成整个效果模拟
缺点：需要在片元着色器中进行两次矩阵乘法，性能有影响

2.MotionBlurWithDepthTexture.cs

 private Camera myCamera;
 public Camera camera
 {
     get
     {
         if(myCamera == null) 
         {
             myCamera = GetComponent<Camera>();
         }
         return myCamera;
     }
 }

由于需要得到相机的视角和投影矩阵，定义一个Camera类型的变量，来获取该脚本所在的摄像机组件

 private Matrix4x4 previousViewProjectionMatrix;

定义一个变量来保存上一帧摄像机的 视角*投影矩阵

private void OnEnable()
{
    camera.depthTextureMode |= DepthTextureMode.Depth;
}

设置摄像机的状态——获取摄像机的深度纹理

 private void OnRenderImage(RenderTexture src, RenderTexture dest)
 {
     if(material != null)
     {
         material.SetFloat("_BlurSize", blurSize);

         material.SetMatrix("_PreviousViewProjectionMatrix", previousViewProjectionMatrix);
         Matrix4x4 currentViewProjectionMatrix = camera.projectionMatrix * camera.worldToCameraMatrix;
         Matrix4x4 currentViewProjectionInverseMatrix = currentViewProjectionMatrix.inverse;
         material.SetMatrix("_CurrentViewProjectionInverseMatrix", currentViewProjectionInverseMatrix);
         previousViewProjectionMatrix = currentViewProjectionMatrix;

         Graphics.Blit(src, dest, material);
     }
     else
     {
         Graphics.Blit(src, dest);
     }
 }

需要两个矩阵：前一帧的视角×投影矩阵 & 当前帧的（视角×投影矩阵）的逆矩阵
camera.projectionMatrix得到投影矩阵，camera.worldToCameraMatrix得到视角矩阵
再把取逆结果前的结果存储再 previousViewProjectionMatrix 变量中，给下一帧用

3.MotionBlurShader

Properties
{
    _MainTex ("Base(RGB)",2D) = "white"{}
    _BlurSize ("Blur Size",Float) = 1.0
}
SubShader
{
    CGINCLUDE
    #include "UnityCG.cginc"
    sampler2D _MainTex;
    half4 _MainTex_TexelSize;
    sampler2D _CameraDepthTexture;
    float4x4 _CurrentViewProjectionInverseMatrix;
    float4x4 _PreviousViewProjectionMatrix;
    half _BlurSize;

除了定义在Propertise里面的属性，还声明了另外三个变量。_CameraDepthTexture 是Unity传递给我们的深度纹理，而_CurrentViewProjectionInverseMatrix 和 _PreviousViewProjectionMatrix 是脚本传递来的矩阵（不支持在属性面板中设置）

 struct v2f{
     float4 pos : SV_POSITION;
     half2 uv : TEXCOORD0;
     half2 uv_depth : TEXCOORD1;
 };

 v2f vert(appdata_img v)
 {
     v2f o;
     o.pos = UnityObjectToClipPos(v.vertex);
     o.uv = v.texcoord;
     o.uv_depth = v.texcoord;

     #if UNITY_UV_STARTS_AT_TOP
     if (_MainTex_TexelSize.y < 0)
         o.uv_depth.y = 1-o.uv_depth.y;
     #endif
     return o;
 }

增加了专门用于对深度纹理采样的纹理坐标变量

fixed4 frag(v2f i) : SV_Target 
{
    //得到该像素的深度缓存的值
    float d = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv_depth);
    //H为像素的视角位置
    float4 H = float4(i.uv.x * 2 - 1, i.uv.y * 2 - 1, d * 2 - 1, 1);
    //用视角投影逆矩阵变换
    float4 D = mul(_CurrentViewProjectionInverseMatrix, H);
    //除以w，得到世界位置
    float4 worldPos = D/D.w;

    //当前视角位置
    float4 currentPos = H;
    //用世界位置，以及前一帧的矩阵得到前一帧的视角位置
    float4 previousPos = mul(_PreviousViewProjectionMatrix, worldPos);
    //除以w
    previousPos /= previousPos.w;

    //用两帧的位置差得到速度
    float2 velocity = (currentPos.xy - previousPos.xy) / 2.0f;

    float2 uv = i.uv;
    float4 c = tex2D(_MainTex, uv);
    uv += velocity * _BlurSize;
    for(int it = 1; it < 3; it++, uv += velocity * _BlurSize)
    {
        float4 currentColor = tex2D(_MainTex, uv);
        c += currentColor;
    }
    c /= 3;

    return fixed4(c.rgb, 1.0);
}

先 SAMPLE_DEPTH_TEXTURE 对深度纹理进行采样，得到深度值d
d是由NDC映射来的，要构建NDC坐标H，就要把xy值和深度值d重新映射回NDC（即映射函数的反函数 z = 2*d+1）
利用当前帧的视角投影矩阵的逆矩阵，并除以它的w分量来求该像素在世界空间下的位置worldPos
得到后再用前一帧的视角投影矩阵来变换，得到previousPos
计算位置差得到该像素的速度 velocity = (currentPos.xy - previousPos.xy) / 2
邻域采样
- uv += velocity * _BlurSize;：根据速度和模糊大小计算邻域像素的纹理坐标
- float4 currentColor = tex2D(_MainTex, uv);：对邻域像素进行采样，得到颜色值
- c += currentColor：将领域像素颜色累加到c中
模糊效果
- c /= 3; 将邻域像素颜色平均，得到模糊颜色

三、全局雾效 —— 屏幕后处理

屏幕后处理生成的雾效不需要修改场景内物体的shader，自由度很高，方便模拟各种雾效——均匀的、基于距离的线性/指数雾效、基于高度的雾效等
屏幕后处理的雾效关键：根据深度纹理来重建每个像素在世界空间下的位置。上一节中使用的是在shader中进行两次计算，性能消耗大
本节方法：
- 首先对图像空间下的视锥体射线（从摄像机出发，指向图像上某点的射线）进行插值，这条射线存储了该像素在世界空间下到摄像机的方向信息
- 把该射线和线性化后的视角空间下的深度值相乘，再加到摄像机的世界空间位置，即可得到该像素在世界空间下的位置

1.重建世界坐标

思想：知道摄像机的世界坐标位置，以及世界空间下该像素相对于摄像机的偏移量，相加即可得到 float4 worldPos = _WorldSpaceCameraPos + linearDepth * interpolatedRay;
- _WorldSpaceCameraPos 为Unity内置变量
- linearDepth * interpolatedRay 可以计算偏移量

interpolatedRay的求法

来源于对近平面的4个角的某个特定向量的插值，这4个向量包含了它们到摄像机方向的距离和信息，可以利用摄像机近平面距离、FOV、纵横比来计算
可以先计算 toTop 和 toRight 向量，起点位于近平面的中心，分别指向正上方和正右方
- $\times tan(\frac{FOV}{2})$
- $\times halfHeight$
- $\times halfHeight \cdot aspect$
得到后，根据矢量计算得到四个角的向量
- $camera.foward\cdot Near + toTop - toRight$
- $camera.foward\cdot Near + toTop + toRight$
- $camera.foward\cdot Near - toTop - toRight$
- $camera.foward\cdot Near - toTop + toRight$
因为像素的深度值是平行于z轴的，不是欧拉距离，现在需要把深度值转换为欧拉距离dist（由相似三角形可得）
- $\frac{depth}{dist} = \frac{Near}{|TL|}$
- $\frac{|TL|}{Near} \times depth$
由于四个点相互对称，因此其他三个向量的模和TL相等，即我们可以使用同一个因子和单位向量相乘，得到其对应的向量值
- $\frac{|TL|}{|Near|}$
- $Ray_{TL} = \frac{TL}{|TL|} \times scale$
- $Ray_{TR} = \frac{TR}{|TR|} \times scale$
- …
这个四边形面片的4个顶点就对应了近裁剪平面的4个角。因此可以把上面的计算结果传递给顶点着色器，顶点着色器根据当前的位置选择所对应的向量，再将其输出，经过插值后传递给片元着色器得到 interpolatedRay

2.雾的计算

在简单的雾效实现中，需要一个雾效系数f，作为混合原始颜色和雾的颜色的混合系数float3 afterFog = f * fogColor + (1-f) * origColor;
三种雾的计算方式：线性、指数、指数的平方
本节利用线性，计算基于高度的雾效
方法：给定一点在世界空间下的高度y后， $\frac{H_{end}-y}{H_{end}-H_{start}}$ ， $H_{end}$ 和 $H_{start}$ 分别表示雾影响的终止高度和起始高度

3.FogWithDepthTex.cs

private Camera myCamera;
public Camera camera
{
    get
    {
        if (myCamera == null)
        {
            myCamera = GetComponent<Camera>();
        }
        return myCamera;
    }
}
private Transform myCameraTransform;
public Transform cameraTransform
{
    get
    {
        if(myCameraTransform == null)
        {
            myCameraTransform = camera.transform;
        }
        return myCameraTransform;
    }
}

需要获取摄像机的相关参数，如近平面的距离、FOV等，同时还需要获取摄像机在世界空间下的前方、上方、右方等方向。因此用两个变量来存储camera和Transform组件

//定义模拟雾效时使用的参数
[Range(0.0f, 3.0f)]
public float fogDensity = 1.0f;

public Color fogColor = Color.white;
public float fogStart = 0.0f;
public float fogEnd = 2.0f;

fogDensity控制雾的浓度，fogColor用于控制雾的颜色

private void OnEnable()
{
    camera.depthTextureMode |= DepthTextureMode.Depth;
}

获取摄像机的深度纹理——设置摄像机的状态

 private void OnRenderImage(RenderTexture src, RenderTexture dest)
 {
     if(material != null)
     {
         Matrix4x4 frustumCorners = Matrix4x4.identity;

         float fov = camera.fieldOfView;
         float aspect = camera.aspect;
         float near = camera.nearClipPlane;
         float far = camera.farClipPlane;

         float halfHeight = near * Mathf.Tan(fov * 0.5f * Mathf.Deg2Rad);
         Vector3 toRight = cameraTransform.right * halfHeight * aspect;
         Vector3 toTop = cameraTransform.up * halfHeight;

         Vector3 tL = cameraTransform.forward * near + toTop - toRight;
         Vector3 tR = cameraTransform.forward * near + toTop + toRight;
         Vector3 bL = cameraTransform.forward * near - toTop - toRight;
         Vector3 bR = cameraTransform.forward * near - toTop + toRight;

         float scale = tL.magnitude / near;
         tL.Normalize();
         tL *= scale;
         tR.Normalize();
         tR *= scale;
         bL.Normalize();
         bL *= scale;
         bR.Normalize();
         bR *= scale;

         frustumCorners.SetRow(0, bL);
         frustumCorners.SetRow(1, bR);
         frustumCorners.SetRow(2, tR);
         frustumCorners.SetRow(3, tL);

         material.SetMatrix("_FrustumCornersRay", frustumCorners);
         material.SetMatrix("_ViewProjectionInverseMatrix", (camera.projectionMatrix * camera.worldToCameraMatrix).inverse);

         material.SetFloat("_FogDensity", fogDensity);
         material.SetColor("_FogColor", fogColor);
         material.SetFloat("_FogStart", fogStart);
         material.SetFloat("_FogEnd", fogEnd);

         Graphics.Blit(src,dest, material);

     }
     else
     {
         Graphics.Blit(src,dest);
     }
 }

首先计算近平面的四个角对应的向量，并存储在一个矩阵类型的变量中 frustumCorners 中，要按照顺序来存储（因为决定了我们在顶点着色器中使用哪一行作为该点的待插值向量）

4.FogShader

struct v2f{
    float4 pos : SV_POSITION;
    half2 uv : TEXCOORD0;
    half2 uv_depth : TEXCOORD1;
    float4 interpolatedRay : TEXCOORD2;
};

v2f vert(appdata_img v)
{
    v2f o;
    o.pos = UnityObjectToClipPos(v.vertex);
    o.uv = v.texcoord;
    o.uv_depth = v.texcoord;

    #if UNITY_UV_STARTS_AT_TOP
    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;
    }

     #if UNITY_UV_STARTS_AT_TOP
    if(_MainTex_TexelSize.y < 0)
        index = 3- index;
    #endif

    o.interpolatedRay = _FrustumCornersRay[index];

    return o;
}

定义了interpolatedRay 变量存储插值后的像素向量
通过判断纹理坐标来决定要用哪个角的向量插值
- 纹理坐标的(0,0)点对应左下角，(1,1)对应了右上角
- 使用索引值来获取_FrustumCornersRay 中对应的行为作为该顶点的interpolatedRay 值

 fixed4 frag(v2f i) : SV_Target 
 {
     float linearDepth = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE (_CameraDepthTexture, i.uv_depth));
     float3 worldPos = _WorldSpaceCameraPos + linearDepth * i.interpolatedRay.xzy;

     float fogDensity = (_FogEnd-worldPos.z) / (_FogEnd - _FogStart);
     fogDensity = saturate(fogDensity * _FogDensity);

     fixed4 finalColor = tex2D(_MainTex,i.uv);
     finalColor.rgb = lerp(finalColor.rgb, _FogColor.rgb, fogDensity);

     return finalColor;
 }

首先要重建该像素在世界空间中的位置
- 先对深度纹理进行采样，在用LinearEyeDepth得到视角空间下的线性深度值
- 再与interpolatedRay相乘后再和世界空间下的摄像机位置相加，得到世界空间下的位置
再计算 fogDensity，再与原始颜色混合后返回

四、再谈边缘检测

上一章中，直接利用sobel算子边缘检测会得到很多杂乱的边缘线
本节再深度和法线纹理上进行边缘检测，不会受纹理和光照的影响，而仅仅保留了当前渲染物体的模型信息
本节将使用 Roberts 算子来进行边缘检测
- 本质上就是计算左上角和右下角的插值 × 右上角与左下角的插值，作为评估边缘的依据
- 在实现中，取对角线方向的深度或法线值，比较他们之间的插值，若超过某个阈值，就认为他们存在一条边

1.EdgeDetect.cs

 [Range(0.0f, 1.0f)]
 public float edgesOnly = 0.0f;

 public Color edgeColor = Color.black;

 public Color backgroundColor = Color.white;

 public float sampleDistance = 1.0f;

 public float sensitivityDepth = 1.0f;

 public float sensitivityNormals = 1.0f;

sampleDistance 用于控制对深度+法线采样时，使用的采样距离，视觉上看，值越大，描边越宽
灵敏度 sensitivityDepth 和 sensitivityNormals 会影响当邻域的深度值或法线值相差多少时认为存在一条边

    void OnEnable()
    {
        GetComponent<Camera>().depthTextureMode |= DepthTextureMode.DepthNormals;
    }

由于需要获得摄像机的深度+法线纹理

 [ImageEffectOpaque]
 void OnRenderImage(RenderTexture src, RenderTexture dest)
 {
     if (material != null)
     {
         material.SetFloat("_EdgeOnly", edgesOnly);
         material.SetColor("_EdgeColor", edgeColor);
         material.SetColor("_BackgroundColor", backgroundColor);
         material.SetFloat("_SampleDistance", sampleDistance);
         material.SetVector("_Sensitivity", new Vector4(sensitivityNormals, sensitivityDepth, 0.0f, 0.0f));

         Graphics.Blit(src, dest, material);
     }
     else
     {
         Graphics.Blit(src, dest);
     }
 }

[ImageEffectOpaque] 属性表示只在不透明物体上进行描边

2.EdgeDetectShader

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
_Sensitivity ("Sensitivity", Vector) = (1, 1, 1, 1)
}
SubShader {
CGINCLUDE

#include "UnityCG.cginc"

sampler2D _MainTex;
half4 _MainTex_TexelSize;
fixed _EdgeOnly;
fixed4 _EdgeColor;
fixed4 _BackgroundColor;
float _SampleDistance;
half4 _Sensitivity;

sampler2D _CameraDepthNormalsTexture;

声明需要的属性

struct v2f {
float4 pos : SV_POSITION;
half2 uv[5]: TEXCOORD0;
};
  
v2f vert(appdata_img v) {
v2f o;
o.pos = UnityObjectToClipPos(v.vertex);

half2 uv = v.texcoord;
o.uv[0] = uv;

#if UNITY_UV_STARTS_AT_TOP
if (_MainTex_TexelSize.y < 0)
uv.y = 1 - uv.y;
#endif

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;
}

定义了一个5维数组，第一个坐标存储了屏幕颜色图像的采样纹理，对深度纹理采样坐标进行了平台差异化处理
数组中剩余四个坐标则存储了Roberts 算子需要采样的纹理坐标，还使用了_SampleDistance来控制采样距离
把计算采样纹理坐标的代码从片元着色器移到顶点中可以减少运算‘

fixed4 fragRobertsCrossDepthAndNormal(v2f i) : SV_Target {
half4 sample1 = tex2D(_CameraDepthNormalsTexture, i.uv[1]);
half4 sample2 = tex2D(_CameraDepthNormalsTexture, i.uv[2]);
half4 sample3 = tex2D(_CameraDepthNormalsTexture, i.uv[3]);
half4 sample4 = tex2D(_CameraDepthNormalsTexture, i.uv[4]);

half edge = 1.0;

edge *= CheckSame(sample1, sample2);
edge *= CheckSame(sample3, sample4);

fixed4 withEdgeColor = lerp(_EdgeColor, tex2D(_MainTex, i.uv[0]), edge);
fixed4 onlyEdgeColor = lerp(_EdgeColor, _BackgroundColor, edge);

return lerp(withEdgeColor, onlyEdgeColor, _EdgeOnly);
}

首先使用4个纹理坐标对深度进行采样，再调用CheckSame函数来计算对角线上两个纹理值的差值。
CheckSame函数返回两个值，0是有边界，1是没有边界

half CheckSame(half4 center, half4 sample) {
half2 centerNormal = center.xy;
float centerDepth = DecodeFloatRG(center.zw);
half2 sampleNormal = sample.xy;
float sampleDepth = DecodeFloatRG(sample.zw);

// difference in normals
// do not bother decoding normals - there's no need here
half2 diffNormal = abs(centerNormal - sampleNormal) * _Sensitivity.x;
int isSameNormal = (diffNormal.x + diffNormal.y) < 0.1;
// difference in depth
float diffDepth = abs(centerDepth - sampleDepth) * _Sensitivity.y;
// scale the required threshold by the distance
int isSameDepth = diffDepth < 0.1 * centerDepth;

// return:
// 1 - if normals and depth are similar enough
// 0 - otherwise
return isSameNormal * isSameDepth ? 1.0 : 0.0;
}

首先从 center 和 sample 中分别提取法线和深度值
计算两个像素的法线差异 diffNormal，并乘以法线灵敏度 _Sensitivity.x
判断法线差异是否小于阈值 0.1，如果小于则认为法线相似，否则认为不相似
- diffNormal.x 表示法线在 x 轴方向上的差异。
- diffNormal.y 表示法线在 y 轴方向上的差异。
- 将这两个分量相加，可以得到 法线差异向量在两个方向上的总差异
计算两个像素的深度差异 diffDepth，并乘以深度灵敏度 _Sensitivity.y
将深度差异乘以中心像素的深度值，得到距离缩放后的深度差异
判断距离缩放后的深度差异是否小于阈值 0.1 * centerDepth，如果小于则认为深度相似，否则认为不相似
如果法线和深度都相似，则返回 1，否则返回 0

原文地址：https://blog.csdn.net/weixin_70073176/article/details/140523281

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Java_MyBatisPlus
下一篇：MongoDB学习笔记

数据中台建设（六）—— 数据开发-提取数据价值
数据开发涉及的产品能力主要包括三部分：离线开发、实时开发和算法开发。
阅读更多2024-09-21
vue项目引入比较独特的字体的方法
.ttf格式的字体文件在vue项目中的使用
阅读更多2024-09-21
es的封装
es他使用的网络协议时http，序列化协议用的json。而es客户端给我们提供的三个接口中，我们需要填的就是一个请求正文，所以我们主要是针对这个正文json的一个组织。es基本请求格式提示：以下是本篇
阅读更多2024-09-21
MySQL中几种常见的行格式
动态格式会根据行中数据的实际大小动态地调整行的存储方式。如果行中的某个字段是变长的，那么这个字段的实际数据将被存储在行的末尾，而不会在行的开头占用固定的空间。这种格式适用于所有列都是固定长度的情况，可
阅读更多2024-09-21
通信工程学习：什么是LMDS本地多点分配系统
通信工程学习：什么是LMDS本地多点分配系统
阅读更多2024-09-21
Sentinel组件学习
本篇博文是sentinel组件的学习科普文章，主要讲述了sentinel的作用，springCoud整合，以及sentinel dashboard安装和使用，以及流控规则、熔断规则、热点规则的配置和使
阅读更多2024-09-21
【PyTorch】Tensor（张量）介绍
Tensor 中文为张量。张量的意思是一个，它是标量、向量、矩阵的高维扩展。标量可以称为 0 维张量，向量可以称为 1 维张量，矩阵可以称为 2 维张量，RGB 图像可以表示 3 维张量。你可以把张量
阅读更多2024-09-21
【计算机网络 - 基础问题】每日 3 题（十六）
✍个人博客：Pandaconda-CSDN博客📣专栏地址：http://t.csdnimg.cn/fYaBd📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~📝推荐参考地址：ht
阅读更多2024-09-21
@EnableScheduling 和 @Scheduled 实现定时任务的任务延期问题
本文主要讲述了使用 @EnableScheduling 可能出现的线程阻塞导致定时任务延期的问题，也顺便解释了动态定时任务源码上的实现
阅读更多2024-09-21
WPF 自定义路由事件
路由事件的所有者类类型。不能为 null（比如你声明一个控件，你对这个控件定义一个路由，所有者就是这个控件）当我需要调用的时候，只需要再调用的地方为该路由指定一个方法，然后满足触发该路由条件时，就会触
阅读更多2024-09-21

Chapter13 深度和法线纹理——Shader入门精要学习笔记

Chapter13 深度和法线纹理

一、深度和法线纹理的原理和获取

1.背后的原理

①深度纹理

②法线纹理

2.如何获取

3.查看深度和法线纹理

二、再谈运动模糊

1.速度映射

2.MotionBlurWithDepthTexture.cs

3.MotionBlurShader

三、全局雾效 —— 屏幕后处理

1.重建世界坐标

interpolatedRay的求法

2.雾的计算

3.FogWithDepthTex.cs

4.FogShader

四、再谈边缘检测

1.EdgeDetect.cs

2.EdgeDetectShader

相关文章