The depth map is all zero

[jywu511]

Hi, thanks for the great contribution. I am using this project to collect some data. When I am collecting the depth using, I find the depth is all zero. Could you tell me whether there is some wrong? thanks!

[YGanLab]

Hey,

Are you able to run the scene with objects such as tables and robotic arms? Thanks!

[liyuan-qiu]

Hi, thanks for the great contribution. I am using this project to collect some data. When I am collecting the depth using, I find the depth is all zero. Could you tell me whether there is some wrong? thanks!

Same all zero depth picture. I have tried different shader in Unity, but none of them works.

[liyuan-qiu]

Shader "Custom/HDRPDepthShader2019"
{
Properties
{
_MainTex ("Texture", 2D) = "white" {}
_DepthMin ("Minimum Depth", Float) = 0.01
_DepthMax ("Maximum Depth", Float) = 10.0
}
SubShader
{
Tags { "RenderPipeline" = "HDRenderPipeline" }

    Pass
    {
        ZTest Always
        ZWrite Off
        Cull Off

        HLSLPROGRAM
        #pragma vertex vert
        #pragma fragment frag
        
        #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
        #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"

        struct Attributes
        {
            uint vertexID : SV_VertexID;
        };

        struct Varyings
        {
            float4 positionCS : SV_POSITION;
            float2 texcoord : TEXCOORD0;
        };

        float _DepthMin;
        float _DepthMax;

        Varyings vert(Attributes input)
        {
            Varyings output;
            output.texcoord = float2((input.vertexID << 1) & 2, input.vertexID & 2);
            output.positionCS = float4(output.texcoord * 2.0 - 1.0, 0, 1);
            output.texcoord.y = 1 - output.texcoord.y;
            return output;
        }

        float4 frag(Varyings input) : SV_Target
        {
            float2 uv = input.texcoord;
            
            // Use HDRP's built-in depth sampling
            #if UNITY_REVERSED_Z
                float depth = SampleCameraDepth(uv);
            #else
                float depth = 1.0 - SampleCameraDepth(uv);
            #endif

            // Convert to linear depth
            float linearDepth = LinearEyeDepth(depth, _ZBufferParams);
	                
            // Normalize depth between min and max values
            //float normalizedDepth = (linearDepth - _DepthMin) / (_DepthMax - _DepthMin);
            //float linearDepth = 1.0 / (_ZBufferParams.x * depth + _ZBufferParams.y);
            float normalizedDepth = (linearDepth - _DepthMin) / (_DepthMax - _DepthMin);
            // Output depth (closer objects are darker)
            return float4(normalizedDepth.xxx, 1);
        }
        /*
        float4 frag(Varyings input) : SV_Target
        {
            float2 uv = input.texcoord;
            float rawDepth = SampleCameraDepth(uv);
            
            // Get linear eye space depth
            float linearDepth = LinearEyeDepth(rawDepth, _ZBufferParams);
            
            // Convert UV t2o view space coordinates (-1 to 1)
            float2 uvToView = (uv * 2.0 - 1.0);
            
            // For HDRP, we can use _ProjectionParams
            // _ProjectionParams.y is near plane
            // _ProjectionParams.z is far plane
            // _ScreenParams.x is screen width
            // _ScreenParams.y is screen height
            
            float aspect = _ScreenParams.x / _ScreenParams.y;
            
            // Approximate FOV calculation (you might want to pass this as a property instead)
            float fov = radians(60.0); // Default 60 degree FOV, adjust as needed
            
            // Calculate x and y offsets based on FOV
            float xOffset = uvToView.x * linearDepth * tan(fov * 0.5) * aspect;
            float yOffset = uvToView.y * linearDepth * tan(fov * 0.5);
            
            // Calculate true distance using Pythagorean theorem
            float trueDistance = sqrt(xOffset * xOffset + yOffset * yOffset + linearDepth * linearDepth);
            
            // Normalize between your near and far planes

            float normalizedDepth = (trueDistance - _DepthMin) / (_DepthMax - _DepthMin);
            
            return float4(normalizedDepth.xxx, 1);
        } 
        */          
        ENDHLSL
    }
}

}

=======================
This is the shader of HDRP pipeline that can generate the depth image correctly. I thought the URP can't work in this project. And you should use the Unity 2019 to correctly run the HDRP