Почему _BaseMap пустая? (Unity URP)

Shader "Hidden/CustomRenderer/VelocityObjects"
{
    Properties
    {
        [MainTexture, PerRenderData] _BaseMap("Base Map", 2D) = "white"
    }
    SubShader
    {
        Pass
        {
            Name "VelocityObjects"
            Tags { "LightMode" = "MotionVectors" }

            HLSLPROGRAM
            #pragma target 3.0

            //--------------------------------------
            // GPU Instancing
            #pragma multi_compile_instancing

            #pragma vertex vert
            #pragma fragment frag

            // -------------------------------------
            // Includes

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
       
            TEXTURE2D(_BaseMap);
            SAMPLER(sampler_BaseMap);

            CBUFFER_START(UnityPerMaterial)
                float4 _BaseMap_ST;
            CBUFFER_END

            struct Attributes
            {
                float2 texcoord             : TEXCOORD0;
                float4 position             : POSITION;
                float4 positionOld          : TEXCOORD4;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4 positionCS           : SV_POSITION;
                float2 uv                   : TEXCOORD0;
                float3 HPos                 : TEXCOORD1;
                float3 HPosPrev             : TEXCOORD2;
                float posModified           : TEXCOORD3;
                UNITY_VERTEX_INPUT_INSTANCE_ID
                UNITY_VERTEX_OUTPUT_STEREO
            };

            float4 HPosToScreenTC(float4 HPos/*, bool scaled = true*/)
            {
                float4 ScrTC = HPos;
                ScrTC.xy = (HPos.xy * float2(1, -1) + HPos.ww) * 0.5;
                //if (scaled) ScrTC.xy = GetScaledScreenTC(ScrTC.xy);

                return ScrTC;
            }

            Varyings vert(Attributes input)
            {
                Varyings output = (Varyings)0;

                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_TRANSFER_INSTANCE_ID(input, output);
                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);

                output.positionCS = TransformObjectToHClip(input.position.xyz);

                // this works around an issue with dynamic batching
                // potentially remove in 5.4 when we use instancing
                #if defined(UNITY_REVERSED_Z)
                    output.positionCS.z -= unity_MotionVectorsParams.z * output.positionCS.w;
                #else
                    output.positionCS.z += unity_MotionVectorsParams.z * output.positionCS.w;
                #endif

                const float4 prevPos = (unity_MotionVectorsParams.x == 1) ? input.positionOld : input.position;
                float4 prevPosCS = mul(UNITY_MATRIX_VP, mul(unity_MatrixPreviousM, prevPos));

                output.HPosPrev = HPosToScreenTC(prevPosCS).xyw;

                const float4 currPos = mul(UNITY_MATRIX_VP, mul(UNITY_MATRIX_M, input.position));
                output.HPos = HPosToScreenTC(currPos).xyw;

                output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);

                bool isNewPos = output.HPos != output.HPosPrev;
                if (isNewPos || unity_MotionVectorsParams.x == 1) output.posModified = 1;

                return output;
            }

            float2 EncodeMotionVector(float2 vMotion, bool bFastEncode = false)
            {
                #if UNITY_UV_STARTS_AT_TOP
                    vMotion.y = -vMotion.y;
                #endif

                if (!bFastEncode)
                    vMotion = sqrt(abs(vMotion)) * (vMotion.xy > 0.0f ? float2(1, 1) : float2(-1, -1));

                vMotion = vMotion * 0.5h + 127.f / 255.f;

                return vMotion.xy;
            }

            float2 OutputVelocityRT(float2 vCurrPos, float2 vPrevPos, float fAlpha = 1.0f)
            {
                float2 vVelocity = (vPrevPos - vCurrPos) * fAlpha;
                return float2(EncodeMotionVector(vVelocity));
            }

            // -------------------------------------
            // Fragment
            float4 frag(Varyings input) : SV_Target
            {
                UNITY_SETUP_INSTANCE_ID(input);
                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);

                //if (input.posModified == 0) return 0;

                //Note: unity_MotionVectorsParams.y is 0 is forceNoMotion is enabled
                bool forceNoMotion = unity_MotionVectorsParams.y == 0.0;
                if (forceNoMotion) return 0;
                
                // Calculate positions
                float2 currTCPos = input.positionCS.xy / _ScreenSize.xy;
                float2 ScreenTCPrev = (input.HPosPrev.xy / input.HPosPrev.z);
                
                float2 uv = input.uv;
                float4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv);  

                return texColor;
            }
            ENDHLSL
        }
    }
}

