import the woofer

assets/shaders/clean4x.gdshader

@@ -0,0 +1,146 @@
+shader_type canvas_item;
+
+//the color with the highest priority.
+// other colors will be tested based on distance to this
+// color to determine which colors take priority for overlaps.
+uniform vec3 highestColor = vec3(1.,1.,1.);
+
+//how close two colors should be to be considered "similar".
+// can group shapes of visually similar colors, but creates
+// some artifacting and should be kept as low as possible.
+uniform float similarThreshold = 0.0;
+
+const float scale = 4.0;
+const mat3 yuv_matrix = mat3(vec3(0.299, 0.587, 0.114), vec3(-0.169, -0.331, 0.5), vec3(0.5, -0.419, -0.081));
+
+vec3 yuv(vec3 col){
+    mat3 yuv = transpose(yuv_matrix);
+    return yuv * col;
+}
+
+bool similar(vec4 col1, vec4 col2){
+    return (col1.a == 0. && col2.a == 0.) || distance(col1, col2) <= similarThreshold;
+}
+
+//multiple versions because godot doesn't support function overloading
+//note: inner check should ideally check between all permutations
+//  but this is good enough, and faster
+bool similar3(vec4 col1, vec4 col2, vec4 col3){
+    return similar(col1, col2) && similar(col2, col3);
+}
+
+bool similar4(vec4 col1, vec4 col2, vec4 col3, vec4 col4){
+    return similar(col1, col2) && similar(col2, col3) && similar(col3, col4);
+}
+
+bool similar5(vec4 col1, vec4 col2, vec4 col3, vec4 col4, vec4 col5){
+    return similar(col1, col2) && similar(col2, col3) && similar(col3, col4) && similar(col4, col5);
+}
+
+bool higher(vec4 thisCol, vec4 otherCol){
+    if(similar(thisCol, otherCol)) return false;
+    if(thisCol.a == otherCol.a){
+//      return yuv(thisCol.rgb).x > yuv(otherCol.rgb).x;
+//      return distance(yuv(thisCol.rgb), yuv(highestColor)) < distance(yuv(otherCol.rgb), yuv(highestColor));
+        return distance(thisCol.rgb, highestColor) < distance(otherCol.rgb, highestColor);
+    } else {
+        return thisCol.a > otherCol.a;
+    }
+}
+
+void fragment() {
+    vec2 size = 1.0/TEXTURE_PIXEL_SIZE+0.00001; //???
+    vec2 px = UV*size;
+    vec2 local = floor(mod(px,1.0)*scale);
+    vec2 localDiff = (local/1.0) - vec2(1.5, 1.5);
+    vec2 edge = floor(local/(scale/2.0))*(scale/2.0) - vec2(1.0, 1.0);
+    px = ceil(px);
+    
+    vec4 baseCol = texture(TEXTURE, px/size);
+
+    vec4 col = baseCol;
+    
+    vec4 c = baseCol;
+    
+    
+//  vec4 c = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+edge/4.0))/size);
+    vec2 ot = vec2(edge.x, edge.y * 4.0);
+    vec4 t = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+ot/4.0))/size);
+    vec2 otl = vec2(edge.x * 4.0, edge.y * 4.0);
+    vec4 tl = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+otl/4.0))/size);
+    vec2 otr = vec2(-edge.x * 4.0, edge.y * 4.0);
+    vec4 tr = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+otr/4.0))/size);
+    vec2 ol = vec2(edge.x * 4.0, edge.y);
+    vec4 l = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+ol/4.0))/size);
+    vec2 ob = vec2(edge.x, -edge.y * 4.0);
+    vec4 b = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+ob/4.0))/size);
+    vec2 obl = vec2(edge.x * 4.0, -edge.y * 4.0);
+    vec4 bl = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+obl/4.0))/size);
+    vec2 obr = vec2(-edge.x * 4.0, -edge.y * 4.0);
+    vec4 br = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+obr/4.0))/size);
+    vec2 or = vec2(-edge.x * 4.0, edge.y);
+    vec4 r = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+or/4.0))/size);
+    
+    vec2 os = vec2(localDiff.x, localDiff.y);
+    vec4 s = texture(TEXTURE, floor(px+(vec2(0.5,0.5)+os/2.0))/size);
+    
+    
+    //checkerboard special case
+    if(similar5(c, tl, tr, bl, br) && similar4(t, r, b, l) && higher(t, c)){
+//      if(local == vec2(0.,0.)){
+//          col = l;
+//      } else if(local == vec2(3.,0.)){
+//          col = r;
+//      } else if(local == vec2(0.,3.)){
+//          col = l;
+//      } else if(local == vec2(3.,3.)){
+//          col = r;
+//      }
+    } else {
+        //corner
+        if(length(localDiff) > 2.1){
+            if(similar(t, l) && !(similar(tl, c) && !higher(t, c))){
+                col = t;
+            } else if(higher(c, l) && higher(c, t) && (similar(tr, c) || similar(bl, c)) && !similar(tl, c)){
+                if(higher(t, l)){
+                    col = t;
+                } else {
+                    col = l;
+                }
+            }
+        //edge
+        } else if(length(localDiff) > 1.58) {
+            
+            if(similar(t, l)){
+                if(higher(s, c)){
+                    col = s;
+                }
+            }
+            
+            if(similar3(r, s, tl) && similar3(br, c, l) && higher(s, c)/* && !similar(b, t)*/){
+                col = t;
+            }
+            if(!similar(tl, c) && similar3(r, c, bl) && similar3(tr, t, l) && higher(c, l)){
+                col = s;
+            }
+            if(!similar(tr, c) && similar3(l, c, br) && similar3(tl, s, r) && higher(c, r)){
+                col = s;
+            }
+            
+            if(similar3(b, s, tl) && similar3(br, c, t) && higher(b, c)/* && !similar(r, l)*/){
+                col = s;
+            }
+            if(!similar(tl, c) && similar3(tr, c, b) && similar3(t, l, bl) && higher(c, l)){
+                col = s;
+            }
+            if(!similar(bl, c) && similar3(br, c, t) && similar3(b, s, tl) && higher(c, s)){
+                col = s;
+            }
+        }
+    }
+    //set alpha back to full, for manually adjusted pixels 
+    if(col.a > 0.00001){
+        col.a = 1.0;
+    }
+    COLOR = col;
+}