Draw onto an object's texture based on a raycast hit position in world space

There are two approaches to this problem - either you pass in the texture coordinate and try to convert it to world space inside the shader, or you pass in a world position and compare it to the fragment world position. The latter is no doubt the easiest.

So, let's say that you pass in the world position into the shader like so:

drawMaterial.SetVector("_Coordinate", new Vector4(hit.point.x, hit.point.y, hit.point.z, 0));

Calculating a world position per fragment is expensive, so we do it inside the vertex shader and let the hardware interpolate the value per fragment. Let's add a world position to our v2f struct:

struct v2f
{
    float2 uv : TEXCOORD0;
    float4 vertex : SV_POSITION;
    float3 worldPos : TEXCOORD1;
};

To calculate the world position inside the vertex shader, we can use the built-in matrix unity_ObjectToWorld:

v2f vert (appdata v)
{
    v2f o;
    o.vertex = UnityObjectToClipPos(v.vertex);
    o.uv = TRANSFORM_TEX(v.uv, _MainTex);
    o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
    return o;
 }

Finally, we can access the value in the fragment shader like so:

float draw =pow(saturate(1-distance(i.worldPos,_Coordinate.xyz)),100);

EDIT: I just realized - when you do a blit pass, you are not rendering with your mesh, you are rendering to a quad which covers the whole screen. Because of this, when you calculate the distance to the vertex, you get the distance to the screen corners, which is not right. There is a way to solve this though - you can change the render target to your render texture and draw the mesh using a shader which projects the mesh UVs across the screen.

It's a bit hard to explain, but basically, the way vertex shaders work is that you take in a vertex which is in local object space and transform it to be relative to the screen in the space -1 to 1 on both axes, where 0 is in the center. This is called Normalized Device Coordinate Space, or NDC space. We can leverage this to make it so that instead of using the model and camera matrices to transform our vertices, we use the UV coordinates, converted from [0,1] space to [-1,1]. At the same time, we can calculate our world position and pass it onto the fragment separately. Here is how the shader would look:

v2f vert (appdata v)
{
    v2f o;

    float2 uv = v.texcoord.xy;

    // https://docs.unity3d.com/Manual/SL-PlatformDifferences.html

    if (_ProjectionParams.x < 0) {
        uv.y = 1 - uv.y;
    }

    // Convert from 0,1 to -1,1, for the blit
    o.vertex = float4(2 * (uv - 0.5), 0, 1);

    // We still need UVs to draw the base texture
    o.uv = TRANSFORM_TEX(v.uv, _MainTex);

    // Let's do the calculations in local space instead!
    o.localPos = v.vertex.xyz;

    return o;
 }

Also remember to pass in the _Coordinate variable in local space, using transform.InverseTransformPoint.

Now, we need to use a different approach to render this into the render texture. Basically, we need to render the actual mesh as if we were rendering from a camera - except that this mesh will be drawn as a splayed out UV sheet across the screen. First, we set the active render texture to the texture we want to draw into:

// Cache the old target so that we can reset it later
RenderTexture previousRT = RenderTexture.active;
RenderTexture.active = temp;

(You can read about how render targets work here) Next, we need to bind our material and draw the mesh.

Material mat = drawMaterial;
Mesh mesh = yourAwesomeMesh;
mat.SetTexture("_MainTex", splatMap);
mat.SetPass(0); // This tells the renderer to use pass 0 from this material
Graphics.DrawMeshNow(mesh, Vector3.zero, Quaternion.identity);

Finally, blit the texture back to the original:

// Remember to reset the render target
RenderTexture.active = previousRT;
Graphics.Blit(temp, splatMap);

I haven't tested or verified this, but i have used a similar technique to draw a mesh into UVs before. You can read more about DrawMeshNow here.