using System;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;
using UnityEngine.Experimental.Rendering;
using System.Collections.Generic;

namespace Sources.CustomRenderer.Features
{
    public class MotionVectorRenderPass : ScriptableRenderPass
    {
        const string kObjectShader = "Hidden/CustomRenderer/VelocityObjects";

        private static readonly int m_velocityTexId = Shader.PropertyToID("_VelocityTexture");

        private List<ShaderTagId> s_ShaderTags;

        Material m_ObjectMaterial;
        MotionData m_MotionData;

        private RenderTargetIdentifier m_velocityTextureTarget = new RenderTargetIdentifier(m_velocityTexId, 0, CubemapFace.Unknown, -1);
        private RenderTextureDescriptor m_velocityTextureDescriptor;

        public MotionVectorRenderPass()
        {
            // Set data
            renderPassEvent = RenderPassEvent.AfterRenderingGbuffer;
        }

        public void Setup(MotionData motionData)
        {
            if (s_ShaderTags == null)
            {
                s_ShaderTags = new List<ShaderTagId>()
                {
                    new ShaderTagId("LightweightForward"),
                    new ShaderTagId("SRPDefaultUnlit"), new ShaderTagId("UniversalForward"), new ShaderTagId("UniversalForwardOnly"),
                    new ShaderTagId("Unlit"), new ShaderTagId("ForwardLit")                   
                };
            }
            
            m_MotionData = motionData;
            m_ObjectMaterial = new Material(Shader.Find(kObjectShader));
        }

        public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
        {
            RenderTextureDescriptor cameraTargetDescriptor = renderingData.cameraData.cameraTargetDescriptor;
            RenderTextureDescriptor descriptor = cameraTargetDescriptor;
            descriptor.depthBufferBits = 32;
            m_velocityTextureDescriptor = descriptor;
            m_velocityTextureDescriptor.graphicsFormat = GraphicsFormat.R16G16B16A16_SFloat;


            cmd.GetTemporaryRT(m_velocityTexId, m_velocityTextureDescriptor, FilterMode.Point);
            ConfigureTarget(m_velocityTextureTarget);
            ConfigureClear(ClearFlag.All, Color.black);
        }

        public override void OnCameraCleanup(CommandBuffer cmd)
        {
            if (cmd == null)
                throw new ArgumentNullException("cmd");
            cmd.ReleaseTemporaryRT(m_velocityTexId);
        }

        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            var camera = renderingData.cameraData.camera;
            CommandBuffer cmd = CommandBufferPool.Get();

            using (new ProfilingScope(cmd, new ProfilingSampler("VelocityVector")))
            {
                camera.depthTextureMode |= DepthTextureMode.MotionVectors | DepthTextureMode.Depth;

                var drawingSettings = GetDrawingSettings(ref renderingData);
                var filteringSettings = new FilteringSettings(RenderQueueRange.all, camera.cullingMask);
                var renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);

                //var cullingResults = context.Cull(ref cullingParameters);
                context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings, ref renderStateBlock);

            }
            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }

        DrawingSettings GetDrawingSettings(ref RenderingData renderingData)
        {
            // Drawing Settings
            var camera = renderingData.cameraData.camera;
            var sortingSettings = new SortingSettings(camera) { criteria = SortingCriteria.CommonOpaque };
            var drawingSettings = new DrawingSettings(ShaderTagId.none, sortingSettings)
            {
                perObjectData = PerObjectData.MotionVectors,
                enableDynamicBatching = renderingData.supportsDynamicBatching,
                enableInstancing = true,
            };

            // Shader Tags
            for (int i = 0; i < s_ShaderTags.Count; ++i)
            {
                drawingSettings.SetShaderPassName(i, s_ShaderTags[i]);
            }

            // Material
            drawingSettings.overrideMaterial = m_ObjectMaterial;
            drawingSettings.overrideMaterialPassIndex = 0;
            return drawingSettings;
        }
    }
}