Using Depth Textures

It is possible to create Render Textures where each pixel contains a high precision “depth” value (see RenderTextureFormat.Depth). This is mostly used when some effects need scene’s depth to be available (for example, soft particles, screen space ambient occlusion, translucency would all need scene’s depth). Image Effects often use depth textures too.

Pixel values in the depth texture range from 0 to 1 with a nonlinear distribution. Precision is usually 24 or 16 bits, depending on depth buffer used. When reading from depth texture, a high precision value in 0..1 range is returned. If you need to get distance from the camera, or otherwise linear value, you should compute that manually using helper macros (see below). Since the depth texture contains high precision data, use sampler2D_float data type to declare it (see data types and precision).

Depth textures are supported on most modern hardware and graphics APIs. Special requirements are listed below:

• Direct3D 11+ (Windows), OpenGL 3+ (Mac/Linux), OpenGL ES 3.0+ (Android/iOS), Metal (iOS/Mac) and consoles like PS4/XboxOne all support depth textures.
• Direct3D 9 (Windows) requires a graphics driver to support “INTZ” texture format to get depth textures.
• OpenGL ES 2.0 (iOS/Android) requires GL_OES_depth_texture extension to be present.
• WebGL requires WEBGL_depth_texture extension.
• Direct3D 11 feature level 9.x (common on Windows Phone devices) does not support depth textures.

Depth texture shader helper macros

Most of the time depth textures are used to render depth from the camera. UnityCG.cginc include file contains some macros to deal with the above complexity in this case:

• UNITY_TRANSFER_DEPTH(o): computes eye space depth of the vertex and outputs it in o (which must be a float2). Use it in a vertex program when rendering into a depth texture. On platforms with native depth textures this macro does nothing at all, because Z buffer value is rendered implicitly.
• UNITY_OUTPUT_DEPTH(i): returns eye space depth from i (which must be a float2). Use it in a fragment program when rendering into a depth texture. On platforms with native depth textures this macro always returns zero, because Z buffer value is rendered implicitly.
• COMPUTE_EYEDEPTH(i): computes eye space depth of the vertex and outputs it in o. Use it in a vertex program when not rendering into a depth texture.
• DECODE_EYEDEPTH(i): given high precision value from depth texture i, returns corresponding eye space depth. This macro just returns i*FarPlane on Direct3D. On platforms with native depth textures it linearizes and expands the value to match camera’s range.

For example, this shader would render depth of its objects:

Shader "Render Depth" {
SubShader {
    Tags { "RenderType"="Opaque" }
    Pass {
CGPROGRAM

#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"

struct v2f {
    float4 pos : SV_POSITION;
    float2 depth : TEXCOORD0;
};

v2f vert (appdata_base v) {
    v2f o;
    o.pos = mul (UNITY_MATRIX_MVP, v.vertex);
    UNITY_TRANSFER_DEPTH(o.depth);
    return o;
}

half4 frag(v2f i) : SV_Target {
    UNITY_OUTPUT_DEPTH(i.depth);
}
ENDCG
    }
}
}

Véase también

• Camera Depth Textures.
• Writing Image Effects.