🔧 Use generic i/o names

docs/how-to-create-new-effects.md

@@ -86,7 +86,9 @@ Please study this code carefully, all of it is explained with inline comments.
 
 ```glsl
 // The content from common.glsl is automatically prepended to each shader effect. This
-// provides some standard uniforms which will be updated during the animation.
+// provides the standard input "vec2 iTexCoord", the standard output "vec4 oColor" as well
+// as some standard uniforms which will be updated during the animation:
+
 // bool      uForOpening: True if a window-open animation is ongoing, false otherwise.
 // sampler2D uTexture:    Contains the texture of the window.
 // float     uProgress:   A value which transitions from 0 to 1 during the entire animation.
@@ -99,15 +101,15 @@ uniform float uFadeWidth;
 
 void main() {
   // Get the color from the window texture.
-  cogl_color_out = texture2D(uTexture, cogl_tex_coord_in[0].st);
+  oColor = texture2D(uTexture, iTexCoord.st);
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
-  if (cogl_color_out.a > 0) {
+  if (oColor.a > 0) {
-    cogl_color_out.rgb /= cogl_color_out.a;
+    oColor.rgb /= oColor.a;
   }
 
   // Radial distance from window edge to the window's center.
-  float dist = length(cogl_tex_coord_in[0].st - 0.5) * 2.0 / sqrt(2.0);
+  float dist = length(iTexCoord.st - 0.5) * 2.0 / sqrt(2.0);
 
   // This gradually dissolves from [1..0] from the outside to the center. We
   // switch the direction for opening and closing.
@@ -118,7 +120,7 @@ void main() {
   mask = smoothstep(0, 1, mask);
 
   // Apply the mask to the output.
-  cogl_color_out.a *= mask;
+  oColor.a *= mask;
 }
 ```
 

resources/shaders/apparition.frag

