fix shaders format

data/shaders/atlas.glsl

@@ -1,21 +1,27 @@
 [[vertex]]
+
 uniform mat4 mvp;
 uniform vec2 tof;
 uniform vec2 tsz;
+
 in vec2 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
-   uv = tof + uvs * tsz;
+    uv = tof + uvs * tsz;
-   gl_Position = mvp * vec4(pos, 0.0, 1.0);
+    gl_Position = mvp * vec4(pos, 0.0, 1.0);
-};
+}
 
 [[fragment]]
+
 uniform sampler2D tex;
+
 in mediump vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
-   frag = texture(tex, uv);
+    frag = texture(tex, uv);
-};
+}

data/shaders/bake-uv.glsl

@@ -1,10 +1,13 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec3 nor;
 in vec2 uvs;
 out vec3 n;
 out vec3 p;
+
 void main()
 {
     n = nor;
@@ -13,10 +16,13 @@ void main()
 }
 
 [[fragment]]
+
 uniform int mode;
+
 in highp vec3 n;
 in highp vec3 p;
 out highp vec3 frag;
+
 void main()
 {
     switch(mode)

data/shaders/checkerboard.glsl

@@ -1,8 +1,11 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
     uv = uvs;
@@ -10,15 +13,20 @@ void main()
 }
 
 [[fragment]]
+
 uniform bool colorize;
+
 in mediump vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
     const mediump vec4 c1 = vec4(1.0, 1.0, 1.0, 1.0);
     const mediump vec4 c2 = vec4(0.9, 0.9, 0.9, 1.0);
     mediump vec2 c = floor(fract(uv * 10.0) * 2.0);
     mediump float alpha = mix(c.x, 1.0 - c.x, c.y);
-    if (colorize) frag = mix(c1, c2, alpha) * vec4(fract(uv.x * 5.0), uv.y, 1.0, 1.0);
+    if (colorize)
-    else frag = mix(c1, c2, alpha);
+        frag = mix(c1, c2, alpha) * vec4(fract(uv.x * 5.0), uv.y, 1.0, 1.0);
+    else 
+        frag = mix(c1, c2, alpha);
 }

data/shaders/color-hue.glsl

@@ -1,22 +1,28 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec3 uv;
+
 void main()
 {
-   gl_Position = mvp * pos;
+    gl_Position = mvp * pos;
-   uv = vec3(uvs, pos.w);
+    uv = vec3(uvs, pos.w);
-};
+}
 
 [[fragment]]
+
 #include "include/hsv.glsl"
+
 uniform mediump vec4 col;
 uniform bool dir; // 0:horizontal, 1:vertical
+
 in mediump vec3 uv;
 out mediump vec4 frag;
+
 void main()
 {
-   frag = vec4(hsv2rgb(vec3(dir?uv.y:uv.x, 1.0, 1.0)), 1.0);
+    frag = vec4(hsv2rgb(vec3(dir?uv.y:uv.x, 1.0, 1.0)), 1.0);
-};
+}
-

data/shaders/color-quad.glsl

@@ -1,20 +1,27 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec3 uv;
+
 void main()
 {
-   gl_Position = mvp * pos;
+    gl_Position = mvp * pos;
-   uv = vec3(uvs, pos.w);
+    uv = vec3(uvs, pos.w);
-};
+}
 
 [[fragment]]
+
 #include "include/hsv.glsl"
+
 uniform mediump vec4 col; // HSV
+
 in mediump vec3 uv;
 out mediump vec4 frag;
+
 void main()
 {
     frag = vec4(hsv2rgb(vec3(col.x, uv.x, 1.0 - uv.y)), 1.0);
-};
+}

data/shaders/color-tri.glsl

@@ -1,21 +1,28 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec3 uv;
+
 void main()
 {
-   gl_Position = mvp * pos;
+    gl_Position = mvp * pos;
-   uv = vec3(uvs, pos.w);
+    uv = vec3(uvs, pos.w);
-};
+}
 
 [[fragment]]
+
 #include "include/hsv.glsl"
+
 uniform mediump vec4 col; // in HSV
+
 in mediump vec3 uv;
 out mediump vec4 frag;
