This technique relies on knowing where the seams between meshes are, so we need a system to be able to detect this.
We could rely on g-buffer info such as checking if the normals of the surface changes but that would also smooth intended seams on meshes themselves.
The technique I used is generating a ID for every object, there are a lot of ways to do this since i am implementing this in Unity the simplest way is adding a render pass.

For this pass I set every objects shader to a shader that hashes its position into the color as an id then draw that pass to a render texture

# ObjectIDShader
# HLSL:

float Hash(float3 p)

            {

                p = frac(p * 0.3183099 + 0.1);

                p *= 17.0;

                return frac(p.x * p.y * p.z * (p.x + p.y + p.z));

            }

            half4 frag(Varyings input) : SV_Target

            {

  float3 normal = normalize(input.normalWS);

                float3 objectPosition = unity_ObjectToWorld._m03_m13_m23;

                float hashValue = Hash(objectPosition);

                return half4(hashValue, 0, 0, 1);

            }

#

If you draw this to a screen This should get you something like this:

Now that we have a id per object detecting seams is pretty straight forward.
In a post process shader we run a kernel that detects if the id changes
A kernel is a shader that loop over every pixel on the screen and then loops over their neighbors

# SeamDetectionPostProcess
# HLSL:

int _KernelSize;

float _KernelRadius;

        half4 Frag(Varyings input) : SV_Target

            {

float2 UV = float2(input.uv.x, 1-input.uv.y); // In my case i had to flip the uv

// Depth and color of the current pixel

float4 sceneColor = SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, UV);

float sceneDepth = Linear01Depth(SAMPLE_TEXTURE2D(_ObjectDepthTexture, sampler_ObjectDepthTexture, UV), _ZBufferParams);
// The ID we set in the first pass

float4 objectIDColor = SAMPLE_TEXTURE2D(_ObjectIDTexture, sampler_ObjectIDTexture, UV);

float4 color = sceneColor;

//Kernel, loop over all the pixels in a radius

for(int x = -_KernelSize; x < _KernelSize; x++) {

for(int y = -_KernelSize; y < _KernelSize; y++) {
// Divide by scenedepth to keep sample size consistent over distance

float2 offset = float2(x,y)*_KernelRadius/sceneDepth/_KernelSize;

float2 SampleUV = UV + offset; // UV location of the pixel being tested

 // Test the id of the offset pixel against the middle pixel

float4 id = SAMPLE_TEXTURE2D(_ObjectIDTexture, sampler_ObjectIDTexture, SampleUV);

if (id.x != objectIDColor.x) {

color = float4(1,0,0,1); // Set the color to red if there is a seam

}

}

}

return color;

            }

#

With this you should basically have a outline shader:

There is one simple problem with our transitions.
They are happening even if the objects arent next to eachother so the top of the rocks are also transitioned.
We can fix this by adding a simple check for depth to our weight

# SeamBlendPostProcess
# HLSL:

      int _KernelSize;
float _KernelRadius;
float _DepthFalloff;

    half4 Frag(Varyings input) : SV_Target

    {
                  ...

Kernel

...

// Get the pixel on the other side of the seam

    float4 otherColor = SAMPLE_TEXTURE2D(_CameraOpaqueTexture, sampler_CameraOpaqueTexture, UV + seamLocation * 2 );

     float4 otherDepth = Linear01Depth(SAMPLE_TEXTURE2D(_ObjectDepthTexture, sampler_ObjectDepthTexture, 

UV + seamLocation * 2 ), _ZBufferParams);

float depthDiff = abs(otherDepth-sceneDepth);

        // This is the maximum distance where our kernel can find a seam

float maxSearchDistance = (KernelRadius)/sceneDepth; 

 // We subtract 0.5 to make the transition line up on the seam

float spatialWeight = saturate(0.5 - sqrt(minimumDistance ) / maxSearchDistance);

float depthWeight = saturate(1.0 - depthDiff / _DepthFalloff*_KernelRadius);

 float totalWeight

    return lerp(sceneColor, otherColor, totalWeight);

     }

#

This creates our final effect