@@ -30,7 +30,7 @@ void main() {
 
   // Choose a random suction center.
   vec2 center = uSeed * uRandomness + 0.5 * (1.0 - uRandomness);
-  vec2 coords = cogl_tex_coord_in[0].st * ACTOR_SCALE - PADDING - center;
+  vec2 coords = iTexCoord.st * ACTOR_SCALE - PADDING - center;
 
   // Add some shaking.
   coords.x +=
@@ -49,11 +49,11 @@ void main() {
   coords      = vec2(dot(coords, vec2(c, -s)), dot(coords, vec2(s, c)));
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
-  cogl_color_out = texture2D(uTexture, coords + center);
+  oColor = texture2D(uTexture, coords + center);
-  if (cogl_color_out.a > 0) {
+  if (oColor.a > 0) {
-    cogl_color_out.rgb /= cogl_color_out.a;
+    oColor.rgb /= oColor.a;
   }
 
   // Fade out the window texture.
-  cogl_color_out.a *= 1.0 - progress;
+  oColor.a *= 1.0 - progress;
 }

resources/shaders/broken-glass.frag

@@ -25,7 +25,7 @@ const float ACTOR_SCALE  = 2.0;
 const float PADDING      = ACTOR_SCALE / 2.0 - 0.5;
 
 void main() {
-  cogl_color_out = vec4(0, 0, 0, 0);
+  oColor = vec4(0, 0, 0, 0);
 
   float progress = uForOpening ? 1.0 - uProgress : uProgress;
 
@@ -35,7 +35,7 @@ void main() {
     // To enable drawing shards outside of the window bounds, the actor was scaled
     // by ACTOR_SCALE. Here we scale and move the texture coordinates so that the
     // window gets drawn at the correct position again.
-    vec2 coords = cogl_tex_coord_in[0].st * ACTOR_SCALE - PADDING;
+    vec2 coords = iTexCoord.st * ACTOR_SCALE - PADDING;
 
     // Scale and rotate around our epicenter.
     coords -= uEpicenter;
@@ -66,12 +66,12 @@ void main() {
     float shardGroup = floor(shardMap.g * SHARD_LAYERS * 0.999);
 
     if (shardGroup == i && (shardMap.x - pow(progress + 0.1, 2)) > 0) {
-      cogl_color_out = texture2D(uTexture, coords);
+      oColor = texture2D(uTexture, coords);
     }
   }
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
-  if (cogl_color_out.a > 0) {
+  if (oColor.a > 0) {
-    cogl_color_out.rgb /= cogl_color_out.a;
+    oColor.rgb /= oColor.a;
   }
 }

resources/shaders/common.glsl

@@ -23,6 +23,25 @@
 // uTime:       A steadily increasing value in seconds.
 // uSize:       The size of uTexture in pixels.
 // uPadding:    The empty area around the actual window (e.g. where the shadow is drawn).
+
+#ifdef KWIN
+
+uniform bool uForOpening;
+uniform sampler2D uTexture;
+uniform float animationProgress;
+// uniform float uTime;
+// uniform vec2 uSize;
+// uniform float uPadding;
+
+in vec2 texcoord0;
+out vec4 fragColor;
+
+#define uProgress animationProgress
+#define iTexCoord texcoord0
+#define oColor fragColor
+
+#else
+
 uniform bool uForOpening;
 uniform sampler2D uTexture;
 uniform float uProgress;
@@ -30,6 +49,11 @@ uniform float uTime;
 uniform vec2 uSize;
 uniform float uPadding;
 
+#define iTexCoord cogl_tex_coord_in[0]
+#define oColor cogl_color_out
+
+#endif
+
 // ----------------------------------------------------------------- compositing operators
 
 // The Shell.GLSLEffect uses straight alpha blending. This helper method allows
@@ -71,7 +95,7 @@ float getEdgeMask(vec2 uv, vec2 maxUV, float fadeWidth) {
 // (offset = 1).
 float getAbsoluteEdgeMask(float fadePixels, float offset) {
   float padding = max(0, uPadding - fadePixels * offset);
-  vec2 uv       = cogl_tex_coord_in[0].st * uSize - padding;
+  vec2 uv       = iTexCoord.st * uSize - padding;
   return getEdgeMask(uv, uSize - 2.0 * padding, fadePixels);
 }
 
@@ -79,7 +103,7 @@ float getAbsoluteEdgeMask(float fadePixels, float offset) {
 // the fade zone is given relative to the actor size. This neither uses uSize and
 // uPadding.
 float getRelativeEdgeMask(float fadeAmount) {
-  vec2 uv = cogl_tex_coord_in[0].st;
+  vec2 uv = iTexCoord.st;
   return getEdgeMask(uv, vec2(1.0), fadeAmount);
 }
 

resources/shaders/energize-a.frag

@@ -31,7 +31,7 @@ vec2 getMasks(float progress) {
     clamp((progress - (1.0 - HEART_FADE_TIME)) / HEART_FADE_TIME, 0, 1);
 
   // Compute mask for the "atom" particles.
-  float dist     = length(cogl_tex_coord_in[0].st - 0.5) * 4.0;
+  float dist     = length(iTexCoord.st - 0.5) * 4.0;
   float atomMask = smoothstep(0.0, 1.0, (fadeInProgress * 2.0 - dist + 1.0));
   atomMask *= fadeInProgress;
   atomMask *= smoothstep(1.0, 0.0, fadeOutProgress);
@@ -60,7 +60,7 @@ void main() {
   float progress = easeOutQuad(uProgress);
 
   vec2 masks       = getMasks(progress);
-  vec4 windowColor = texture2D(uTexture, cogl_tex_coord_in[0].st);
+  vec4 windowColor = texture2D(uTexture, iTexCoord.st);
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
   if (windowColor.a > 0) {
@@ -68,10 +68,10 @@ void main() {
   }
 
   // Dissolve window to effect color / transparency.
-  cogl_color_out.rgb = mix(uColor, windowColor.rgb, 0.2 * masks.y + 0.8);
+  oColor.rgb = mix(uColor, windowColor.rgb, 0.2 * masks.y + 0.8);
-  cogl_color_out.a   = windowColor.a * masks.y;
+  oColor.a   = windowColor.a * masks.y;
 
-  vec2 scaledUV = (cogl_tex_coord_in[0].st - 0.5) * (1.0 + 0.1 * progress);
+  vec2 scaledUV = (iTexCoord.st - 0.5) * (1.0 + 0.1 * progress);
   scaledUV /= uScale;
 
   // Add molecule particles.
@@ -86,12 +86,12 @@ void main() {
     particles += 0.5 * pow(0.2 * (1.0 / (1.0 - atoms) - 1.0), 2);
   }
 
-  cogl_color_out.rgb += uColor * particles * masks.x;
+  oColor.rgb += uColor * particles * masks.x;
-  cogl_color_out.a += particles * masks.x;
+  oColor.a += particles * masks.x;
 
   // These are pretty useful for understanding how this works.
-  // cogl_color_out = vec4(masks, 0.0, 1.0);
+  // oColor = vec4(masks, 0.0, 1.0);
-  // cogl_color_out = vec4(vec3(masks.x), 1.0);
+  // oColor = vec4(vec3(masks.x), 1.0);
-  // cogl_color_out = vec4(vec3(masks.y), 1.0);
+  // oColor = vec4(vec3(masks.y), 1.0);
-  // cogl_color_out = vec4(vec3(particles), 1.0);
+  // oColor = vec4(vec3(particles), 1.0);
 }

resources/shaders/energize-b.frag

@@ -32,7 +32,7 @@ vec4 getMasks(float progress) {
   float fadeProgress   = clamp((progress - SHOWER_TIME) / (1.0 - SHOWER_TIME), 0, 1);
 
   // Gradient from top to bottom.
-  float t = cogl_tex_coord_in[0].t;
+  float t = iTexCoord.t;
 
   // A smooth gradient which moves to the bottom within the showerProgress.
   float showerMask =
@@ -77,7 +77,7 @@ void main() {
   float progress = easeOutQuad(uProgress);
 
   vec4 masks       = getMasks(progress);
-  vec4 windowColor = texture2D(uTexture, cogl_tex_coord_in[0].st);
+  vec4 windowColor = texture2D(uTexture, iTexCoord.st);
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
   if (windowColor.a > 0) {
@@ -85,37 +85,37 @@ void main() {
   }
 
   // Dissolve window to effect color / transparency.
-  cogl_color_out.rgb = mix(uColor, windowColor.rgb, 0.5 * masks.w + 0.5);
+  oColor.rgb = mix(uColor, windowColor.rgb, 0.5 * masks.w + 0.5);
-  cogl_color_out.a   = windowColor.a * masks.w;
+  oColor.a   = windowColor.a * masks.w;
 
   // Add leading shower particles.
-  vec2 showerUV = cogl_tex_coord_in[0].st + vec2(0, -0.7 * progress / SHOWER_TIME);
+  vec2 showerUV = iTexCoord.st + vec2(0, -0.7 * progress / SHOWER_TIME);
   showerUV *= 0.02 * uSize / uScale;
   float shower = pow(simplex2D(showerUV), 10.0);
-  cogl_color_out.rgb += uColor * shower * masks.x;
+  oColor.rgb += uColor * shower * masks.x;
-  cogl_color_out.a += shower * masks.x;
+  oColor.a += shower * masks.x;
 
   // Add trailing streak lines.
-  vec2 streakUV = cogl_tex_coord_in[0].st + vec2(0, -progress / SHOWER_TIME);
+  vec2 streakUV = iTexCoord.st + vec2(0, -progress / SHOWER_TIME);
   streakUV *= vec2(0.05 * uSize.x, 0.001 * uSize.y) / uScale;
   float streaks = simplex2DFractal(streakUV) * 0.5;
-  cogl_color_out.rgb += uColor * streaks * masks.y;
+  oColor.rgb += uColor * streaks * masks.y;
-  cogl_color_out.a += streaks * masks.y;
+  oColor.a += streaks * masks.y;
 
   // Add glimmering atoms.
-  vec2 atomUV = cogl_tex_coord_in[0].st + vec2(0, -0.025 * progress / SHOWER_TIME);
+  vec2 atomUV = iTexCoord.st + vec2(0, -0.025 * progress / SHOWER_TIME);
   atomUV *= 0.2 * uSize / uScale;
   float atoms = pow((simplex3D(vec3(atomUV, uTime))), 5.0);
-  cogl_color_out.rgb += uColor * atoms * masks.z;
+  oColor.rgb += uColor * atoms * masks.z;
-  cogl_color_out.a += atoms * masks.z;
+  oColor.a += atoms * masks.z;
 
   // These are pretty useful for understanding how this works.
-  // cogl_color_out = vec4(masks.rgb, 1.0);
+  // oColor = vec4(masks.rgb, 1.0);
-  // cogl_color_out = vec4(vec3(masks.x), 1.0);
+  // oColor = vec4(vec3(masks.x), 1.0);
-  // cogl_color_out = vec4(vec3(masks.y), 1.0);
+  // oColor = vec4(vec3(masks.y), 1.0);
-  // cogl_color_out = vec4(vec3(masks.z), 1.0);
+  // oColor = vec4(vec3(masks.z), 1.0);
-  // cogl_color_out = vec4(vec3(masks.w), 1.0);
+  // oColor = vec4(vec3(masks.w), 1.0);
-  // cogl_color_out = vec4(vec3(shower), 1.0);
+  // oColor = vec4(vec3(shower), 1.0);
-  // cogl_color_out = vec4(vec3(streaks), 1.0);
+  // oColor = vec4(vec3(streaks), 1.0);
-  // cogl_color_out = vec4(vec3(atoms), 1.0);
+  // oColor = vec4(vec3(atoms), 1.0);
 }

resources/shaders/fire.frag

@@ -63,7 +63,7 @@ vec2 effectMask(float hideTime, float fadeWidth, float edgeFadeWidth) {
   float afterBurnProgress = clamp((progress - hideTime) / (1 - hideTime), 0, 1);
 
   // Gradient from top to bottom.
-  float t = cogl_tex_coord_in[0].t * (1 - fadeWidth);
+  float t = iTexCoord.t * (1 - fadeWidth);
 
   // Visible part of the window. Gradually dissolves towards the bottom.
   float windowMask = 1 - clamp((burnProgress - t) / fadeWidth, 0, 1);
@@ -89,7 +89,7 @@ vec2 effectMask(float hideTime, float fadeWidth, float edgeFadeWidth) {
 
 void main() {
   // Get a noise value which moves vertically in time.
-  vec2 uv = cogl_tex_coord_in[0].st * uSize / vec2(400, 600) / uScale;
+  vec2 uv = iTexCoord.st * uSize / vec2(400, 600) / uScale;
   uv.y += uTime * uMovementSpeed;
 
   float noise = u3DNoise ? simplex3DFractal(vec3(uv * 4.0, uTime * uMovementSpeed * 1.5))
@@ -103,21 +103,21 @@ void main() {
   vec4 fire = getFireColor(noise);
 
   // Get the window texture.
-  cogl_color_out = texture2D(uTexture, cogl_tex_coord_in[0].st);
+  oColor = texture2D(uTexture, iTexCoord.st);
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
-  if (cogl_color_out.a > 0) {
+  if (oColor.a > 0) {
-    cogl_color_out.rgb /= cogl_color_out.a;
+    oColor.rgb /= oColor.a;
   }
 
   // Fade the window according to the effect mask.
-  cogl_color_out.a *= effectMask.x;
+  oColor.a *= effectMask.x;
 
   // Add the fire to the window.
-  cogl_color_out = alphaOver(cogl_color_out, fire);
+  oColor = alphaOver(oColor, fire);
 
   // These are pretty useful for understanding how this works.
-  // cogl_color_out = vec4(vec3(noise), 1);
+  // oColor = vec4(vec3(noise), 1);
-  // cogl_color_out = vec4(vec3(effectMask.x), 1);
+  // oColor = vec4(vec3(effectMask.x), 1);
-  // cogl_color_out = vec4(vec3(effectMask.y), 1);
+  // oColor = vec4(vec3(effectMask.y), 1);
 }

resources/shaders/hexagon.frag

@@ -68,7 +68,7 @@ void main() {
 
   // Add some smooth noise to the progress so that not every tile behaves the
   // same.
-  float noise = simplex2D(cogl_tex_coord_in[0].st + uSeed);
+  float noise = simplex2D(iTexCoord.st + uSeed);
   progress    = clamp(mix(noise - 1.0, noise + 1.0, progress), 0.0, 1.0);
 
   // glowProgress fades in in the first half of the animation, tileProgress fades
@@ -77,23 +77,23 @@ void main() {
   float tileProgress = smoothstep(0, 1, clamp((progress - 0.5) / 0.5, 0, 1));
 
   vec2 texScale = 0.1 * uSize / uScale;
-  vec4 hex      = getHexagons(cogl_tex_coord_in[0].st * texScale);
+  vec4 hex      = getHexagons(iTexCoord.st * texScale);
 
   if (tileProgress > hex.z) {
 
     // Crop outer parts of the shrinking tiles.
-    cogl_color_out.a = 0.0;
+    oColor.a = 0.0;
 
   } else {
 
     // Make the tiles shrink by offsetting the texture lookup towards the edge
     // of the cell.
     vec2 lookupOffset = tileProgress * hex.xy / texScale / (1.0 - tileProgress);
-    cogl_color_out    = texture2D(uTexture, cogl_tex_coord_in[0].st + lookupOffset);
+    oColor            = texture2D(uTexture, iTexCoord.st + lookupOffset);
 
     // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
-    if (cogl_color_out.a > 0) {
+    if (oColor.a > 0) {
-      cogl_color_out.rgb /= cogl_color_out.a;
+      oColor.rgb /= oColor.a;
     }
 
     vec4 glow = uGlowColor;
@@ -111,15 +111,15 @@ void main() {
     line.a *= glowProgress;
 
     // Do not add the hexagon lines onto transparent parts of the window.
-    glow *= cogl_color_out.a;
+    glow *= oColor.a;
-    line *= cogl_color_out.a;
+    line *= oColor.a;
 
     if (uAdditiveBlending) {
-      cogl_color_out.rgb += glow.rgb * glow.a;
+      oColor.rgb += glow.rgb * glow.a;
-      cogl_color_out.rgb += line.rgb * line.a;
+      oColor.rgb += line.rgb * line.a;
     } else {
-      cogl_color_out.rgb = mix(cogl_color_out.rgb, glow.rgb, glow.a);
+      oColor.rgb = mix(oColor.rgb, glow.rgb, glow.a);
-      cogl_color_out.rgb = mix(cogl_color_out.rgb, line.rgb, line.a);
+      oColor.rgb = mix(oColor.rgb, line.rgb, line.a);
     }
   }
 }

resources/shaders/matrix.frag

@@ -47,13 +47,13 @@ float getText(vec2 fragCoord) {
 // to one below each drop and to zero above it. This second value is used for fading
 // the window texture.
 vec2 getRain(vec2 fragCoord) {
-  float column = cogl_tex_coord_in[0].x * uSize.x;
+  float column = iTexCoord.x * uSize.x;
   column -= mod(column, uLetterSize);
 
   float delay = fract(sin(column) * 78.233) * mix(0.0, 1.0, uRandomness);
   float speed = fract(cos(column) * 12.989) * mix(0.0, 0.3, uRandomness) + 1.5;
 
-  float distToDrop = (uProgress * 2 - delay) * speed - cogl_tex_coord_in[0].y;
+  float distToDrop = (uProgress * 2 - delay) * speed - iTexCoord.y;
 
   float rainAlpha   = distToDrop >= 0 ? exp(-distToDrop / TRAIL_LENGTH) : 0;
   float windowAlpha = 1 - clamp(uSize.y * distToDrop, 0, FADE_WIDTH) / FADE_WIDTH;
@@ -64,8 +64,8 @@ vec2 getRain(vec2 fragCoord) {
   // Add some variation to the drop start and end position.
   float shorten =
     fract(sin(column + 42.0) * 33.423) * mix(0.0, uOverShoot * 0.25, uRandomness);
-  rainAlpha *= smoothstep(0, 1, clamp(cogl_tex_coord_in[0].y / shorten, 0, 1));
+  rainAlpha *= smoothstep(0, 1, clamp(iTexCoord.y / shorten, 0, 1));
-  rainAlpha *= smoothstep(0, 1, clamp((1.0 - cogl_tex_coord_in[0].y) / shorten, 0, 1));
+  rainAlpha *= smoothstep(0, 1, clamp((1.0 - iTexCoord.y) / shorten, 0, 1));
 
   if (uForOpening) {
     windowAlpha = 1.0 - windowAlpha;
@@ -75,7 +75,7 @@ vec2 getRain(vec2 fragCoord) {
 }
 
 void main() {
-  vec2 coords = cogl_tex_coord_in[0].st;
+  vec2 coords = iTexCoord.st;
   coords.y    = coords.y * (uOverShoot + 1.0) - uOverShoot * 0.5;
 
   // Get a cool matrix effect. See comments for those methods above.
@@ -83,15 +83,15 @@ void main() {
   float textMask = getText(coords);
 
   // Get the window texture.
-  cogl_color_out = texture2D(uTexture, coords);
+  oColor = texture2D(uTexture, coords);
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
-  if (cogl_color_out.a > 0) {
+  if (oColor.a > 0) {
-    cogl_color_out.rgb /= cogl_color_out.a;
+    oColor.rgb /= oColor.a;
   }
 
   // Fade the window according to the effect mask.
-  cogl_color_out.a *= rainMask.y;
+  oColor.a *= rainMask.y;
 
   // This is used to fade out the remaining trails in the end.
   float finalFade =
@@ -101,10 +101,10 @@ void main() {
   // Add the matrix effect to the window.
   vec4 text = vec4(mix(uTrailColor, uTipColor, min(1, pow(rainAlpha + 0.1, 4))),
                    rainAlpha * textMask);
-  cogl_color_out = alphaOver(cogl_color_out, text);
+  oColor    = alphaOver(oColor, text);
 
   // These are pretty useful for understanding how this works.
-  // cogl_color_out = vec4(vec3(textMask), 1);
+  // oColor = vec4(vec3(textMask), 1);
-  // cogl_color_out = vec4(vec3(rainMask.x), 1);
+  // oColor = vec4(vec3(rainMask.x), 1);
-  // cogl_color_out = vec4(vec3(rainMask.y), 1);
+  // oColor = vec4(vec3(rainMask.y), 1);
 }

resources/shaders/snap.frag

@@ -29,16 +29,16 @@ void main() {
   // We simply inverse the progress for opening windows.
   float progress = uForOpening ? uProgress : 1.0 - uProgress;
 
-  float gradient = cogl_tex_coord_in[0].t * ACTOR_SCALE - PADDING;
+  float gradient = iTexCoord.t * ACTOR_SCALE - PADDING;
   progress       = 2.0 - gradient - 2.0 * progress;
-  progress = progress + 0.25 - 0.5 * simplex2D((cogl_tex_coord_in[0].st + uSeed) * 2.0);
+  progress       = progress + 0.25 - 0.5 * simplex2D((iTexCoord.st + uSeed) * 2.0);
   progress       = pow(max(0, progress), 2.0);
 
   // This may help you to understand how this effect works.
-  // cogl_color_out = vec4(progress, 0, 0, 0);
+  // oColor = vec4(progress, 0, 0, 0);
   // return;
 
-  cogl_color_out = vec4(0, 0, 0, 0);
+  oColor = vec4(0, 0, 0, 0);
 
   for (float i = 0; i < DUST_LAYERS; ++i) {
 
@@ -49,7 +49,7 @@ void main() {
     direction      = rotate(direction, angle);
 
     // Flip direction for one side of the window.
-    vec2 coords = cogl_tex_coord_in[0].st * ACTOR_SCALE - PADDING - 0.5;
+    vec2 coords = iTexCoord.st * ACTOR_SCALE - PADDING - 0.5;
     if (getWinding(direction, coords) > 0) {
       direction *= -1;
     }
@@ -93,7 +93,7 @@ void main() {
 
       // Dissolve and blend the layers.
       if (dustMap.x - progress > 0) {
-        cogl_color_out = windowColor;
+        oColor = windowColor;
       }
     }
   }

resources/shaders/trex.frag

@@ -68,10 +68,10 @@ void main() {
   float progress = uForOpening ? 1.0 - easeOutQuad(uProgress) : easeOutQuad(uProgress);
 
   // Warp the texture coordinates to create a blow-up effect.
-  vec2 coords = cogl_tex_coord_in[0].st * 2.0 - 1.0;
+  vec2 coords = iTexCoord.st * 2.0 - 1.0;
   float dist  = length(coords);
   coords      = (coords / dist * pow(dist, 1.0 + uWarpIntensity)) * 0.5 + 0.5;
-  coords      = mix(cogl_tex_coord_in[0].st, coords, progress);
+  coords      = mix(iTexCoord.st, coords, progress);
 
   // Scale down the window according to the warp.
   float scale = 0.5 * uWarpIntensity * (1.0 - progress);
@@ -90,11 +90,11 @@ void main() {
   // Get the window texture. We shift the texture lookup by the local derivative of
   // the claw texture in order to mimic some folding distortion.
   vec2 offset = vec2(dFdx(scratchMap), dFdy(scratchMap)) * progress * 0.5;
-  cogl_color_out = texture2D(uTexture, coords + offset);
+  oColor      = texture2D(uTexture, coords + offset);
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
-  if (cogl_color_out.a > 0) {
+  if (oColor.a > 0) {
-    cogl_color_out.rgb /= cogl_color_out.a;
+    oColor.rgb /= oColor.a;
   }
 
   // Add colorful flashes.
@@ -105,19 +105,19 @@ void main() {
 
   // Hide flashes where there is now window.
   vec4 flash = uFlashColor;
-  flash.a *= flashIntensity * cogl_color_out.a * (1.0 - progress);
+  flash.a *= flashIntensity * oColor.a * (1.0 - progress);
 
   // Hide scratched out parts.
-  cogl_color_out.a *= (scratchMap > progress ? 1 : 0);
+  oColor.a *= (scratchMap > progress ? 1 : 0);
 
   // Add flash color.
-  cogl_color_out = alphaOver(cogl_color_out, flash);
+  oColor = alphaOver(oColor, flash);
 
   // Fade out the remaining shards.
   float fadeProgress = smoothstep(0, 1, (progress - 1.0 + FF_TIME) / FF_TIME);
-  cogl_color_out.a *= sqrt(1 - fadeProgress * fadeProgress);
+  oColor.a *= sqrt(1 - fadeProgress * fadeProgress);
 
   // These are pretty useful for understanding how this works.
-  // cogl_color_out = vec4(vec3(flashIntensity), 1);
+  // oColor = vec4(vec3(flashIntensity), 1);
-  // cogl_color_out = vec4(vec3(scratchMap), 1);
+  // oColor = vec4(vec3(scratchMap), 1);
 }

resources/shaders/tv.frag

@@ -27,7 +27,7 @@ void main() {
 
   // Scale down the window vertically.
   float scale = 1.0 / mix(1.0, SCALING, progress) - 1.0;
-  vec2 coords = cogl_tex_coord_in[0].st;
+  vec2 coords = iTexCoord.st;
   coords.y    = coords.y * (scale + 1.0) - scale * 0.5;
 
   // All of these are in [0..1] during the different stages of the animation.
@@ -54,20 +54,19 @@ void main() {
   // Assemble the final alpha value.
   float mask = tbMask * lrMask * ffMask;
 
-  cogl_color_out = texture2D(uTexture, coords);
+  oColor = texture2D(uTexture, coords);
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
-  if (cogl_color_out.a > 0) {
+  if (oColor.a > 0) {
-    cogl_color_out.rgb /= cogl_color_out.a;
+    oColor.rgb /= oColor.a;
   }
 
-  cogl_color_out.rgb =
+  oColor.rgb = mix(oColor.rgb, uColor * oColor.a, smoothstep(0, 1, progress));
-    mix(cogl_color_out.rgb, uColor * cogl_color_out.a, smoothstep(0, 1, progress));
+  oColor.a *= mask;
-  cogl_color_out.a *= mask;
 
   // These are pretty useful for understanding how this works.
-  // cogl_color_out = vec4(vec3(tbMask), 1);
+  // oColor = vec4(vec3(tbMask), 1);
-  // cogl_color_out = vec4(vec3(lrMask), 1);
+  // oColor = vec4(vec3(lrMask), 1);
-  // cogl_color_out = vec4(vec3(ffMask), 1);
+  // oColor = vec4(vec3(ffMask), 1);
-  // cogl_color_out = vec4(vec3(mask), 1);
+  // oColor = vec4(vec3(mask), 1);
 }

resources/shaders/wisps.frag

@@ -68,18 +68,18 @@ void main() {
 
   // Scale down the window slightly.
   float scale = 1.0 / mix(1.0, SCALING, progress) - 1.0;
-  vec2 coords = cogl_tex_coord_in[0].st * (scale + 1.0) - scale * 0.5;
+  vec2 coords = iTexCoord.st * (scale + 1.0) - scale * 0.5;
 
   // Get the color of the window.
-  cogl_color_out = texture2D(uTexture, coords);
+  oColor = texture2D(uTexture, coords);
 
   // Shell.GLSLEffect uses straight alpha. So we have to convert from premultiplied.
-  if (cogl_color_out.a > 0) {
+  if (oColor.a > 0) {
-    cogl_color_out.rgb /= cogl_color_out.a;
+    oColor.rgb /= oColor.a;
   }
 
   // Compute several layers of moving wisps.
-  vec2 uv = (cogl_tex_coord_in[0].st - 0.5) / mix(1.0, 0.5, progress) + 0.5;
+  vec2 uv = (iTexCoord.st - 0.5) / mix(1.0, 0.5, progress) + 0.5;
   uv /= uScale;
   float wisps = 0;
   for (int i = 0; i < WISPS_LAYERS; ++i) {
@@ -99,15 +99,15 @@ void main() {
   float noise = smoothstep(1.0, 0.0, abs(2.0 * simplex2DFractal(uv * uSize / 250) - 1.0));
   float windowMask = 1.0 - (windowOut < 0.5 ? mix(0.0, noise, windowOut * 2.0)
                                             : mix(noise, 1.0, windowOut * 2.0 - 1.0));
-  cogl_color_out.a *= windowMask * mask;
+  oColor.a *= windowMask * mask;
 
   // Add the wisps.
   vec4 wispColor = wisps * vec4(uColor, min(wispsIn, 1.0 - wispsOut) * mask);
-  cogl_color_out = alphaOver(cogl_color_out, wispColor);
+  oColor         = alphaOver(oColor, wispColor);
 
   // These are pretty useful for understanding how this works.
-  // cogl_color_out = vec4(vec3(windowMask), 1.0);
+  // oColor = vec4(vec3(windowMask), 1.0);
-  // cogl_color_out = vec4(vec3(wisps), 1.0);
+  // oColor = vec4(vec3(wisps), 1.0);
-  // cogl_color_out = vec4(vec3(noise), 1.0);
+  // oColor = vec4(vec3(noise), 1.0);
-  // cogl_color_out = vec4(vec3(mask*min(wispsIn, 1.0 - wispsOut)), 1.0);
+  // oColor = vec4(vec3(mask*min(wispsIn, 1.0 - wispsOut)), 1.0);
 }