+
 void main()
 {
-   mediump float sat = tan(atan(uv.y, uv.x)) * 0.5 + 0.5;
+    mediump float sat = tan(atan(uv.y, uv.x)) * 0.5 + 0.5;
-   frag = vec4(hsv2rgb(vec3(col.r, sat, uv.x)), 1.0);
+    frag = vec4(hsv2rgb(vec3(col.r, sat, uv.x)), 1.0);
-};
+}

data/shaders/color.glsl

@@ -1,16 +1,22 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
+
 void main()
 {
-   gl_Position = mvp * pos;
+    gl_Position = mvp * pos;
-   gl_PointSize = 5.0;
+    gl_PointSize = 5.0;
-};
+}
 
 [[fragment]]
+
 uniform mediump vec4 col;
+
 out mediump vec4 frag;
+
 void main()
 {
-   frag = col;
+    frag = col;
-};
+}

data/shaders/comp-draw.glsl

@@ -1,15 +1,19 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
     uv = uvs;
     gl_Position = mvp * vec4(pos.xyz, 1.0);
-};
+}
 
 [[fragment]]
+
 #include "include/blur.glsl"
 #include "include/blend.glsl"
 #include "include/blend-stroke.glsl"
@@ -45,30 +49,38 @@ out mediump vec4 frag;
 
 void main()
 {
-   mediump vec4 base = texture(tex, uv);
+    mediump vec4 base = texture(tex, uv);
-   mediump vec4 stroke = texture(tex_stroke, uv);
+    mediump vec4 stroke = texture(tex_stroke, uv);
-   if (use_pattern)
+
-   {
+    if (use_pattern)
-       mediump vec2 rscale = resolution / vec2(512.0);
+    {
-       mediump float patt = texture(tex_pattern, uv * (0.5 / pattern_scale) * rscale + pattern_offset).r;
+        mediump vec2 rscale = resolution / vec2(512.0);
-       if (pattern_invert)
+        mediump float patt = texture(tex_pattern, uv * (0.5 / pattern_scale) * rscale + pattern_offset).r;
-           patt = 1.0 - patt;
+        if (pattern_invert)
-        //"       patt = patt * pattern_alpha + (1.0 - pattern_alpha);
+            patt = 1.0 - patt;
-       if (pattern_bright != 0.5)
+        //patt = patt * pattern_alpha + (1.0 - pattern_alpha);
-           patt = brightness1(patt, 1.0 - pattern_bright);
+        if (pattern_bright != 0.5)
-       if (pattern_contr != 0.5)
+            patt = brightness1(patt, 1.0 - pattern_bright);
-           patt = contrast1(patt, pattern_contr);
+        if (pattern_contr != 0.5)
-        //"       mediump float pa = (1.0 - patt) * pow(pattern_depth, 0.25) + (stroke.a * pattern_depth * 10.0);
+            patt = contrast1(patt, pattern_contr);
-       mediump float pa = pow((1.0 - patt), max(1.0, (1.0 - pattern_depth) * 10.0)) * pow(pattern_depth, 0.25) + (stroke.a * pattern_depth * 5.0);
+        //mediump float pa = (1.0 - patt) * pow(pattern_depth, 0.25) + (stroke.a * pattern_depth * 10.0);
-       stroke.a = mix(pa * stroke.a, stroke.a, 0.0);
+        mediump float pa = pow((1.0 - patt), max(1.0, (1.0 - pattern_depth) * 10.0)) * pow(pattern_depth, 0.25) + (stroke.a * pattern_depth * 5.0);
-   }
+        stroke.a = mix(pa * stroke.a, stroke.a, 0.0);
-   if (use_dual)
+    }
-   {
+
-       mediump vec4 dual = texture(tex_dual, uv);
+    if (use_dual)
-       stroke.a = blend_stroke(stroke.a, dual.a * dual_alpha, dual_blend_mode);
+    {
-   }
+        mediump vec4 dual = texture(tex_dual, uv);
-   stroke.a = mask ? stroke.a * stroke_alpha * blur(tex_mask, uv).r : stroke.a * stroke_alpha;
+        stroke.a = blend_stroke(stroke.a, dual.a * dual_alpha, dual_blend_mode);
-   if (!lock && base.a == 0.0) { frag = stroke * vec4(1.0, 1.0, 1.0, alpha); return; }
+    }
-   mediump vec4 blended = blend(base, stroke, blend_mode);
+
-   frag = vec4(blended.rgb, (lock ? base.a : blended.a) * alpha);
+    stroke.a = mask ? stroke.a * stroke_alpha * blur(tex_mask, uv).r : stroke.a * stroke_alpha;
-};
+    if (!lock && base.a == 0.0)
+    {
+        frag = stroke * vec4(1.0, 1.0, 1.0, alpha);
+        return;
+    }
+
+    mediump vec4 blended = blend(base, stroke, blend_mode);
+    frag = vec4(blended.rgb, (lock ? base.a : blended.a) * alpha);
+}

