Merge branch 'master' into pr/1875

app/shaders/alphaover.frag

@@ -3,29 +3,30 @@ uniform sampler2D blend_in;
 uniform bool base_in_enabled;
 uniform bool blend_in_enabled;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main(void) {
-    vec4 base_col = texture2D(base_in, ove_texcoord);
-    vec4 blend_col = texture2D(blend_in, ove_texcoord);
+    vec4 base_col = texture(base_in, ove_texcoord);
+    vec4 blend_col = texture(blend_in, ove_texcoord);
 
     if (!base_in_enabled && !blend_in_enabled) {
-        gl_FragColor = vec4(0.0);
+        frag_color = vec4(0.0);
         return;
     }
 
     if (!base_in_enabled) {
-        gl_FragColor = blend_col;
+        frag_color = blend_col;
         return;
     }
 
     if (!blend_in_enabled) {
-        gl_FragColor = base_col;
+        frag_color = base_col;
         return;
     }
 
     base_col *= 1.0 - blend_col.a;
     base_col += blend_col;
 
-    gl_FragColor = base_col;
+    frag_color = base_col;
 }

app/shaders/blur.frag

@@ -8,7 +8,8 @@ uniform vec2 resolution_in;
 
 uniform int ove_iteration;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 // Gaussian function uses PI
 #define M_PI 3.1415926535897932384626433832795
@@ -63,7 +64,7 @@ void main(void) {
     int mode = determine_mode();
 
     if (mode == MODE_NONE) {
-        gl_FragColor = texture2D(tex_in, ove_texcoord);
+        frag_color = texture(tex_in, ove_texcoord);
         return;
     }
 
@@ -115,9 +116,9 @@ void main(void) {
                 && pixel_coord.x < 1.0
                 && pixel_coord.y >= 0.0
                 && pixel_coord.y < 1.0)) {
-            composite += texture2D(tex_in, pixel_coord) * weight;
+            composite += texture(tex_in, pixel_coord) * weight;
         }
     }
 
-    gl_FragColor = composite;
+    frag_color = composite;
 }

app/shaders/colordifferencekey.frag

@@ -0,0 +1,68 @@
+uniform sampler2D tex_in;
+uniform sampler2D garbage_in;
+uniform sampler2D core_in;
+uniform int color_in;
+uniform bool garbage_in_enabled;
+uniform bool core_in_enabled;
+uniform float highlights_in;
+uniform float shadows_in;
+uniform bool mask_only_in;
+
+in vec2 ove_texcoord;
+out vec4 frag_color;
+
+#define SCREEN_COLOR_GREEN 0
+#define SCREEN_COLOR_BLUE  1
+
+void main(void) {
+    vec4 tex_col = texture(tex_in, ove_texcoord);
+
+    // Unassociate RGB before calculating values
+    vec4 unassoc = tex_col;
+    if (unassoc.a > 0) {
+      unassoc.rgb /= unassoc.a;
+    }
+
+    // Simple keyer, generates a inverted mask (background is white, foreground black)
+    float mask;
+    if (color_in == SCREEN_COLOR_GREEN) {
+      mask = (unassoc.g - max(unassoc.r, unassoc.b));
+    } else{ // Assume SCREEN_COLOR_BLUE
+      mask = (unassoc.b - max(unassoc.r, unassoc.g));
+    }
+
+    mask = clamp(mask, 0.0, 1.0);
+
+    if (garbage_in_enabled) {
+      // Force anything we want to remove to be 1.0
+      vec4 garbage = texture(garbage_in, ove_texcoord);
+      // Assumes garbage is achromatic
+      mask += garbage.r;
+      mask = clamp(mask, 0.0, 1.0);
+    }
+
+    if (core_in_enabled) {
+      // Force anything we want to keep to be 0.1
+      vec3 core = texture(core_in, ove_texcoord).rgb;
+      vec3 core_invert = 1.0 - core.rgb;
+      // Assumes core is achromatic
+      mask *= core_invert.r;
+      mask = clamp(mask, 0.0, 1.0);
+    }
+
+    // Crush blacks and push whites
+    mask = highlights_in * 0.01 * (shadows_in * 0.01 * mask - 1.0) + 1.0;
+    mask = clamp(mask, 0.0, 1.0);
+
+    // Invert mask
+    mask = 1.0 - mask;
+
+    // Multiply color by mask
+    tex_col *= mask;
+
+    if (!mask_only_in) {
+        frag_color = tex_col;
+    } else {
+        frag_color = vec4(vec3(mask), 1.0);
+    }
+}

