Question RayTracingShader-TraceRay() not getting RayPayload back right

I'm trying to use ray tracing shader to bake rt datas to mesh uvs. I generate rays from mesh verts, and set the normal as ray direction. The rays hit the mesh renderer but didn't pass back the RayPayload data. I did use RaytracingShader.SetShaderPass() and set the shader pass name same, but it just don't work.
here are the result:
the mesh uv2 before baking

the mesh uv2 after baking. The verts that generate rays that can hit the mesh itself should be white as I wrote in my shader, but they remain black as I initialized in my raytracingshader.

Here is my baker script:

Code (CSharp):

1.  
2.     public RayTracingShader rtShader;
3.     public MeshFilter meshFilter;
4.     public Renderer _renderer;
5.     Mesh mesh;
6.  
7.     void Start()
8.     {
9.         rtShader.SetShaderPass("RayTracing");
10.  
11.         RayTracingAccelerationStructure accStruct = new RayTracingAccelerationStructure();
12.         bool[] subMeshMask = {};
13.         bool[] subMeshTransparencyFlags = {false};
14.         accStruct.AddInstance(_renderer,subMeshMask,subMeshTransparencyFlags,false,false,0xff);
15.         accStruct.Build();
16.         rtShader.SetAccelerationStructure("_AccelerationStructure", accStruct);
17.  
18.         int patchCount = 100;
19.         rtShader.SetFloat("_PatchCount", patchCount);
20.         mesh = meshFilter.mesh;
21.  
22.         List<Vector3> vertices = new List<Vector3>(patchCount * patchCount);
23.         mesh.GetVertices(vertices);
24.         ComputeBuffer vertexBuffer = new ComputeBuffer(patchCount * patchCount, sizeof(float) * 3);
25.         vertexBuffer.SetData(vertices);
26.         rtShader.SetBuffer("Vertices", vertexBuffer);
27.  
28.         List<Vector3> normals = new List<Vector3>(patchCount * patchCount);
29.         mesh.GetNormals(normals);
30.         ComputeBuffer normalBuffer = new ComputeBuffer(patchCount * patchCount, sizeof(float) * 3);
31.         normalBuffer.SetData(normals);
32.         rtShader.SetBuffer("Normals", normalBuffer);
33.  
34.         ComputeBuffer outBuffer = new ComputeBuffer(patchCount * patchCount, sizeof(float) * 4);
35.         rtShader.SetBuffer("Out", outBuffer);
36.  
37.         rtShader.Dispatch("MyRaygenShader", patchCount, patchCount, 1);
38.  
39.         Vector4[] outVerts = new Vector4[patchCount * patchCount];
40.         outBuffer.GetData(outVerts);
41.        
42.         vertexBuffer.Release();
43.         normalBuffer.Release();
44.         outBuffer.Release();
45.         accStruct.Release();
46.  
47.         int vertexCount = mesh.vertexCount;
48.         mesh.SetUVs(1, outVerts, 0, vertexCount);
49.         meshFilter.mesh = mesh;
50.  
51.     }

and here is my RayTracingShader:

Code (CSharp):

1. RWStructuredBuffer<float3> Vertices;
2. RWStructuredBuffer<float3> Normals;
3.  
4.  
5. RWStructuredBuffer<float4> Out;
6.  
7. struct RayPayload
8. {
9.   float4 color;
10. };
11.  
12. #pragma max_recursion_depth 1
13.  
14. RaytracingAccelerationStructure _AccelerationStructure;
15. float _RayFarDistance;
16. float _PatchCount;
17. [shader("raygeneration")]
18. void MyRaygenShader()
19. {
20.     const uint2 dispatchIdx = DispatchRaysIndex().xy;
21.     uint idx = dispatchIdx.x * _PatchCount + dispatchIdx.y;
22.  
23.     RayDesc rayDescriptor;
24.     rayDescriptor.Origin = Vertices[idx];
25.     rayDescriptor.Direction = Normals[idx];
26.     rayDescriptor.TMin = 1e-5f;
27.     rayDescriptor.TMax = 100;
28.  
29.     RayPayload rayHit;
30.     rayHit.color = float4(0, 0, 0, 0);
31.  
32.     TraceRay(_AccelerationStructure, RAY_FLAG_NONE, 0xFF, 0, 1, 0, rayDescriptor, rayHit);
33.  
34.     Out[idx] = rayHit.color;
35. }
36.  
37. [shader("miss")]
38. void MissShader(inout RayPayload rayHit : SV_RayPayload)
39. {
40.   rayHit.color = float4(1,0,0,0);
41. }

and here is my shader:

Code (CSharp):

1.  
2.     SubShader
3.     {
4.         Tags { "RenderType"="Opaque" }
5.         LOD 100
6.  
7.         Pass
8.         {
9.             CGPROGRAM
10.             #pragma vertex vert
11.             #pragma fragment frag
12.  
13.             #include "UnityCG.cginc"
14.  
15.             struct appdata
16.             {
17.                 float4 vertex : POSITION;
18.                 float2 uv : TEXCOORD0;
19.                 float4 uv2 : TEXCOORD1;
20.             };
21.  
22.             struct v2f
23.             {
24.                 float2 uv : TEXCOORD0;
25.                 float4 uv2 : TEXCOORD1;
26.                 float4 vertex : SV_POSITION;
27.             };
28.  
29.             sampler2D _MainTex;
30.             float4 _MainTex_ST;
31.  
32.             v2f vert (appdata v)
33.             {
34.                 v2f o;
35.                 o.vertex = UnityObjectToClipPos(v.vertex);
36.                 o.uv = v.uv;
37.                 o.uv2 = v.uv2;
38.                 return o;
39.             }
40.  
41.             fixed4 frag (v2f i) : SV_Target
42.             {
43.                 fixed4 col = i.uv2;
44.                 return col;
45.             }
46.             ENDCG
47.         }
48.     }
49.  
50.     SubShader
51.     {
52.         Pass
53.         {
54.             Name "RayTracing"
55.             Tags { "LightMode" = "RayTracing" }
56.  
57.             HLSLPROGRAM
58.  
59.             #pragma raytracing test
60.  
61.             struct RayPayload
62.             {
63.               float4 color;
64.             };
65.  
66.             struct AttributeData
67.             {
68.               float2 barycentrics;
69.             };
70.  
71.  
72.             [shader("closesthit")]
73.             void ClosestHitShader(inout RayPayload rayHit : SV_RayPayload, AttributeData attributeData : SV_IntersectionAttributes)
74.             {
75.               rayHit.color = float4(1,1,1,1);
76.             }
77.  
78.             ENDHLSL
79.         }
80.     }