data/shaders/comp-erase.glsl

@@ -1,16 +1,21 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
     uv = uvs;
     gl_Position = mvp * vec4(pos.xyz, 1.0);
-};
+}
 
 [[fragment]]
+
 #include "include/blur.glsl"
+
 uniform sampler2D tex;
 uniform sampler2D tex_stroke;
 uniform sampler2D tex_mask;
@@ -18,12 +23,14 @@ uniform mediump float alpha;
 uniform mediump float stroke_alpha;
 uniform mediump vec2 resolution;
 uniform bool mask;
+
 in mediump vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
     mediump vec4 base = texture(tex, uv);
     mediump vec4 stroke = texture(tex_stroke, uv);
     stroke.a = mask ? stroke.a * stroke_alpha * blur(tex_mask, uv).r : stroke.a * stroke_alpha;
     frag = vec4(base.rgb, clamp((base.a - stroke.a) * alpha, 0.0, 1.0));
-};
+}

data/shaders/equirect.glsl

@@ -1,29 +1,36 @@
 [[vertex]]
+
 #define PI 3.1415926535897932384626433832795
 #define TWO_PI 6.283185307179586476925286766559
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
-   uv = (vec2(1.0) - uvs + vec2(0.25,0.0)) * vec2(TWO_PI, PI);
+    uv = (vec2(1.0) - uvs + vec2(0.25,0.0)) * vec2(TWO_PI, PI);
-   gl_Position = mvp * vec4(pos.xyz, 1.0);
+    gl_Position = mvp * vec4(pos.xyz, 1.0);
 }
 
 [[fragment]]
+
 uniform samplerCube tex;
+
 in highp vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
-   highp float anglex = uv.x;
+    highp float anglex = uv.x;
-   highp float angley = uv.y;
+    highp float angley = uv.y;
-   highp float sx = sin(anglex);
+    highp float sx = sin(anglex);
-   highp float cx = cos(anglex);
+    highp float cx = cos(anglex);
-   highp vec3 dir = vec3(0.0, 0.0, 0.0);
+    highp vec3 dir = vec3(0.0, 0.0, 0.0);
-   dir.x = sin(angley) * cx;
+    dir.x = sin(angley) * cx;
-   dir.y = cos(angley);
+    dir.y = cos(angley);
-   dir.z = sin(angley) * sx;
+    dir.z = sin(angley) * sx;
-   frag = texture(tex, dir);
+    frag = texture(tex, dir);
 }

data/shaders/font.glsl

@@ -1,22 +1,27 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec2 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
-   uv = uvs;
+    uv = uvs;
-   gl_Position = mvp * vec4(pos, 0.0, 1.0);
+    gl_Position = mvp * vec4(pos, 0.0, 1.0);
-};
+}
 
 [[fragment]]
+
 uniform mediump sampler2D tex;
 uniform mediump vec4 col;
+
 in mediump vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
-   mediump float a = texture(tex, uv).r;
+    mediump float a = texture(tex, uv).r;
-   frag = vec4(col.rgb, a);
+    frag = vec4(col.rgb, a);
-};
+}
-

data/shaders/include/blend.glsl

@@ -1,20 +1,76 @@
 mediump vec3 blend_normal(mediump vec4 base, mediump vec4 stroke, mediump float alpha_tot)
