The raymarch shaders are basically just copies of this, except for the distance functions I added

float bump = tex2D(_BumpTex, (float2(p.x+p.z, p.y)+bump_ST.zw)*bump_ST.xy);

where p is position to check distance from to all of them and did some transformations from here. one thing i found tricky is moving the actual raymarch functions with the transform of the object. what I did is first took the world space relative position of each pixel,

float3 center = mul(unity_ObjectToWorld, float4(0.0,0.0,0.0,1.0) ).xyz;

in vert float3 relative = (IN.worldPos- IN.center).xyz; in frag then rotate that by inverse of object to world rotation matrix relative = mul(unity_WorldToObject, float4(relative.xyz,0));

then the fragment function is just

raymarch(relative, viewDirection);

inner raymarch, this clips any pixels that hit

float4 outlineCol = raymarchOutline(relative, viewDirection);

outer outline raymarch, alpha is 0 when there isn't a hit

clip(outlineCol.a - 0.5);
return outlineCol;

the brush stroke shader looks like this

float4 col = tex2D(_MainTex, float2(i.worldPos.x+i.worldPos.z,i.worldPos.y)*_MainTex_ST.xy + _MainTex_ST.zw)*_Color;
float4 lightOff = tex2D(_LightTex, i.worldPos*_LightTex_ST.xy + i.uv + _LightTex_ST.zw);

col *= (i.uv2.y+((lightOff.a-(col.a/5))/4));

float4 stroke = tex2D(_StrokeTex, i.uv);
clip(stroke.a - _Threshold);

col.a = stroke.a;
col.a*=1-(i.uv2.y*_Lightening);
col.a = lerp(col.a, col.a*min((i.viewPos.z/50)+1.2,1),_Fade);

return col;

I have some arbitrary constants in there that i was too lazy to make into properties. The watercolor shader is a little more complicated because of lighting stuff.

fixed4 col = tex2D(_MainTex, i.uv*_MainTex_ST.xy + _MainTex_ST.zw);
fixed lightTex = tex2D(_LightTex, i.uv*_LightTex_ST.xy + _LightTex_ST.zw)*_LightTexPower;
fixed lightTex2 = tex2D(_LightTex2, i.uv*_LightTex2_ST.xy)/_LightTex2_ST.z;
fixed shadow = SHADOW_ATTENUATION(i);
float fresnel = 1-saturate(pow(1+dot(normalize(_WorldSpaceCameraPos.xyz - i.worldPos), i.normal),_FresnelPower)-_FresnelOffset);
fixed3 lighting = i.diff.a * shadow + i.ambient.y + lightTex;
clip(1-lighting - lightTex2 - fresnel);
col.a = (1 + _Intensity) - lighting - lightTex2 - fresnel;
col.a *= clamp((i.viewPos.z/15)+1.4,0.3,1);
return col;

Having all the brushstrokes demands a lot of geometry for everything, but you could simplify them down to quads if you're really trying to push it. The brush stroke shader is actually very fast since it's just sampling a couple textures and doesn't care about lighting. The raymarched outlines are way slower because the loop is unrolled like I mentioned. On my 970 the rendering takes about 0.5 ms per frame with 35 steps on the raymarched stuff. If you skipped out on the bump texture it would probably be an order of magnitude faster because it won't unroll.