Unity Shader - 根据片段深度重建片段的世界坐标_unity从深度缓冲重建世界空间位置

获取当前绘制片段的世界坐标

在Unity中，获取当前绘制对象中的片段的世界坐标，可以按下列方式：

struct a2v {
	...
	float4 pos : POSITION;
	...
};
struct v2f {
	...
	float4 worldPos : TEXCOORD0;
	...
};
v2f vert(a2v v) {
	v2f o = (v2f)0;
	...
	o.worldPos = mul(unity_ObjectToWorld, v.pos);
	...
	return 0;
}
fixed4 frag(v2f i) : SV_Target {
	i.worldPos ...; // 该片段的世界坐标
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

OK，获取绘制的片段的世界坐标是如此的简单。

那么下面开始实践。

绘制世界坐标

为了方便测试功能正确性，放一些模型，调整好他们的位置、缩放，尽量在unity的1 unit单位范围内。
因为我们要直接用xyz坐标当做颜色绘制出来。所以我们要控制要物体的xyz都尽量在0~1范围内。

模型

先放置一个cube，scaleXYZ都是1，用于作为大小参考物
再放置三个quad，scaleXYZ都是1，三种颜色分别代表：红色：X轴，绿色：Y轴，蓝色：Z轴

再放一个，小Cube，scaleXYZ缩放都是0.1，因为要将它在0~1的坐标范围内移动，弄小一些就好。
再给这个小Cube弄上材质，材质的shader为下面的代码，用于显示世界坐标的。

// jave.lin 2020.03.10 - Draws the world position
Shader "Custom/DrawWP" {
    SubShader {
        Pass {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"
            struct appdata { float4 vertex : POSITION; };
            struct v2f {
                float4 vertex : SV_POSITION;
                float4 wp : TEXCOORD0;
            };
            v2f vert (appdata v) {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.wp = mul(unity_ObjectToWorld, v.vertex);
                return o;
            }
            fixed4 frag (v2f i) : SV_Target { return i.wp; }
            ENDCG
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

好了，那么移动小Cube看看坐标值作为颜色绘制的情况如何

将小Cube直接放大，看看他的各个角度下的片段颜色

OK，那么确定正确的世界坐标绘制颜色。

接下来需要对深度缓存中的值都还原到世界坐标。

重构深度缓存的世界坐标

深度缓存如何拿到啊？可以看看我上一篇的：Unity Shader - 获取BuiltIn深度纹理和自定义深度纹理的方法。

下面执行在后处理流程，在后处理获取深度缓存并转换每个像素到世界坐标。
先简单说明：

• ndc.xyz都是 [-1~1]
• uv的范围是 [0~1]
• ndc.xy 可以表示为 uv * 2 - 1
• ndc.z 的范围 [-1~1] 但实际我们缓存只使用到 [0~1]，可以从深度缓存中读取 0~1的数据（我记得好想DX是[0~1],OpenGL是[-1~1]），这里从_CameraDepthTexture.R读取的是ndc.z，但是_CameraDepthNormalsTexture.BA读取的是EyeZ/Far的一个比例值（Linear01Depth），具体可以查看之前写过的一篇：Unity Shader - 获取BuiltIn深度纹理和自定义深度纹理的数据

那么开始使用ndc来转换到世界坐标。

列出好几种方法，并简单介绍（下面几种方式在DX中没有问题，但在OpenGL中，第一种ndc to world显示有问题，因为我在android上跑，使用底层渲染API是OpenGL的，直接用第二种方式，性能最好，兼容性也好）：

• ndc to world：frag中使用depth与screen.xy得到ndc，再使用_InvVP变换到world space。
• camera world position + frustum corner world space ray + linear01depth：frustum corner world space ray从vert传到frag，frag再用相机世界坐标 + 视锥体（截锥体）world space的角射线 * depth比例值。
• ndc to clip, clip to viewRay, viewRay * linear01depth to viewPos, viewPos to wordPos：vert中先是ndc space到clip space，再就是clip的远截面角落点转为view space的射线viewRay，frag中worldPos = cameraPos + viewRay * linear01depth。

先给相机添加OnRenderImage将深度值转到世界坐标当颜色值绘制

下面所有的代码中的注释都非常详细，推荐看看，本文的正文部分没说的细节，可能在注释里有说明，因为我在写demo时的代码，就将注释写上了，懒得在文章中又在写一遍。

首先挂个下面的脚本，设置好脚本的Camera cam，这个就主相机就好了。

// jave.lin 2020.03.12
using UnityEngine;

public class GetWPosFromDepthScript1 : MonoBehaviour
{
    private Camera cam;
    public Material mat;
    // 这里之所以手动设置，并使用这些变量
    // 而不是用unity内置的，是因为后处理中
    // 部分的矩阵会给替换成一些只渲染一个布满屏幕Quad的正交矩阵信息
    private int _InvVP_hash;        // VP逆矩阵
    private int _VP_hash;           // V矩阵
    private int _Ray_hash;          // Frustum的角射线
    private int _InvP_hash;         // P的逆矩阵
    private int _InvV_hash;         // V的逆矩阵
    private void Start()
    {
        cam = gameObject.GetComponent<Camera>();
        cam.depthTextureMode |= DepthTextureMode.Depth;         // _CameraDepthTexture与_CameraDepthNormalsTexture都测试
        cam.depthTextureMode |= DepthTextureMode.DepthNormals;

        _InvVP_hash = Shader.PropertyToID("_InvVP");
        _VP_hash = Shader.PropertyToID("_VP");
        _Ray_hash = Shader.PropertyToID("_Ray");
        _InvP_hash = Shader.PropertyToID("_InvP");
        _InvV_hash = Shader.PropertyToID("_InvV");
    }
    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        Graphics.Blit(source, destination, mat);
    }
    private void OnPreRender()
    {
        var aspect = cam.aspect;                // 宽高比
        var far = cam.farClipPlane;             // 远截面距离长度
        var rightDir = transform.right;         // 相机的右边方向（单位向量）
        var upDir = transform.up;               // 相机的顶部方向（单位向量）
        var forwardDir = transform.forward;     // 相机的正前方（单位向量）
        // fov = field of view，就是相机的顶面与底面的连接相机作为点的夹角，
        // 我们取一半就好，与相机正前方方向的线段 * far就是到达远截面的位置（这条边当做下面的tan公式的邻边使用）
        // tan(a) = 对 比 邻 = 对/邻
        // 邻边的长度是知道的，就是far值，加上fov * 0.5的角度，就可以求出高度（对边）
        // tan(a)=对/邻
        // 对=tan(a)*邻
        var halfOfHeight = Mathf.Tan(cam.fieldOfView * 0.5f * Mathf.Deg2Rad) * far;
        // 剩下要求宽度
        // aspect = 宽高比 = 宽/高
        // 宽 = aspect * 高
        var halfOfWidth = aspect * halfOfHeight;
        // 前，上，右的角落偏移向量
        var forwardVec = forwardDir * far;
        var upVec = upDir * halfOfHeight;
        var rightVec = rightDir * halfOfWidth;
        // 左下角 bottom left
        var bl = forwardVec - upVec - rightVec;
        // 左上角 top left
        var tl = forwardVec + upVec - rightVec;
        // 右上角 top right
        var tr = forwardVec + upVec + rightVec;
        // 右下角 bottom right
        var br = forwardVec - upVec + rightVec;

        // 视锥体远截面角落点的射线
        var frustumFarCornersRay = Matrix4x4.identity;
        // 经shader中顶点颜色赋值后出入到屏幕，可以确定，第0是：左下角，1：左上角，2：右上角，3：右下角
        frustumFarCornersRay.SetRow(0, bl);
        frustumFarCornersRay.SetRow(1, tl);
        frustumFarCornersRay.SetRow(2, tr);
        frustumFarCornersRay.SetRow(3, br);

        // 使用GL.GetGPUProjectionMatrix接口Unity底层会处理不同平台的投影矩阵的差异
        // 第二个参数是相对RT来使用的，因为RT的UV.v在一些平台是反过来的，这里传false，因为不需要RT的UV变化兼容处理
        Matrix4x4 p = GL.GetGPUProjectionMatrix(cam.projectionMatrix, false);
        Matrix4x4 v = cam.worldToCameraMatrix;
        Matrix4x4 vp = p * v;
        mat.SetMatrix(_InvVP_hash, vp.inverse);
        mat.SetMatrix(_VP_hash, vp);
        mat.SetMatrix(_Ray_hash, frustumFarCornersRay );
        mat.SetMatrix(_InvP_hash, p.inverse);
        mat.SetMatrix(_InvV_hash, v.inverse);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

脚本中，对viewPortRay每行向量，设置了一个射线，分别第几个射线对应哪个角落，可以在shader中，使用SV_VertexID来取到顶点索引，在对索引绘制：0：红，1：绿，2：蓝，3：黄，shader如下：

            struct appdata {
                float4 vertex : POSITION;
                uint vid : SV_VertexID;
            };
            struct v2f {
                float4 vertex : SV_POSITION;
                fixed4 col : TEXCOORD2;
            };
            v2f vert (appdata v) {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                const fixed4x4 vcol = {
                    {1,0,0,1},
                    {0,1,0,1},
                    {0,0,1,1},
                    {1,1,0,1},
                };
                // 测试用的，用于辨别后处理的四个顶点
                // 经过测试id：0在左下角，1：左上角，2：右上角，3：右下角
                o.col = vcol[v.vid];

                return o;
             }
             fixed4 frag (v2f i) : SV_Target { return i.col; }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行效果：

经过测试id：0在左下角，1：左上角，2：右上角，3：右下角

所以在vert中要拿到对应frustum corner ray（视锥体角射线），直接取：_Ray[v.id]就好了，下面一些使用方式中会用到。

ndc to world

在frag shader使用depth与screenPos.xy得到ndc，再使用_InvVP将ndc变换到world space。

详细的描述是：先在直接在片段着色器，获取深度值的ndcZ，float4 fwp = mul(_InvVP, float4(i.uv * 2 - 1, ndcZ, 1));，再fwp /= fwp.w;后，fwp就是深度片段对应的世界坐标了。

有多种写法：
第一种

            struct appdata {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };
            struct v2f {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
            };
            float4x4 _InvVP;
			sampler2D _CameraDepthTexture;
            sampler2D _CameraDepthNormalsTexture;
            v2f vert (appdata v) {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
  			}
            fixed4 frag (v2f i) : SV_Target {
                // tex2D(_CameraDepthTexture, i.uv) 的是ndcZ
                float ndcZ = (SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv));
                // ndc to world pos => worldPos = _InvVP * ndc;
                float4 fwp = mul(_InvVP, float4(i.uv * 2 - 1, ndcZ, 1));
                fwp /= fwp.w;
                return fwp;
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这里为何要将fwp世界坐标乘以它本身的w分量。
可以参考：这篇和这个国外文章

原因：

看起来比较简单，但是其中有一个/w的操作，如果按照正常思维来算，应该是先乘以w，然后进行逆变换，最后再把world中的w抛弃，即是最终的世界坐标，不过实际上投影变换是一个损失维度的变换，我们并不知道应该乘以哪个w，所以实际上上面的计算，并非按照理想的情况进行的计算，而是根据计算推导而来。
已知条件（$M$为$VP$矩阵，$M^{-1}$即为其逆矩阵，$Clip$为裁剪空间，$ndc$为标准设备空间，$world$为世界空间）：
$ndc=Clip.xyzw/Clip.w=Clip/Clip.w$
$world=M^{-1}\ast Clip$
二者结合得：
$world=M^{-1}\ast ndc\ast Clip.w$
我们已知M和ndc，然而还是不知道Clip.w，但是有一个特殊情况，是world的w坐标，经过变换后应该是1，即
$1=world.w=(M^{-1}\ast ndc).w\ast Clip.w$
进而得到$Clip.w=1/(M^{-1}\ast ndc).w$
带入上面等式得到：
$world=(M^{-1}\ast ndc)/(M^{-1}\ast ndc).w$
所以，世界坐标就等于ndc进行VP逆变换之后再除以自身的w。

那么继续ndc to world的内容

第二种
不同的是，使用_CameraDepthNormalsTexture.BA解码出来的线性linear01Depth 值，而不是ndc.z，所以我们需要先将它转换到ndc.z，ndc.z = (1/linear01Depth - _ZBufferParams.y) / _ZBufferParams.x。

            v2f vert (appdata v) {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
            }
            fixed4 frag (v2f i) : SV_Target {
                float depth;
                float3 normal;
                float4 cdn = tex2D(_CameraDepthNormalsTexture, i.uv);
                DecodeDepthNormal(cdn, depth, normal);
                //float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
                //逆矩阵的方式使用的是1/z非线性深度，而_CameraDepthNormalsTexture中的是线性的，进行一步Linear01Depth的逆运算
                /* Linear01Depth的逆运算
                // Z buffer to linear 0..1 depth
                inline float Linear01Depth( float z )
                {
                    return 1.0 / (_ZBufferParams.x * z + _ZBufferParams.y);
                }
                Linear01Depth = 1.0 / (_ZBufferParams.x * z + _ZBufferParams.y);
                (_ZBufferParams.x * z + _ZBufferParams.y) * Linear01Depth = 1
                (_ZBufferParams.x * z + _ZBufferParams.y) = 1/Linear01Depth
                (_ZBufferParams.x * z) = 1/Linear01Depth - _ZBufferParams.y
                z = (1/Linear01Depth - _ZBufferParams.y) / _ZBufferParams.x 
                */
                // 此时的depth是ndcZ：ndc space z value(ndc空间下的z值)
                depth = (1.0/depth - _ZBufferParams.y) /_ZBufferParams.x ;
                // //自己操作深度的时候，需要注意Reverse_Z的情况
                // #if defined(UNITY_REVERSED_Z)
                // depth = 1 - depth;
                // #endif
                
                // 从上面的反Linear01Depth运算，到正确的结果
                // 说明中生成_CameraDepthNormalsTexture时
                // 使用的o.depthNormals.w = COMPUTE_DEPTH_01;深度
                // 就相当于处理了Linear01Depth，不然反运算是不能成功的
                float4 ndc = float4(i.uv.x * 2 - 1, i.uv.y * 2 - 1, depth, 1);
                float4 worldPos = mul(_InvVP, ndc);
                worldPos /= worldPos.w;
                return worldPos;
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

运行效果：

但这种方式都有一个问题，那就是：都有在frag shader里执行float4 worldPos = mul(_InvVP, ndc);，但在后处理的话，就意味着要执行screenW*H格frag shader，执行的片段是很多的。我们接着看看其他更优化的方式。

camera world position + frustum corner world space ray + linear01depth

用相机世界坐标 + 视锥体（截锥体）world space的角射线 * depth比例值。

视锥体的角射线在CSharp脚本传入，视锥体射线：_Ray，_Ray有四个角落的射线，分别为：左下角，左上角，右上角，右下角，_Ray在vert传入frag插值后使用。

这种方式会比ndc to world的方式要高效很多。
在vert中处理内容就只是索引查找：o.ray = _Ray[v.vid];
在frag中，有只有一次tex2D采样，一次加法，一次乘法（第二种一次乘法，第一种还多了个除法，这里是演示不同写法而已）

第一种写法：

主要思想是：CameraWorldPos + FrustumCornerRay * (EyeZ/Far)
放一张图的话，大概是这样的：

GIF来演示，四条FrustomCornerRay的0，1，2，3射线分别对应BLRay,TLRay,TRRay,BRRay

            struct appdata {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                uint vid : SV_VertexID;
            };
            struct v2f {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float3 ray : TEXCOORD1;
            };
            float4x4 _Ray;
            sampler2D _CameraDepthTexture;
            sampler2D _CameraDepthNormalsTexture;
            v2f vert (appdata v) {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.ray = _Ray[v.vid];
            }
            fixed4 frag (v2f i) : SV_Target {
                float eyeZ = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv));
                // worldPos = cameraWorldPos + frustomConerRay * (eyeZ / far);
                // normalize(i.ray) * (eyeZ / far) == 射线 * (eyeZ / far) == 射线 * (Linear01Depth)
                // 所以我才使用了下面的eyeZ * _ProjectionParams.w的方式，因为_ProjectionParams.w == 1/far
                // float3 wp = _WorldSpaceCameraPos.xyz + normalize(i.ray) * eyeZ; // 与正确结果很相似，但肯定是不对的，因为eyeZ是视图空间下的，而i.ray是世界空间下的射线
                // (eyeZ * _ProjectionParams.w) == Linear01Depth(tex2D(depthTex, i.uv).r)
                float3 wp = _WorldSpaceCameraPos.xyz + i.ray * (eyeZ * _ProjectionParams.w);
                return fixed4(wp, 1);
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

第二种写法，也是目前罗列出来的写法中，效率是最高的写法。
都一样的思路，写法不一而已，作参考用，与第一种不同的是frag的内容
主要思想是：CameraWorldPos + FrustumCornerRay * linearEyeRate01Z，用linearEyeRate01Z替换了(EyeZ/Far)

			fixed4 frag (v2f i) : SV_Target {
                float linearEyeRate01Z = Linear01Depth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv));
                // worldPos = cameraWorldPos + frustomConerRay * linearEyeRate01Z;
                // 世界坐标 = 相机坐标 + 射线（注意不是方向，无归一化处理，所以向量模是很重要的） * 该深度与远截面的比例值
                // 下面的链接：linear01Depth存的是什么，以及_CameraDepthTexture.r以及_CameraDepthNormalsTexture解码后的深度值有是什么都有说明
                // https://blog.csdn.net/linjf520/article/details/104723859#t21
                // linearEyeRate01Z就是链接中的AH / AC的比例值
                // linearEyeRate01Z = AH / AC == Linear01Depth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv))
                // Linear01Depth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv)) == DecodeDepthNormal(tex2D(_CameraDepthNormalsTexture, i.uv), out float outLinear01Depth, out float3 normal)中的outLinear01Depth值
                float3 wp = _WorldSpaceCameraPos.xyz + i.ray * linearEyeRate01Z;
                return fixed4(wp, 1);
             }
1
2
3
4
5
6
7
8
9
10
11
12

vert : ndcPos to clipPos, clipPos to viewPos, viewRay=viewPos.xyz, frag : viewRay * linear01depth to world position

这种方式是效率最差的方式。但这里做演示，都罗列一下。

• vertex shader中ndc=float4(v.uv * 2 - 1, 1, 1)，ndc转到clip，再使用_InvP将clip转到view，view生成viewRay下的射线（与之前的不同，之前的是world space下的射线，这里是view space下的射线），将下viewRay传到frag shader；
• frag shader直接拿到vert shader传来的viewRay，再通过读取深度纹理得到ndc.z，再Linear01Depth(ndc.z)得到线性的深度比例值：linear01Depth来对viewRay做线性缩放，得到view space下的坐标viewPos = i.viewRay * linear01Depth，通过float4 worldPos = mul(_InvV, viewPos);。

第一种写法：

            struct appdata {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                uint vid : SV_VertexID;
            };
            struct v2f {
                float4 vertex : SV_POSITION;
                float2 uv : TEXCOORD0;
                float3 ray : TEXCOORD1;
            };
            float4x4 _InvVP;
            float4x4 _InvP;
            float4x4 _InvV;
            sampler2D _CameraDepthTexture;
            v2f vert (appdata v) {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                float far = _ProjectionParams.z;
                float4 clipPos = float4(v.uv * 2 - 1.0, 1.0, 1.0) * far; // 远截面的ndc * far = clip
                float4 viewRay = mul(_InvP, clipPos);
                o.ray = viewRay.xyz;
             }
            fixed4 frag (v2f i) : SV_Target {
                float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
                // i.ray == view space Ray, haven't normalized
                float3 viewPos = i.ray * Linear01Depth(depth);
                // 这里的_InvV原本为：UNITY_MATRIX_I_V，但是shader时运行在后处理时
                // 所以MVP都被替换了，所以要用回原来主相机的MVP相关的矩阵都必须外部自己传进来
                float4 worldPos = mul(_InvV, float4(viewPos, 1));
                return worldPos;
             }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

第二种写法，只有vertex shader不同：

            v2f vert (appdata v) {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                // 两种方式获取(ndc.xy * 0.5 + 0.5)==screenPos
                float4 screenPos = float4(v.uv, 1, 1);       // 方法1
                // float4 screenPos = ComputeScreenPos(o.vertex);  // 方法2
                // screenPos.xy /= screenPos.w;
                float2 ndcPos = screenPos.xy * 2 -1;
                float far = _ProjectionParams.z;
                float3 clipVec = float3(ndcPos, 1) * far;
                float3 viewVec = mul(_InvP, clipVec.xyzz).xyz;
                o.ray = viewVec;
             }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

要注意的是，这种写的性能相对第二种来说比较差，因为vertex有矩阵乘法，fragment也有，虽然后处理顶点不多，一个Quad就四个点，但像素是全屏的数量：ScreenW*ScreenH。

最后添加了Timeline控制一下镜头旋转与后处理过渡背景的参数，看看效果

在正交相机下的深度纹理重构世界坐标

这个应该是unity 2018.3.0f2（我使用的unity版本的坑，后面版本unity应该会修复的）
具体有什么坑，可以看看下面我的shader代码注释里有写得很详细。
或是可以参考之前写的：Unity Shader - 获取BuiltIn深度纹理和自定义深度纹理的数据，只看部分内容：注意Unity正交相机中的深度纹理的编码。

关于正交相机（正交投影、矩阵）的相关知识，可以参考：Orthographic Projection。

下面是我在正交相机下，实现获取深度的世界坐标（与透视的不一样）：

CSharp

// jave.lin 2020.03.12
using UnityEngine;

public class GetWPosFromDepthScript1 : MonoBehaviour
{
    public enum ProjType
    {
        Perspective,
        Orthographic
    }
    public ProjType projType;
    [Range(0, 1)]
    public float alpha = 0.3f;
    public Material mat;
    private Camera cam;
    // 这里之所以手动设置，并使用这些变量
    // 而不是用unity内置的，是因为后处理中
    // 部分的矩阵会给替换成一些只渲染一个布满屏幕Quad的正交矩阵信息
    private static int _InvVP_hash;                 // VP逆矩阵
    private static int _VP_hash;                    // V矩阵
    private static int _Ray_hash;                   // Frustum的角射线
    private static int _InvP_hash;                  // P的逆矩阵
    private static int _InvV_hash;                  // V的逆矩阵

    private static int _Ortho_Ray_hash;             // 正交相机的射线向量
    private static int _Ortho_Ray_Oringin_hash;     // 正交相机的射线起点

    private static int _Alpha_hash;

    static GetWPosFromDepthScript1()
    {
        _InvVP_hash = Shader.PropertyToID("_InvVP");
        _VP_hash = Shader.PropertyToID("_VP");
        _Ray_hash = Shader.PropertyToID("_Ray");
        _InvP_hash = Shader.PropertyToID("_InvP");
        _InvV_hash = Shader.PropertyToID("_InvV");

        _Ortho_Ray_hash = Shader.PropertyToID("_Ortho_Ray");
        _Ortho_Ray_Oringin_hash = Shader.PropertyToID("_Ortho_Ray_Oringin");

        _Alpha_hash = Shader.PropertyToID("_Alpha");
    }
    private void Start()
    {
        cam = gameObject.GetComponent<Camera>();
        cam.depthTextureMode |= DepthTextureMode.Depth;         // _CameraDepthTexture與_CameraDepthNormalsTexture都测试
        cam.depthTextureMode |= DepthTextureMode.DepthNormals;


    }
    private void OnRenderImage(RenderTexture source, RenderTexture destination)
    {
        Graphics.Blit(source, destination, mat);
    }
    private void OnPreRender()
    {
        cam.orthographic = projType == ProjType.Orthographic;

        if (cam.orthographic)
        {
            // 正交的处理
            mat.EnableKeyword("_PROJ_METHOD_ORTHOGRAPHIC");
            mat.DisableKeyword("_PROJ_METHOD_PERSPECTIVE");
            // Camera's half-size when in orthographic mode.
            // https://docs.unity3d.com/ScriptReference/Camera-orthographicSize.html
            // The orthographicSize property defines the viewing volume of an orthographic Camera. In order to edit this size, 
            // set the Camera to be orthographic first through script or in the Inspector. 
            // The orthographicSize is half the size of the vertical viewing volume. The horizontal size of the viewing volume depends on the aspect ratio.
            // 由上面的官方API描述中，可得知，orthograpihcSize是控制 view volume，视图长方体的高度的一半的，orthographicSize = 5，那么view volume height = 10
            // unity 1 unit == 100 pixels，所以view volume height = 10 unit == 1000 pixel
            var halfOfHeight = cam.orthographicSize;
            var halfOfWith = cam.aspect * halfOfHeight;
            //Debug.Log($"size:{cam.orthographicSize}, aspect:{cam.aspect}, hw:{halfOfWith}, hh:{halfOfHeight}");

            // 了解orthographic的投影矩阵，更方便与对参数的应用：http://www.songho.ca/opengl/gl_projectionmatrix.html#ortho

            var upVec = cam.transform.up * halfOfHeight;
            var rightVec = cam.transform.right * halfOfWith;

            // 左下角 bottom left
            var bl = -upVec - rightVec;
            // 左上角 top left
            var tl = upVec - rightVec;
            // 右上角 top right
            var tr = upVec + rightVec;
            // 右下角 bottom right
            var br = -upVec + rightVec;

            // 正交相机的四个角落射线的起点
            var orthographicCornersPos = Matrix4x4.identity;
            // 经shader中顶点颜色赋值后出入到屏幕，可以确定，第0是：左下角，1：左上角，2：右上角，3：右下角
            orthographicCornersPos.SetRow(0, bl);
            orthographicCornersPos.SetRow(1, tl);
            orthographicCornersPos.SetRow(2, tr);
            orthographicCornersPos.SetRow(3, br);

            mat.SetVector(_Ortho_Ray_hash, transform.forward * cam.farClipPlane);
            mat.SetMatrix(_Ortho_Ray_Oringin_hash, orthographicCornersPos);
        }
        else
        {
            // 透视的处理
            mat.EnableKeyword("_PROJ_METHOD_PERSPECTIVE");
            mat.DisableKeyword("_PROJ_METHOD_ORTHOGRAPHIC");

            var aspect = cam.aspect;                // 宽高比
            var far = cam.farClipPlane;             // 远截面距离长度
            var rightDir = transform.right;         // 相机的右边方向（单位向量）
            var upDir = transform.up;               // 相机的顶部方向（单位向量）
            var forwardDir = transform.forward;     // 相机的正前方（单位向量）

            // fov = field of view，就是相机的顶面与底面的连接相机作为点的夹角，
            // 我们取一半就好，与相机正前方方向的线段 * far就是到达远截面的位置（这条边当做下面的tan公式的邻边使用）
            // tan(a) = 对 比 邻 = 对/邻
            // 邻边的长度是知道的，就是far值，加上fov * 0.5的角度，就可以求出高度（对边）
            // tan(a)=对/邻
            // 对=tan(a)*邻
            var halfOfHeight = Mathf.Tan(cam.fieldOfView * 0.5f * Mathf.Deg2Rad) * far;
            // 剩下要求宽度
            // aspect = 宽高比 = 宽/高
            // 宽 = aspect * 高
            var halfOfWidth = aspect * halfOfHeight;
            // 前，上，右的角落偏移向量
            var forwardVec = forwardDir * far;
            var upVec = upDir * halfOfHeight;
            var rightVec = rightDir * halfOfWidth;
            // 左下角 bottom left
            var bl = forwardVec - upVec - rightVec;
            // 左上角 top left
            var tl = forwardVec + upVec - rightVec;
            // 右上角 top right
            var tr = forwardVec + upVec + rightVec;
            // 右下角 bottom right
            var br = forwardVec - upVec + rightVec;

            var frustumCornersRay = Matrix4x4.identity;
            // 经shader中顶点颜色赋值后出入到屏幕，可以确定，第0是：左下角，1：左上角，2：右上角，3：右下角
            frustumCornersRay.SetRow(0, bl);
            frustumCornersRay.SetRow(1, tl);
            frustumCornersRay.SetRow(2, tr);
            frustumCornersRay.SetRow(3, br);
            mat.SetMatrix(_Ray_hash, frustumCornersRay);
        }
        // 公共属性
        // 使用GL.GetGPUProjectionMatrix接口Unity底层会处理不同平台的投影矩阵的差异
        // 第二个参数是相对RT来使用的，因为RT的UV.v在一些平台是反过来的，这里传false，因为不需要RT的UV变化兼容处理
        Matrix4x4 p = GL.GetGPUProjectionMatrix(cam.projectionMatrix, false);
        Matrix4x4 v = cam.worldToCameraMatrix;
        Matrix4x4 vp = p * v;
        mat.SetMatrix(_InvVP_hash, vp.inverse);
        mat.SetMatrix(_VP_hash, vp);
        mat.SetMatrix(_InvP_hash, p.inverse);
        mat.SetMatrix(_InvV_hash, v.inverse);
        mat.SetFloat(_Alpha_hash, alpha);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

可以看到，OnPreRender我添加了一个分支，分别处理正交与透视的逻辑处理。
透视的内容不变，正交的与透视的区别在于：

• 透视构建frustum的角落点射线，主要思路是：camWorldPos + frustumCornerRay * linear01depth;。
• 正交构建的是一条相机前方射线，与四个角射线起点，主要思路是：camWorldPos + viewVolumeCornerPos + camForwardDir * linear01depth;。

Shader

    struct appdata {
        float4 vertex : POSITION;
        float2 uv : TEXCOORD0;
        uint vid : SV_VertexID;
    };
    struct v2f {
        float4 vertex : SV_POSITION;
        float2 uv : TEXCOORD0;
        float4 rayOrigin : TEXCOORD1;
    };
    float _Alpha;
    sampler2D _MainTex;
    sampler2D _CameraDepthTexture;
    sampler2D _CameraDepthNormalsTexture;
    v2f vert_orthographic(appdata v) {
        v2f o;
        o.vertex = UnityObjectToClipPos(v.vertex);
        o.uv = v.uv;
        o.rayOrigin = _Ortho_Ray_Oringin[v.vid];
        return o;
    }
    fixed4 frag_orthographic(v2f i) {
        // 本人jave.lin 2020.03.14，下面代码运行在unity 2018.3.0f2测试结果，如果其他同学的没有这些问题，大概是unity版本不一致
        #if _METHOD_T1
        // 正交相机下，_CameraDepthTexture存储的是线性值，且：距离镜头远的物体，深度值小，距离镜头近的物体，深度值大，可以使用UNITY_REVERSED_Z宏做处理
        // 透视相机下，_CameraDepthTexture存储的是ndc.z值，且：不是线性的。
        float linear01depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv);
        // return linear01depth;
        // 正交下的相机，_CameraDepthTexture纹理中存储的是线性比例值
        #if defined(UNITY_REVERSED_Z) // 正交需要处理这个宏定义，透视不用，估计后面unity版本升级后会处理正交的这个宏定义处理吧
        linear01depth = 1 - linear01depth;
        #endif
        // return linear01depth;
        float3 wp = _WorldSpaceCameraPos.xyz + i.rayOrigin.xyz + _Ortho_Ray.xyz * linear01depth;
        return lerp(tex2D(_MainTex, i.uv), float4(wp, 1), _Alpha);
        #endif

        #if _METHOD_T2
        // _CameraDepthNormalsTexture的纹理，正交相机，与透视相机下都没问题一样这么使用
        float linear01depth = DecodeFloatRG (tex2D(_CameraDepthNormalsTexture, i.uv).zw);
        // return linear01depth;
        // 正交下的相机，_CameraDepthTexture纹理中存储的是线性比例值
        // #if defined(UNITY_REVERSED_Z) // 测试发现，即使正交模式下：使用_CameraDepthNormalsTexture的深度也是有处理UNITY_REVERSED_Z宏分支逻辑的，所以这里不需要Reverse Z
        // linear01depth = 1 - linear01depth;
        // #endif
        // return linear01depth;
        float3 wp = _WorldSpaceCameraPos.xyz + i.rayOrigin.xyz + _Ortho_Ray.xyz * linear01depth;
        return lerp(tex2D(_MainTex, i.uv), float4(wp, 1), _Alpha);
        #endif
        
        #if _METHOD_TCOLOR
        return i.col;
        #endif
        
        return tex2D(_CameraDepthTexture, i.uv).r;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

效果

2020.03.15 更新，在实现其他深度相关的效果是，也法线Unity在SIGGRAPH2011有分享过一些基于使用深度实现的特效的内容，文档：SIGGRAPH2011 Special Effect with Depth.pdf
如果多年后，下载不了，链接无效了，可以点击这里（Passworld：cmte）下载（我收藏到网盘了）

他分享的也是用：深度世界坐标 = 相机世界坐标 + 世界坐标下的相机坐标指向远截面四个角落的射线 * 深度比例值01

总结

透视相机的：还是使用第二种方式兼容性最好（DX，GL都没问题），性能最好。

            v2f vert (appdata v) {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.uv = v.uv;
                o.ray = _Ray[v.vid];
            }
            fixed4 frag (v2f i) : SV_Target {
                float linearEyeRate01Z = Linear01Depth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, i.uv));
                float3 wp = _WorldSpaceCameraPos.xyz + i.ray * linearEyeRate01Z;
                return fixed4(wp, 1);
             }
1
2
3
4
5
6
7
8
9
10
11

正交相机的，我就只写一种方式吧（就上面那种写法），这种也是性能比较高的写法。

Project

backup : UnityShader_GetWorldPosFromDepthTexTesting_2018.03.12

backup : UnityShader_GetWorldPosFromDepthTexTesting_IncludeOrthoTesting_2018.3.0f2

backup : Simplest_WPosFromDepth_2019_4_30f1

Graph

• GetWorldPosFromDepth.ggb

References

• Unity Shader - 获取BuiltIn深度纹理和自定义深度纹理的数据
• Unity从深度缓冲重建世界空间位置
• Unity Shader-深度相关知识总结与效果实现（LinearDepth，Reverse Z，世界坐标重建，软粒子，高度雾，运动模糊，扫描线效果）
• Unity3D实现体积光
• 【Unity Shader】unity海边波浪效果的实现
• 屏幕后处理-无限大水面渲染
• Using _CameraDepthTexture with Orthographic Camera
• Reconstructing Position From Depth - 2020.04.07看到这位大神的博客也有一篇是从深度重构坐标的