-{ return mix(base.rgb, stroke.rgb, stroke.a/alpha_tot); }
+{
-mediump vec3 blend_multiply(mediump vec4 base, mediump vec4 stroke, mediump float alpha_tot)
+    return mix(
-{ return mix(stroke.rgb, mix(base.rgb, base.rgb*stroke.rgb, stroke.a/alpha_tot), base.a/alpha_tot); }
+        base.rgb,
-mediump vec3 blend_screen(mediump vec4 base, mediump vec4 stroke, mediump float alpha_tot)
+        stroke.rgb,
-{ return mix(stroke.rgb, mix(base.rgb, 1.0-(1.0-base.rgb)*(1.0-stroke.rgb), stroke.a/alpha_tot), base.a/alpha_tot); }
+        stroke.a/alpha_tot
-mediump vec3 blend_colorDodge(mediump vec4 base, mediump vec4 stroke, mediump float alpha_tot)
+    );
-{ return mix(stroke.rgb, mix(base.rgb, base.rgb/(1.0-stroke.rgb), stroke.a/alpha_tot), base.a/alpha_tot); }
+}
-mediump vec3 blend_overlay(mediump vec4 base, mediump vec4 stroke, mediump float alpha_tot)
+
-{ return mix(stroke.rgb, mix(base.rgb, mix(2.0*base.rgb*stroke.rgb, 1.0-2.0*(1.0-base.rgb)*(1.0-stroke.rgb), floor(base.rgb*2.0)), stroke.a/alpha_tot), base.a/alpha_tot); }
+mediump vec3 blend_multiply(mediump vec4 base, mediump vec4 stroke, mediump float alpha_tot)
-mediump vec4 blend(mediump vec4 base, mediump vec4 stroke, int mode) {
+{
-   mediump float contribution = (1.0 - base.a) * stroke.a;
+    return mix(
-   mediump float alpha_tot = base.a + contribution;
+        stroke.rgb, 
-   if      (mode == 0) return vec4(blend_normal(base, stroke, alpha_tot), alpha_tot);
+        mix(
-   else if (mode == 1) return vec4(blend_multiply(base, stroke, alpha_tot), alpha_tot);
+            base.rgb, 
-   else if (mode == 2) return vec4(blend_screen(base, stroke, alpha_tot), alpha_tot);
+            base.rgb*stroke.rgb, 
-   else if (mode == 3) return vec4(blend_colorDodge(base, stroke, alpha_tot), alpha_tot);
+            stroke.a/alpha_tot
-   else if (mode == 4) return vec4(blend_overlay(base, stroke, alpha_tot), alpha_tot);
+        ), 
-   else return vec4(1.0, 0.0, 0.0, 1.0);
+        base.a/alpha_tot
+    );
+}
+
+mediump vec3 blend_screen(mediump vec4 base, mediump vec4 stroke, mediump float alpha_tot)
+{
+    return mix(
+        stroke.rgb, 
+        mix(
+            base.rgb, 
+            1.0-(1.0-base.rgb)*(1.0-stroke.rgb), 
+            stroke.a/alpha_tot
+        ), 
+        base.a/alpha_tot
+    );
+}
+
+mediump vec3 blend_colorDodge(mediump vec4 base, mediump vec4 stroke, mediump float alpha_tot)
+{
+    return mix(
+        stroke.rgb, 
+        mix(
+            base.rgb, 
+            base.rgb/(1.0-stroke.rgb), 
+            stroke.a/alpha_tot
+        ), 
+        base.a/alpha_tot
+    );
+}
+
+mediump vec3 blend_overlay(mediump vec4 base, mediump vec4 stroke, mediump float alpha_tot)
+{
+    return mix(
+        stroke.rgb, 
+        mix(
+            base.rgb, 
+            mix(
+                2.0*base.rgb*stroke.rgb, 
+                1.0-2.0*(1.0-base.rgb)*(1.0-stroke.rgb), 
+                floor(base.rgb*2.0)
+            ), 
+            stroke.a/alpha_tot
+        ), 
+        base.a/alpha_tot
+    );
+}
+
+mediump vec4 blend(mediump vec4 base, mediump vec4 stroke, int mode)
+{
+    mediump float contribution = (1.0 - base.a) * stroke.a;
+    mediump float alpha_tot = base.a + contribution;
+    if      (mode == 0) return vec4(blend_normal(base, stroke, alpha_tot), alpha_tot);
+    else if (mode == 1) return vec4(blend_multiply(base, stroke, alpha_tot), alpha_tot);
+    else if (mode == 2) return vec4(blend_screen(base, stroke, alpha_tot), alpha_tot);
+    else if (mode == 3) return vec4(blend_colorDodge(base, stroke, alpha_tot), alpha_tot);
+    else if (mode == 4) return vec4(blend_overlay(base, stroke, alpha_tot), alpha_tot);
+    else return vec4(1.0, 0.0, 0.0, 1.0);
 }

data/shaders/include/color.glsl

@@ -2,16 +2,19 @@ mediump vec3 brightness3(mediump vec3 c, mediump float val)
 {
    return clamp(c + vec3(val * 2.0 - 1.0), vec3(0), vec3(1));
 }
+
 mediump vec3 contrast3(mediump vec3 c, mediump float val)
 {
    val = val * 2.0 - 1.0;
    mediump float factor = ((259.0 / 255.0) * (val + 1.0)) / (1.0 * ((259.0 / 255.0) - val));
    return clamp(factor * (c - 0.5) + 0.5, vec3(0), vec3(1));
 }
+
 mediump float brightness1(mediump float c, mediump float val)
 {
    return clamp(c + (val * 2.0 - 1.0), 0.0, 1.0);
 }
+
 mediump float contrast1(mediump float c, mediump float val)
 {
    val = val * 2.0 - 1.0;

data/shaders/include/hsv.glsl

@@ -7,9 +7,10 @@ mediump vec3 rgb2hsv(mediump vec3 c)
     mediump float e = 1.0e-10;
     return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
 }
+
 mediump vec3 hsv2rgb(mediump vec3 c)
 {
-   mediump vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    mediump vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
-   mediump vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    mediump vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
-   return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
 }

data/shaders/lambert.glsl

@@ -1,20 +1,26 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec3 nor;
 in vec2 uvs;
 out vec3 n;
+
 void main()
 {
-   n = nor;
+    n = nor;
-   gl_Position = mvp * pos;
+    gl_Position = mvp * pos;
 }
 
 [[fragment]]
+
 uniform mediump vec3 light_dir;
 uniform mediump float ambient;
+
 in mediump vec3 n;
 out mediump vec4 frag;
+
 void main()
 {
     mediump float d = max(0.0, dot(normalize(n), light_dir));

data/shaders/lightmap.glsl

@@ -1,27 +1,33 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec3 nor;
 in vec2 uvs;
 out vec3 n;
 out vec2 uv;
+
 void main()
 {
-   n = nor;
+    n = nor;
-   uv = uvs;
+    uv = uvs;
-   gl_Position = mvp * pos;
+    gl_Position = mvp * pos;
 }
 
 [[fragment]]
+
 uniform mediump sampler2D tex;
 uniform mediump vec3 light_dir;
 uniform mediump float ambient;
+
 in mediump vec3 n;
 in mediump vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
-   mediump float d = max(0.0, dot(normalize(n), normalize(light_dir)));
+    mediump float d = max(0.0, dot(normalize(n), normalize(light_dir)));
-   mediump vec4 c = texture(tex, uv);
+    mediump vec4 c = texture(tex, uv);
-   frag = vec4(c.rgb * d + ambient, 1.0);
+    frag = vec4(c.rgb * d + ambient, 1.0);
 }

data/shaders/stroke-instanced.glsl

@@ -1,31 +1,36 @@
 [[vertex]]
+
 in vec4 pos;
 in vec2 uvs;
 in mat4 a_mvp;
 in float a_flow;
 out vec3 uv;
 out float alpha;
+
 void main()
 {
-   uv = vec3(uvs, pos.w);
+    uv = vec3(uvs, pos.w);
-   alpha = a_flow;
+    alpha = a_flow;
-   gl_Position = a_mvp * vec4(pos.xyz, 1.0);
+    gl_Position = a_mvp * vec4(pos.xyz, 1.0);
 }
 
 [[fragment]]
+
 uniform mediump sampler2D tex;
 uniform mediump sampler2D tex_pattern;
 uniform mediump vec4 col;
 uniform mediump vec2 resolution;
 uniform mediump vec2 pattern_offset;
 uniform mediump float pattern_alpha;
+
 in mediump float alpha;
 in mediump vec3 uv;
 out mediump vec4 frag;
+
 void main()
 {
-   mediump vec2 uv2 = gl_FragCoord.st / resolution;
+    mediump vec2 uv2 = gl_FragCoord.st / resolution;
-   mediump float pattern = 1.0 - (texture(tex_pattern, (uv2+pattern_offset)).r * 0.9) * pattern_alpha;
+    mediump float pattern = 1.0 - (texture(tex_pattern, (uv2+pattern_offset)).r * 0.9) * pattern_alpha;
-   mediump float a = (1.0 - texture(tex, uv.xy).r) * alpha * pattern;
+    mediump float a = (1.0 - texture(tex, uv.xy).r) * alpha * pattern;
-   frag = vec4(col.rgb, a);
+    frag = vec4(col.rgb, a);
 }

data/shaders/stroke-preview.glsl

@@ -1,20 +1,27 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
     uv = uvs;
     gl_Position = mvp * vec4(pos.xyz, 1.0);
-};
+}
 
 [[fragment]]