app/shaders/colormanage.frag

@@ -10,7 +10,8 @@ uniform mat4 ove_cropmatrix;
 #define ALPHA_ASSOC    2
 
 // Main texture coordinate
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 // Program will replace this with OCIO's auto-generated shader code
 %1
@@ -31,11 +32,11 @@ vec4 deassoc(vec4 c) {
 void main() {
   vec2 cropped_coord = (vec4(ove_texcoord-vec2(0.5, 0.5), 0.0, 1.0)*ove_cropmatrix).xy + vec2(0.5, 0.5);
   if (cropped_coord.x < 0.0 || cropped_coord.x >= 1.0 || cropped_coord.y < 0.0 || cropped_coord.y >= 1.0) {
-    gl_FragColor = vec4(0.0);
+    frag_color = vec4(0.0);
     return;
   }
 
-  vec4 col = texture2D(ove_maintex, cropped_coord);
+  vec4 col = texture(ove_maintex, cropped_coord);
 
   // If alpha is associated, de-associate now
   if (ove_maintex_alpha == ALPHA_ASSOC) {
@@ -52,5 +53,5 @@ void main() {
     col = assoc(col);
   }
 
-  gl_FragColor = col;
+  frag_color = col;
 }

app/shaders/cornerpin.frag

@@ -4,45 +4,46 @@ uniform sampler2D tex_in;
 uniform bool perspective_in;
 
 // Input texture coordinate
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
-varying vec2 q;
-varying vec2 b1;
-varying vec2 b2;
-varying vec2 b3;
+in vec2 q;
+in vec2 b1;
+in vec2 b2;
+in vec2 b3;
 
 float Wedge2D(vec2 v, vec2 w) {
-	return (v.x*w.y) - (v.y*w.x);
+  return (v.x*w.y) - (v.y*w.x);
 }
 
 void main() {
     if(perspective_in){
-        gl_FragColor = texture2D(tex_in, ove_texcoord);
+        frag_color = texture(tex_in, ove_texcoord);
     } else {
-	    float A = Wedge2D(b2, b3);
-		float B = Wedge2D(b3, q) - Wedge2D(b1, b2);
-		float C = Wedge2D(b1, q);
+      float A = Wedge2D(b2, b3);
+    float B = Wedge2D(b3, q) - Wedge2D(b1, b2);
+    float C = Wedge2D(b1, q);
 
-		vec2 uv;
+    vec2 uv;
 
-		// solve for v
-		if (abs(A) < 0.001) {
-			uv.y = -C/B;
-		} else {
-			float discrim = B*B - 4.0*A*C;
-			uv.y = 0.5 * (-B + sqrt(discrim)) / A;
-		}
+    // solve for v
+    if (abs(A) < 0.001) {
+      uv.y = -C/B;
+    } else {
+      float discrim = B*B - 4.0*A*C;
+      uv.y = 0.5 * (-B + sqrt(discrim)) / A;
+    }
 
-		// solve for u
-		vec2 denom = b1 + uv.y * b3;
-		if (abs(denom.x) > abs(denom.y)) {
-			uv.x = (q.x - b2.x * uv.y) / denom.x;
-		} else {
-			uv.x = (q.y - b2.y * uv.y) / denom.y;
-		}
+    // solve for u
+    vec2 denom = b1 + uv.y * b3;
+    if (abs(denom.x) > abs(denom.y)) {
+      uv.x = (q.x - b2.x * uv.y) / denom.x;
+    } else {
+      uv.x = (q.y - b2.y * uv.y) / denom.y;
+    }
 
-		uv.y = 1.0 - uv.y;
+    uv.y = 1.0 - uv.y;
 
-		gl_FragColor = texture2D(tex_in, uv);
-	}
+    frag_color = texture(tex_in, uv);
+  }
 }

app/shaders/cornerpin.vert

@@ -8,15 +8,15 @@ uniform vec2 resolution_in;
 
 uniform mat4 ove_mvpmat;
 
-attribute vec4 a_position;
-attribute vec2 a_texcoord;
+in vec4 a_position;
+in vec2 a_texcoord;
 
-varying vec2 ove_texcoord;
+out vec2 ove_texcoord;
 
-varying vec2 q;
-varying vec2 b1;
-varying vec2 b2;
-varying vec2 b3;
+out vec2 q;
+out vec2 b1;
+out vec2 b2;
+out vec2 b3;
 
 void main() {
     // The slider inputs only contain the amount they have changed rather than
@@ -37,7 +37,7 @@ void main() {
         float c1 = b_l.y - m1 * b_l.x;
         float m2 = (b_r.y - t_l.y)/(b_r.x - t_l.x);
         float c2 = t_l.y - m2 * t_l.x;
-    
+
         // Find the intersection by setting the two line equations equal and rearrange.
         float mid_x = (c2 - c1) / (m1 - m2);
         float mid_y = m1 * mid_x + c1;
@@ -70,7 +70,7 @@ void main() {
         } else {
             q = (d2+d0)/d0;
         }
-    
+
         gl_Position[0] *= q;
         gl_Position[1] *= q;
         gl_Position[3] = q;
@@ -93,7 +93,7 @@ void main() {
         b2 = t_l - b_l;
         b3 = b_l - b_r - t_l + t_r;
     }
-    
+
 
     ove_texcoord = a_texcoord;
 }

app/shaders/crop.frag

@@ -8,7 +8,8 @@ uniform float feather_in;
 uniform vec2 resolution_in;
 
 // Input texture coordinate
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main() {
     float multiplier = 1.0;
@@ -44,9 +45,9 @@ void main() {
     }
 
     if (multiplier > 0.0) {
-        vec4 color = texture2D(tex_in, ove_texcoord) * multiplier;
-        gl_FragColor = color;
+        vec4 color = texture(tex_in, ove_texcoord) * multiplier;
+        frag_color = color;
     } else {
-        gl_FragColor = vec4(0.0);
+        frag_color = vec4(0.0);
     }
 }

app/shaders/crossdissolve.frag

@@ -10,7 +10,8 @@ uniform int curve_in;
 
 uniform float ove_tprog_all;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 float TransformCurve(float linear) {
     if (curve_in == EXPONENTIAL_CURVE) {
@@ -26,12 +27,12 @@ void main(void) {
     vec4 composite = vec4(0.0);
 
     if (out_block_in_enabled) {
-        composite += texture2D(out_block_in, ove_texcoord) * TransformCurve(1.0 - ove_tprog_all);
+        composite += texture(out_block_in, ove_texcoord) * TransformCurve(1.0 - ove_tprog_all);
     }
 
     if (in_block_in_enabled) {
-        composite += texture2D(in_block_in, ove_texcoord) * TransformCurve(ove_tprog_all);
+        composite += texture(in_block_in, ove_texcoord) * TransformCurve(ove_tprog_all);
     }
 
-    gl_FragColor = composite;
+    frag_color = composite;
 }

app/shaders/default.frag

@@ -2,9 +2,10 @@
 uniform sampler2D ove_maintex;
 
 // Input texture coordinate
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main() {
-    vec4 color = texture2D(ove_maintex, ove_texcoord);
-    gl_FragColor = color;
+    vec4 color = texture(ove_maintex, ove_texcoord);
+    frag_color = color;
 }

app/shaders/default.vert

@@ -1,9 +1,9 @@
 uniform mat4 ove_mvpmat;
 
-attribute vec4 a_position;
-attribute vec2 a_texcoord;
+in vec4 a_position;
+in vec2 a_texcoord;
 
-varying vec2 ove_texcoord;
+out vec2 ove_texcoord;
 
 void main() {
     gl_Position = ove_mvpmat * a_position;

app/shaders/deinterlace.frag

@@ -2,7 +2,8 @@ uniform sampler2D ove_maintex;
 
 uniform vec2 resolution_in;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 float round(float x)
 {
@@ -18,6 +19,6 @@ void main() {
     float half_vert = round(resolution_in.y / 2.0);
     using_texcoord.y = (round(using_texcoord.y * half_vert) + 0.25) / half_vert;
 
-    vec4 color = texture2D(ove_maintex, using_texcoord);
-    gl_FragColor = color;
+    vec4 color = texture(ove_maintex, using_texcoord);
+    frag_color = color;
 }

app/shaders/despill.frag

@@ -0,0 +1,65 @@
+uniform sampler2D tex_in;
+uniform int color_in;
+uniform int method_in;
+uniform bool preserve_luminance_input;
+uniform vec3 luma_coeffs;
+
+in vec2 ove_texcoord;
+out vec4 frag_color;
+
+#define AVERAGE             0
+#define DOUBLE_RED_AVERAGE  1
+#define DOUBLE_AVERAGE      2
+#define BLUE_LIMIT          3
+
+void main(void) {
+    vec4 original_col = texture(tex_in, ove_texcoord);
+    vec4 tex_col = original_col;
+    float color_average = 0.0;
+
+    if(color_in == 0) { // Green screen
+        switch (method_in) {
+        case AVERAGE:
+            color_average = dot(tex_col.rb, vec2(0.5)); // (tex_col.r + tex_col.b) / 2.0
+            tex_col.g = tex_col.g > color_average ? color_average: tex_col.g;
+            break;
+        case DOUBLE_RED_AVERAGE:
+            color_average = dot(tex_col.rb, vec2(2.0, 1.0) / 3.0); // (2.0 * tex_col.r + tex_col.b) / 3.0
+            tex_col.g = tex_col.g > color_average ? color_average : tex_col.g;
+            break;
+        case DOUBLE_AVERAGE:
+            color_average = dot(tex_col.br, vec2(2.0, 1.0) / 3.0); // (2.0 * tex_col.b + tex_col.r) / 3.0
+            tex_col.g = tex_col.g > color_average ? color_average : tex_col.g;
+            break;
+        case BLUE_LIMIT:
+            tex_col.g = tex_col.g > tex_col.b ? tex_col.b : tex_col.g;
+            break;
+        }
+    } else { // Blue screen
+        switch (method_in) {
+        case AVERAGE:
+            color_average = dot(tex_col.rg, vec2(0.5)); // (tex_col.r + tex_col.g) / 2.0
+            tex_col.b = tex_col.b > color_average ? color_average : tex_col.b;
+            break;
+        case DOUBLE_RED_AVERAGE:
+            color_average = dot(tex_col.rg, vec2(2.0, 1.0) / 3.0); // (2.0 * tex_col.r + tex_col.g) / 3.0
+            tex_col.b = tex_col.b > color_average ? color_average : tex_col.b;
+            break;
+        case DOUBLE_AVERAGE:
+            color_average = dot(tex_col.gr, vec2(2.0, 1.0) / 3.0); // (2.0 * tex_col.g+ tex_col.r) / 3.0
+            tex_col.b = tex_col.b > color_average ? color_average : tex_col.b;
+            break;
+        case BLUE_LIMIT:
+            tex_col.b = tex_col.b > tex_col.g ? tex_col.g : tex_col.b;
+            break;
+        }
+    }
+
+    if (preserve_luminance_input) {
+        vec4 diff = original_col - tex_col;
+        float luma = dot(abs(diff.rgb), luma_coeffs);
+        tex_col.rgb += vec3(luma);
+    }
+
+    frag_color = tex_col;
+}

app/shaders/diptoblack.frag

@@ -8,19 +8,20 @@ uniform float ove_tprog_all;
 uniform float ove_tprog_out;
 uniform float ove_tprog_in;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main(void) {
     if (out_block_in_enabled && in_block_in_enabled) {
-        vec4 out_block_col = mix(texture2D(out_block_in, ove_texcoord), color_in, ove_tprog_out);
-        vec4 in_block_col = mix(texture2D(in_block_in, ove_texcoord), color_in, 1.0 - ove_tprog_in);
+        vec4 out_block_col = mix(texture(out_block_in, ove_texcoord), color_in, ove_tprog_out);
+        vec4 in_block_col = mix(texture(in_block_in, ove_texcoord), color_in, 1.0 - ove_tprog_in);
 
-        gl_FragColor = out_block_col + in_block_col;
+        frag_color = out_block_col + in_block_col;
     } else if (out_block_in_enabled) {
-        gl_FragColor = mix(texture2D(out_block_in, ove_texcoord), color_in, ove_tprog_all);
+        frag_color = mix(texture(out_block_in, ove_texcoord), color_in, ove_tprog_all);
     } else if (in_block_in_enabled) {
-        gl_FragColor = mix(texture2D(in_block_in, ove_texcoord), color_in, 1.0 - ove_tprog_all);
+        frag_color = mix(texture(in_block_in, ove_texcoord), color_in, 1.0 - ove_tprog_all);
     } else {
-        gl_FragColor = vec4(0.0);
+        frag_color = vec4(0.0);
     }
 }

app/shaders/flip.frag

@@ -2,11 +2,12 @@ uniform sampler2D tex_in;
 uniform bool horiz_in;
 uniform bool vert_in;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main(void) {
     if (!horiz_in && !vert_in) {
-        gl_FragColor = texture2D(tex_in, ove_texcoord);
+        frag_color = texture(tex_in, ove_texcoord);
         return;
     }
 
@@ -15,5 +16,5 @@ void main(void) {
     if (horiz_in) new_coord.x = 1.0 - new_coord.x;
     if (vert_in) new_coord.y = 1.0 - new_coord.y;
 
-    gl_FragColor = texture2D(tex_in, new_coord);
+    frag_color = texture(tex_in, new_coord);
 }

app/shaders/interlace.frag

@@ -2,14 +2,15 @@ uniform sampler2D top_tex_in;
 uniform sampler2D bottom_tex_in;
 uniform vec2 resolution_in;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main() {
     float y_pixel = floor(ove_texcoord.y * resolution_in.y);
 
     if (mod(y_pixel, 2.0) == 0.0) {
-      gl_FragColor = texture2D(top_tex_in, ove_texcoord);
+      frag_color = texture(top_tex_in, ove_texcoord);
     } else {
-      gl_FragColor = texture2D(bottom_tex_in, ove_texcoord);
+      frag_color = texture(bottom_tex_in, ove_texcoord);
     }
 }

app/shaders/mosaic.frag

@@ -5,7 +5,8 @@ uniform float horiz_in;
 uniform float vert_in;
 
 // Input texture coordinate
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main() {
   float x;
@@ -23,6 +24,6 @@ void main() {
     y = ove_texcoord.y;
   }
 
-  vec4 color = texture2D(tex_in, vec2(x, y));
-  gl_FragColor = color;
+  vec4 color = texture(tex_in, vec2(x, y));
+  frag_color = color;
 }

app/shaders/noise.frag

@@ -1,13 +1,13 @@
 uniform float time_in;
-varying vec2 ove_texcoord;
 
 uniform float strength_in;
 uniform bool color_in;
 //uniform bool blend;
 
-// precision lowp    float;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
-float PHI = 1.61803398874989484820459 * 00000.1; // Golden Ratio   
+float PHI = 1.61803398874989484820459 * 00000.1; // Golden Ratio
 float PI  = 3.14159265358979323846264 *  00000.1; // PI
 float SQ2 = 1.41421356237309504880169 * 10000.0; // Square Root of Two
 
@@ -23,16 +23,16 @@ bool isNan( float val )
 
 float gold_noise(vec2 coordinate, float seed){
     float value = fract(tan(distance(coordinate*(seed+PHI), vec2(PHI, PI)))*SQ2)*(strength_in*0.01);
-	return isNan(value) ? 0.0 : value;
+  return isNan(value) ? 0.0 : value;
 }
 
 void main(void) {
-	vec3 noise;
-	if (color_in) {
-		noise = vec3(gold_noise(ove_texcoord, time_in + 42069.0), gold_noise(ove_texcoord, time_in + 69220.0), gold_noise(ove_texcoord, time_in + 1337.0));
-	} else {
-		noise = vec3(gold_noise(ove_texcoord, time_in + 69420.0));
-	}
+  vec3 noise;
+  if (color_in) {
+    noise = vec3(gold_noise(ove_texcoord, time_in + 42069.0), gold_noise(ove_texcoord, time_in + 69220.0), gold_noise(ove_texcoord, time_in + 1337.0));
+  } else {
+    noise = vec3(gold_noise(ove_texcoord, time_in + 69420.0));
+  }
 
-    gl_FragColor = vec4(noise, 1.0);
+    frag_color = vec4(noise, 1.0);
 }

app/shaders/opacity.frag

@@ -0,0 +1,11 @@
+// Inputs
+uniform sampler2D tex_in;
+uniform float opacity_in;
+
+// Input texture coordinate
+in vec2 ove_texcoord;
+out vec4 frag_color;
+
+void main() {
+  frag_color = texture(tex_in, ove_texcoord) * opacity_in;
+}

app/shaders/rgbhistogram.frag

@@ -2,7 +2,8 @@ uniform sampler2D ove_maintex;
 uniform vec2 viewport;
 uniform float histogram_scale;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main(void) {
     float histogram_width = ceil(histogram_scale * viewport.y);
@@ -13,7 +14,7 @@ void main(void) {
 
     for (int i = 0; float(i) < histogram_width; i++) {
         ratio = float(i) / float(histogram_width - 1.0);
-        cur_col = texture2D(
+        cur_col = texture(
             ove_maintex,
             vec2(ove_texcoord.y, ratio)
         ).rgb;
@@ -27,5 +28,5 @@ void main(void) {
             );
     }
 
-    gl_FragColor = vec4(sum, 1.0);
+    frag_color = vec4(sum, 1.0);
 }

app/shaders/rgbhistogram.vert

@@ -1,9 +1,9 @@
 uniform float histogram_scale;
 
-attribute vec4 a_position;
-attribute vec2 a_texcoord;
+in vec4 a_position;
+in vec2 a_texcoord;
 
-varying vec2 ove_texcoord;
+out vec2 ove_texcoord;
 
 mat4 scale_mat4(vec3 scale) {
     return mat4(

app/shaders/rgbhistogram_secondary.frag

@@ -4,7 +4,8 @@ uniform vec2 viewport;
 uniform float histogram_scale;
 uniform float histogram_power;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main(void) {
     vec3 col = vec3(0.0);
@@ -17,7 +18,7 @@ void main(void) {
 
     for (int i = 0; float(i) < histogram_height; i++) {
         ratio = float(i) / float(histogram_height - 1.0);
-        sum += texture2D(
+        sum += texture(
             ove_maintex,
             vec2(ove_texcoord.x, ratio)
         ).rgb;
@@ -26,5 +27,5 @@ void main(void) {
     histogram_ratio = pow(sum / total_pixels, vec3(histogram_power));
     col = step(vec3(ove_texcoord.y), histogram_ratio);
 
-    gl_FragColor = vec4(col, 1.0);
+    frag_color = vec4(col, 1.0);
 }

app/shaders/rgbwaveform.frag

@@ -5,7 +5,8 @@ uniform vec3 luma_coeffs;
 
 uniform float waveform_scale;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main(void) {
     float waveform_height = ceil(waveform_scale * viewport.y);
@@ -17,7 +18,7 @@ void main(void) {
 
     for (int i = 0; float(i) < waveform_height; i++) {
         ratio = float(i) / float(waveform_height - 1.0);
-        cur_col.rgb = texture2D(
+        cur_col.rgb = texture(
             ove_maintex,
             vec2(ove_texcoord.x, ratio)
         ).rgb;
@@ -33,5 +34,5 @@ void main(void) {
     }
 
     col.rgb += vec3(col.w);
-    gl_FragColor = vec4(col.rgb, 1.0);
+    frag_color = vec4(col.rgb, 1.0);
 }

app/shaders/rgbwaveform.vert

@@ -1,9 +1,9 @@
 uniform float waveform_scale;
 
-attribute vec4 a_position;
-attribute vec2 a_texcoord;
+in vec4 a_position;
+in vec2 a_texcoord;
 
-varying vec2 ove_texcoord;
+out vec2 ove_texcoord;
 
 mat4 scale_mat4(vec3 scale) {
     return mat4(

app/shaders/shape.frag

@@ -1,5 +1,6 @@
 // Input texture coordinate
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 // Match with ShapeNode::Type
 #define SHAPE_RECTANGLE 0
@@ -37,5 +38,5 @@ void main() {
     col = color_in * (1.0-t);
   }
 
-  gl_FragColor = col;
+  frag_color = col;
 }

app/shaders/solid.frag

@@ -1,5 +1,7 @@
 uniform vec4 color_in;
 
+out vec4 frag_color;
+
 void main(void) {
-    gl_FragColor = color_in;
+    frag_color = color_in;
 }

app/shaders/stroke.frag

@@ -9,10 +9,11 @@ uniform vec2 resolution_in;
 // Standard inputs
 uniform int ove_iteration;
 
-varying vec2 ove_texcoord;
+in vec2 ove_texcoord;
+out vec4 frag_color;
 
 void main(void) {
-    vec4 pixel_here = texture2D(tex_in, ove_texcoord);
+    vec4 pixel_here = texture(tex_in, ove_texcoord);
 
     // Detect no-op situations
     if (radius_in == 0.0
@@ -20,7 +21,7 @@ void main(void) {
         || (inner_in && pixel_here.a == 0.0)
         || (!inner_in && pixel_here.a == 1.0)) {
         // No-op, do nothing
-        gl_FragColor = pixel_here;
+        frag_color = pixel_here;
         return;
     }
 
@@ -37,7 +38,7 @@ void main(void) {
 
             if (abs(length(vec2(i, j))) < radius) {
                 // Get pixel here
-                float alpha = texture2D(tex_in, ove_texcoord + vec2(x_coord, y_coord)).a;
+                float alpha = texture(tex_in, ove_texcoord + vec2(x_coord, y_coord)).a;
 
                 if (inner_in) {
                     alpha = 1.0 - alpha;
@@ -74,5 +75,5 @@ void main(void) {
         stroke_col = stroke_col * (1.0 - pixel_here.a) + pixel_here;
     }
 
-    gl_FragColor = stroke_col;
+    frag_color = stroke_col;
 }