Use a 2-pass depth based outline algorithm when selected

resources/shaders/140/gouraud.fs

@@ -36,6 +36,8 @@ uniform SlopeDetection slope;
 
 //BBS: add outline_color
 uniform bool is_outline;
+uniform sampler2D depth_tex;
+uniform vec2 screen_size;
 
 #ifdef ENABLE_ENVIRONMENT_MAP
     uniform sampler2D environment_tex;
@@ -44,6 +46,9 @@ uniform bool is_outline;
 
 uniform PrintVolumeDetection print_volume;
 
+uniform float z_far;
+uniform float z_near;
+
 in vec3 clipping_planes_dots;
 in float color_clip_plane_dot;
 
@@ -54,6 +59,71 @@ in vec4 world_pos;
 in float world_normal_z;
 in vec3 eye_normal;
 
+vec3 getBackfaceColor(vec3 fill) {
+    float brightness = 0.2126 * fill.r + 0.7152 * fill.g + 0.0722 * fill.b;
+    return (brightness > 0.75) ? vec3(0.11, 0.165, 0.208) : vec3(0.988, 0.988, 0.988);
+}
+
+// Silhouette edge detection & rendering algorithem by leoneruggiero
+// https://www.shadertoy.com/view/DslXz2
+#define INFLATE 1
+
+float GetTolerance(float d, float k)
+{
+    // -------------------------------------------
+    // Find a tolerance for depth that is constant
+    // in view space (k in view space).
+    //
+    // tol = k*ddx(ZtoDepth(z))
+    // -------------------------------------------
+    
+    float A=-   (z_far+z_near)/(z_far-z_near);
+    float B=-2.0*z_far*z_near /(z_far-z_near);
+    
+    d = d*2.0-1.0;
+    
+    return -k*(d+A)*(d+A)/B;   
+}
+
+float DetectSilho(ivec2 fragCoord, ivec2 dir)
+{
+    // -------------------------------------------
+    //   x0 ___ x1----o 
+    //          :\    : 
+    //       r0 : \   : r1
+    //          :  \  : 
+    //          o---x2 ___ x3
+    //
+    // r0 and r1 are the differences between actual
+    // and expected (as if x0..3 where on the same
+    // plane) depth values.
+    // -------------------------------------------
+    
+    float x0 = abs(texelFetch(depth_tex, (fragCoord + dir*-2), 0).r);
+    float x1 = abs(texelFetch(depth_tex, (fragCoord + dir*-1), 0).r);
+    float x2 = abs(texelFetch(depth_tex, (fragCoord + dir* 0), 0).r);
+    float x3 = abs(texelFetch(depth_tex, (fragCoord + dir* 1), 0).r);
+    
+    float d0 = (x1-x0);
+    float d1 = (x2-x3);
+    
+    float r0 = x1 + d0 - x2;
+    float r1 = x2 + d1 - x1;
+    
+    float tol = GetTolerance(x2, 0.04);
+    
+    return smoothstep(0.0, tol*tol, max( - r0*r1, 0.0));
+
+}
+
+float DetectSilho(ivec2 fragCoord)
+{
+    return max(
+        DetectSilho(fragCoord, ivec2(1,0)), // Horizontal
+        DetectSilho(fragCoord, ivec2(0,1))  // Vertical
+        );
+}
+
 out vec4 out_color;
 
 void main()
@@ -96,10 +166,20 @@ void main()
 		pv_check_max = vec3(0.0, 0.0, world_pos.z - print_volume.z_data.y);
 	}
 	color.rgb = (any(lessThan(pv_check_min, ZERO)) || any(greaterThan(pv_check_max, ZERO))) ? mix(color.rgb, ZERO, 0.3333) : color.rgb;
-	
+
     //BBS: add outline_color
-    if (is_outline)
-        out_color = uniform_color;
+    if (is_outline) {
+        color = vec4(vec3(intensity.y) + color.rgb * intensity.x, color.a);
+        ivec2 fragCoord = ivec2(gl_FragCoord.xy);
+        float s = DetectSilho(fragCoord);
+        // Makes silhouettes thicker.
+        for(int i=1;i<=INFLATE; i++)
+        {
+           s = max(s, DetectSilho(fragCoord.xy + ivec2(i, 0)));
+           s = max(s, DetectSilho(fragCoord.xy + ivec2(0, i)));
+        }   
+        out_color = vec4(mix(color.rgb, getBackfaceColor(color.rgb), s), color.a);
+    }
 #ifdef ENABLE_ENVIRONMENT_MAP
     else if (use_environment_tex)
         out_color = vec4(0.45 * texture(environment_tex, normalize(eye_normal).xy * 0.5 + 0.5).xyz + 0.8 * color.rgb * intensity.x, color.a);