+
 uniform sampler2D tex;
 uniform mediump vec4 col;
+
 in mediump vec2 uv;
 out mediump vec4 frag;
-void main() {
+
+void main()
+{
     mediump float stroke = 1.0 - texture(tex, uv).r;
     int zero_count = 0;
     if (textureOffset(tex, uv, ivec2(-1, -1)).r > 0.99) zero_count++;
@@ -28,4 +35,4 @@ void main() {
     if (textureOffset(tex, uv, ivec2(+1, +1)).r > 0.99) zero_count++;
     mediump float edge = (zero_count > 1 && zero_count < 9) ? 0.75 : 0.0;
     frag = vec4(col.rgb, edge * (1.0 - float(zero_count) / 9.f));
-};
+}

data/shaders/stroke.glsl

@@ -1,20 +1,24 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 in vec2 uvs2;
 out vec2 uv;
 out vec2 uv_2;
 out float q;
+
 void main()
 {
-   uv = uvs;
+    uv = uvs;
-   uv_2 = uvs2;
+    uv_2 = uvs2;
-   q = pos.w;
+    q = pos.w;
-   gl_Position = mvp * vec4(pos.xy, 0.0, 1.0);
+    gl_Position = mvp * vec4(pos.xy, 0.0, 1.0);
-};
+}
 
 [[fragment]]
