Make clouds use specific upscale filter, break cloud render over walls

shader/upscale/cloud.frag

@@ -0,0 +1,106 @@
+#version 450 core
+in vec2 vTexPos;
+out vec4 fColor;
+layout (location = 0) uniform vec2 screensize;
+layout(binding = 0) uniform sampler2D screenTexture;
+vec3 f (float x, float y)
+//{ return texture(screenTexture, vTexPos + vec2((x+0.5)/screensize.x,(y+0.5)/screensize.y)).xyz; 
+{ return texture(screenTexture, vTexPos + vec2(x/screensize.x,y/screensize.y)).xyz; 
+}
+bool t (vec3 x, vec3 y)
+{ return dot(x-y,x-y) < 0.005;
+}
+bool t3 (vec3 x, vec3 y, vec3 z)
+{ return t(x,y) && t(y,z);
+}
+vec3 c = f(0,0);
+bool bt (vec3 x, vec3 y)
+{ return x.x+x.y+x.z > y.x+y.y+y.z;}
+bool t4 (vec3 x, vec3 y, vec3 z)
+{ return t(x,z) && (t(x,y) || bt(x,c)) ; }
+bool incenter (int x) { return x > 0 && x < 3; }
+int three = int(( floor(vTexPos.y * screensize.y))) % 3;
+int i = int(( floor(vTexPos.x * screensize.x))) % 4;
+int j = int(( floor(vTexPos.y * screensize.y))) % 4;
+vec4 edgecase (vec3 e1, vec3 e2)
+{ return vec4((t(e1,e2) && bt(e1,c) ? e1 : c),1); }
+vec4 ttlcase (vec3 tt, vec3 tr, vec3 mr, vec3 br, vec3 bb, vec3 bl, vec3 ml, vec3 tl)
+{ 
+    if (t(tl,tt) && t(tl,mr))
+        {return vec4(tl,1);}
+    if (t(tl,tt) && t(tl,ml))
+        {return vec4(tt,1);}
+//    if (t(tt,mr) && bt(tt,c))
+//        {return vec4(tt,1);}
+    return vec4(c,1);
+}
+vec4 corncase (vec3 e1, vec3 e2, vec3 corn)
+{ return vec4( (t(e1,e2) && false == (t(corn,c)) ? e1 : c) , 1);}
+//{ return vec4( (t(e1,e2) ? e1 : c) , 1);}
+void main() 
+{
+vec3 tl = f(-4, 4);
+vec3 tt = f( 0, 4);
+vec3 tr = f( 4, 4);
+vec3 mr = f( 4, 0);
+vec3 br = f( 4,-4);
+vec3 bb = f( 0,-4);
+vec3 bl = f(-4,-4);
+vec3 ml = f(-4, 0);
+vec3 tlc = f(-1, 1);
+vec3 trc = f( 1, 1);
+vec3 brc = f( 1,-1);
+vec3 blc = f(-1,-1);
+//    if (t4(tl,tr,br))
+//        { fColor = vec4(tl,1);}
+//    else if (t4(tr,br,bl))
+//        { fColor = vec4(tr,1);}
+//    else if (t4(br,bl,tl))
+//        { fColor = vec4(br,1);}
+//    else if (t4(bl,tl,tr))
+//        { fColor = vec4(bl,1);}
+if (incenter(i) && incenter(j))
+    {fColor = vec4(c,1); }
+else
+    { fColor = vec4(0,0,0,1);
+      switch (i * 10 + j) {
+        case 10:
+            fColor = ttlcase(bb,br,mr,tr,tt,tl,ml,bl);
+            break;
+        case 01:
+            fColor = ttlcase(ml,tl,tt,tr,mr,br,bb,bl);
+            break;
+        case 13:
+            fColor = ttlcase(tt,tr,mr,br,bb,bl,ml,tl);
+            break;
+        case 02:
+            fColor = ttlcase(ml,bl,bb,br,mr,tr,tt,tl);
+            break;
+        case 23:
+            fColor = ttlcase(tt,tl,ml,bl,bb,br,mr,tr);
+            break;
+        case 32:
+            fColor = ttlcase(mr,br,bb,bl,ml,tl,tt,tr);
+            break;
+        case 20:
+            fColor = ttlcase(bb,bl,ml,tl,tt,tr,mr,br);
+            break;
+        case 31:
+            fColor = ttlcase(mr,tr,tt,tl,ml,bl,bb,br);
+            break;
+        case 00:
+            fColor = corncase(ml,bb,bl);
+            break;
+        case 03:
+            fColor = corncase(ml,tt,tl);
+            break;
+        case 33:
+            fColor = corncase(mr,tt,tr);
+            break;
+        case 30:
+            fColor = corncase(mr,bb,br);
+            break;
+                          }
+    }
+    fColor.a = texture(screenTexture, vTexPos).a; 
+}

shader/upscale/cloud.vert

@@ -0,0 +1,7 @@
+#version 450 core
+layout (std140, binding = 2) uniform PosTex { vec4 posTex[3]; };
+out vec2 vTexPos;
+void main() {
+  gl_Position = vec4(posTex[gl_VertexID].xy,0,1);
+  vTexPos = posTex[gl_VertexID].zw ;
+}