+
 #include "include/ext-fb-fetch.glsl"
 #include "include/rand.glsl"
 #include "include/color.glsl"
@@ -42,52 +46,58 @@ in mediump vec2 uv;
 in mediump vec2 uv_2;
 in mediump float q;
 #if defined(GL_EXT_shader_framebuffer_fetch)
-   inout mediump vec4 frag;
+    inout mediump vec4 frag;
 #else
-   out mediump vec4 frag;
+    out mediump vec4 frag;
 #endif
 
 void main()
 {
-   mediump vec2 uv2 = gl_FragCoord.st / resolution;
+    mediump vec2 uv2 = gl_FragCoord.st / resolution;
-   mediump float brush_alpha = ( 1.0 - texture(tex, uv/q).r ) * alpha;
+    mediump float brush_alpha = ( 1.0 - texture(tex, uv/q).r ) * alpha;
-   mediump vec4 fg = vec4(col.rgb, brush_alpha);
+    mediump vec4 fg = vec4(col.rgb, brush_alpha);
-   if (use_pattern)
+
-   {
+    if (use_pattern)
-       mediump vec2 rscale = resolution / vec2(512.0);
+    {
-       mediump float patt = texture(tex_pattern, uv2 * (0.5 / pattern_scale) * rscale + pattern_offset).r;
+        mediump vec2 rscale = resolution / vec2(512.0);
-       if (pattern_invert)
+        mediump float patt = texture(tex_pattern, uv2 * (0.5 / pattern_scale) * rscale + pattern_offset).r;
-           patt = 1.0 - patt;
+        if (pattern_invert)
-       patt = patt * pattern_depth + (1.0 - pattern_depth);
+            patt = 1.0 - patt;
-       if (pattern_bright != 0.5)
+        patt = patt * pattern_depth + (1.0 - pattern_depth);
-           patt = brightness1(patt, 1.0 - pattern_bright);
+        if (pattern_bright != 0.5)
-       if (pattern_contr != 0.5)
+            patt = brightness1(patt, 1.0 - pattern_bright);
-           patt = contrast1(patt, pattern_contr);
+        if (pattern_contr != 0.5)
-       fg.a = mix(fg.a, fg.a * patt, pattern_depth);
+            patt = contrast1(patt, pattern_contr);
-   }
+        fg.a = mix(fg.a, fg.a * patt, pattern_depth);
+    }
 
 #if defined(GL_EXT_shader_framebuffer_fetch)
-   mediump vec4 bg = frag;
+    mediump vec4 bg = frag;
 #elif defined(GL_ARM_shader_framebuffer_fetch)
-   mediump vec4 bg = gl_LastFragColorARM;
+    mediump vec4 bg = gl_LastFragColorARM;
 #else
-   mediump vec4 bg = texture(tex_bg, uv2);
+    mediump vec4 bg = texture(tex_bg, uv2);
 #endif
 
-   fg.a *= 1.0-rand(uv2+uv)*noise;
+    fg.a *= 1.0-rand(uv2+uv)*noise;
-   if (fg.a == 0.0) discard;
+
-   if (mix_alpha > 0.0)
+    // no need to go further
-   {
+    if (fg.a == 0.0)
-       mediump vec2 uv_mix = uv_2 / q;
+        discard;
-       if (uv_mix.x < 0.0 || uv_mix.x > 1.0 || uv_mix.y < 0.0 || uv_mix.y > 1.0) discard;
+
-       mediump vec4 mbg = texture(tex_mix, uv_mix);
+    if (mix_alpha > 0.0)
-       fg.rgb = mix(fg.rgb, mbg.rgb, mix_alpha * mbg.a);
+    {
-   }
+        mediump vec2 uv_mix = uv_2 / q;
-   mediump float contribution = (1.0 - bg.a) * fg.a;
+        if (uv_mix.x < 0.0 || uv_mix.x > 1.0 || uv_mix.y < 0.0 || uv_mix.y > 1.0) discard;
-   mediump float alpha_tot = bg.a + contribution;
+        mediump vec4 mbg = texture(tex_mix, uv_mix);
-   mediump vec3 rgb = mix(bg.rgb, fg.rgb, fg.a / alpha_tot);
+        fg.rgb = mix(fg.rgb, mbg.rgb, mix_alpha * mbg.a);
-   mediump vec4 frag_wet = vec4(rgb, max(bg.a, fg.a * 1.2));
+    }
-   mediump vec4 frag_dry = vec4(rgb, alpha_tot);
+
-   frag = mix(frag_dry, frag_wet, wet);
+    mediump float contribution = (1.0 - bg.a) * fg.a;
-};
+    mediump float alpha_tot = bg.a + contribution;
+    mediump vec3 rgb = mix(bg.rgb, fg.rgb, fg.a / alpha_tot);
+    mediump vec4 frag_wet = vec4(rgb, max(bg.a, fg.a * 1.2));
+    mediump vec4 frag_dry = vec4(rgb, alpha_tot);
+    frag = mix(frag_dry, frag_wet, wet);
+}
 

data/shaders/texture-alpha-sep.glsl

@@ -1,22 +1,28 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
     uv = uvs;
     gl_Position = mvp * vec4(pos.xyz, 1.0);
-};
+}
 
 [[fragment]]
+
 uniform sampler2D tex;
 uniform sampler2D tex_alpha;
 uniform sampler2D tex_bg;
 uniform mediump float alpha;
 uniform bool highlight;
+
 in mediump vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
     mediump vec3 rgb = texture(tex, uv).rgb;
@@ -25,4 +31,4 @@ void main()
     frag = highlight ? 
         vec4(clamp(vec3(0.3) + c.rgb, vec3(0.0), vec3(1.0)), c.a) : 
         texture(tex, uv) * vec4(1.0, 1.0, 1.0, alpha);
-};
+}

data/shaders/texture-alpha.glsl

@@ -1,24 +1,30 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
     uv = uvs;
     gl_Position = mvp * vec4(pos.xyz, 1.0);
-};
+}
 
 [[fragment]]
+
 uniform sampler2D tex;
 uniform mediump float alpha;
 uniform bool highlight;
+
 in mediump vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
     mediump vec4 c = texture(tex, uv);
     frag = highlight ? 
         vec4(clamp(vec3(0.3) + c.rgb, vec3(0.0), vec3(1.0)), c.a) : 
         c * vec4(1.0, 1.0, 1.0, alpha);
-};
+}

data/shaders/texture-blend.glsl

@@ -1,29 +1,38 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
     uv = uvs;
     gl_Position = mvp * vec4(pos.xyz, 1.0);
-};
+}
 
 [[fragment]]
+
 #include "include/ext-fb-fetch.glsl"
 #include "include/blend.glsl"
+
 uniform sampler2D tex;
 uniform sampler2D tex_alpha;
 uniform sampler2D tex_bg;
 uniform mediump float alpha;
 uniform int blend_mode;
+
 in mediump vec2 uv;
 #if defined(GL_EXT_shader_framebuffer_fetch)
     inout highp vec4 frag;
 #else
     out mediump vec4 frag;
 #endif
-void main() {
+
+void main()
+{
+    // if available use the extension
 #if defined(GL_EXT_shader_framebuffer_fetch)
     highp vec4 bg = frag;
 #elif defined(GL_ARM_shader_framebuffer_fetch)
@@ -31,8 +40,13 @@ void main() {
 #else
     mediump vec4 bg = texture(tex_bg, uv);
 #endif
+
     mediump vec4 fg = vec4(texture(tex, uv).rgb, texture(tex_alpha, uv).a);
-    if (fg.a == 0.0) { frag = bg; return; }
+    if (fg.a == 0.0)
+    {
+        frag = bg;
+        return;
+    }
     mediump vec4 blended = blend(bg, fg, blend_mode);
     frag = vec4(blended.rgb, blended.a * alpha);
-};
+}

data/shaders/texture.glsl

@@ -1,19 +1,25 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
     uv = uvs;
     gl_Position = mvp * vec4(pos.xyz, 1.0);
-};
+}
 
 [[fragment]]
+
 uniform sampler2D tex;
+
 in mediump vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
     frag = texture(tex, uv);
-};
+}

data/shaders/uvs.glsl

@@ -1,18 +1,23 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec2 uvs;
 out vec2 uv;
+
 void main()
 {
     uv = uvs;
     gl_Position = mvp * vec4(pos.xyz, 1.0);
-};
+}
 
 [[fragment]]
+
 in mediump vec2 uv;
 out mediump vec4 frag;
+
 void main()
 {
-   frag = vec4(uv, 0.0, 1.0);
+    frag = vec4(uv, 0.0, 1.0);
-};
+}

data/shaders/vertex-color.glsl

@@ -1,19 +1,24 @@
 [[vertex]]
+
 uniform mat4 mvp;
+
 in vec4 pos;
 in vec4 col;
 out vec4 c;
+
 void main()
 {
-   c = col;
+    c = col;
-   gl_Position = mvp * pos;
+    gl_Position = mvp * pos;
-   gl_PointSize = 5.0;
+    gl_PointSize = 5.0;
-};
+}
 
 [[fragment]]
+
 in mediump vec4 c;
 out mediump vec4 frag;
+
 void main()
 {
-   frag = c;
+    frag = c;
-};
+}

src/app.cpp

@@ -534,6 +534,7 @@ void App::update(float dt)
         layout.reload();
         if (auto* main = layout[main_id])
             main->update(width, height, zoom);
+        stroke->update_controls();
     }
 #endif