@thenick775/mgba-wasm 2.5.0-beta.1 → 2.5.0-beta.2

package/dist/mgba.data

@@ -684,27 +684,34 @@ uniform vec2 ReflectionDistance;
 
 #define M_PI 3.1415926535897932384626433832795
 
+const vec2 CENTER = vec2(0.5, 0.5);
+const float INV_SQRT_HALF = 1.4142135623730951; // 1.0 / sqrt(0.5)
+
 /**
  * Helper to compute backlight bleed intensity
  * for a texCoord input.
  */
 float getLightIntensity(vec2 coord) {
-    vec2 coordCentered = coord - vec2(0.5, 0.5);
-    float coordDistCenter = (
-        length(coordCentered) / sqrt(0.5)
-    );
+    vec2 coordCentered = coord - CENTER;
+
+    // length(coordCentered) / sqrt(0.5) == length(coordCentered) * (1/sqrt(0.5))
+    float coordDistCenter = length(coordCentered) * INV_SQRT_HALF;
+
     vec2 coordQuadrant = vec2(
         1.0 - (1.5 * min(coord.x, 1.0 - coord.x)),
         1.0 - (1.5 * min(coord.y, 1.0 - coord.y))
     );
+
     float lightIntensityEdges = (
         pow(coordQuadrant.x, 5.0) +
         pow(coordQuadrant.y, 5.0)
     );
+
     float lightIntensity = (
         (1.0 - LightSoftness) * lightIntensityEdges +
         LightSoftness * coordDistCenter
     );
+
     return clamp(lightIntensity, 0.0, 1.0);
 }
 
@@ -717,12 +724,17 @@ float getLightIntensity(vec2 coord) {
  */
 vec3 getWhiteVector(float intensity) {
     const float DeformAmount = 0.0025;
-    vec2 texCoordCentered = texCoord - vec2(0.5, 0.5);
+
+    vec2 texCoordCentered = texCoord - CENTER;
     float radians = atan(texCoordCentered.y, texCoordCentered.x);
-    float rot = pow(2.0, 4.0 + floor(6.0 * length(texCoordCentered)));
+
+    float ring = floor(6.0 * length(texCoordCentered));
+    float rot = pow(2.0, 4.0 + ring);
+
     float deformRed = cos(rot * radians + (2.0 / 3.0 * M_PI));
     float deformGreen = cos(rot * radians);
     float deformBlue = cos(rot * radians + (4.0 / 3.0 * M_PI));
+
     return clamp(vec3(
         intensity + (deformRed * DeformAmount),
         intensity + (deformGreen * DeformAmount),
@@ -877,9 +889,11 @@ uniform float SubpixelTabHeight;
  * G: #C1D650 (0.75, 0.84, 0.31)
  * B: #3BCEFF (0.23, 0.81, 1.00)
  */ 
-uniform vec3 SubpixelColorRed; // vec3(1.00, 0.38, 0.22);
+uniform vec3 SubpixelColorRed;   // vec3(1.00, 0.38, 0.22);
 uniform vec3 SubpixelColorGreen; // vec3(0.60, 0.88, 0.30);
-uniform vec3 SubpixelColorBlue; // vec3(0.23, 0.65, 1.00);
+uniform vec3 SubpixelColorBlue;  // vec3(0.23, 0.65, 1.00);
+
+const vec3 ONE = vec3(1.0, 1.0, 1.0);
 
 /**
  * Helper to get luminosity of an RGB color.
@@ -901,13 +915,15 @@ vec3 convertRgbToHcl(in vec3 rgb) {
     float xMax = max(rgb.r, max(rgb.g, rgb.b));
     float c = xMax - xMin;
     float l = getColorLumosity(rgb);
+
     float h = mod((
-        c == 0 ? 0.0 :
+        c == 0.0 ? 0.0 :
         xMax == rgb.r ? ((rgb.g - rgb.b) / c) :
         xMax == rgb.g ? ((rgb.b - rgb.r) / c) + 2.0 :
         xMax == rgb.b ? ((rgb.r - rgb.g) / c) + 4.0 :
         0.0
     ), 6.0);
+
     return vec3(h, c, l);
 }
 
@@ -920,26 +936,24 @@ vec3 convertHclToRgb(in vec3 hcl) {
     float c = hcl.y;
     float l = hcl.z;
     float x = c * (1.0 - abs(mod(h, 2.0) - 1.0));
-    if(h <= 1.0) {
+
+    if (h <= 1.0) {
         rgb = vec3(c, x, 0.0);
-    }
-    else if(h <= 2.0) {
+    } else if (h <= 2.0) {
         rgb = vec3(x, c, 0.0);
-    }
-    else if(h <= 3.0) {
+    } else if (h <= 3.0) {
         rgb = vec3(0.0, c, x);
-    }
-    else if(h <= 4.0) {
+    } else if (h <= 4.0) {
         rgb = vec3(0.0, x, c);
-    }
-    else if(h <= 5.0) {
+    } else if (h <= 5.0) {
         rgb = vec3(x, 0.0, c);
-    }
-    else {
+    } else {
         rgb = vec3(c, 0.0, x);
     }
+
     float lRgb = getColorLumosity(rgb);
     float m = l - lRgb;
+
     return clamp(vec3(m, m, m) + rgb, 0.0, 1.0);
 }
 
@@ -947,11 +961,7 @@ vec3 convertHclToRgb(in vec3 hcl) {
  * Helper to check if a point is contained within
  * a rectangular area.
  */
-bool getPointInRect(
-    vec2 point,
-    vec2 rectTopLeft,
-    vec2 rectBottomRight
-) {
+bool getPointInRect(vec2 point, vec2 rectTopLeft, vec2 rectBottomRight) {
     return (
         point.x >= rectTopLeft.x &&
         point.y >= rectTopLeft.y &&
@@ -967,22 +977,14 @@ bool getPointInRect(
  * distance from the point to the line segment.)
  * Thank you to https://stackoverflow.com/a/1501725
  */
-vec2 getPointLineDistance(
-    vec2 point,
-    vec2 line0,
-    vec2 line1
-) {
+vec2 getPointLineDistance(vec2 point, vec2 line0, vec2 line1) {
     vec2 lineDelta = line0 - line1;
     float lineLengthSq = dot(lineDelta, lineDelta);
-    if(lineLengthSq <= 0) {
+    if (lineLengthSq <= 0.0) {
         return line0 - point;
     }
-    float t = (
-        dot(point - line0, line1 - line0) / lineLengthSq
-    );
-    vec2 projection = (
-        line0 + clamp(t, 0.0, 1.0) * (line1 - line0)
-    );
+    float t = dot(point - line0, line1 - line0) / lineLengthSq;
+    vec2 projection = line0 + clamp(t, 0.0, 1.0) * (line1 - line0);
     return projection - point;
 }
 
@@ -991,40 +993,30 @@ vec2 getPointLineDistance(
  * point to a rectangle.
  * Returns (0, 0) for points within the rectangle.
  */
-vec2 getPointRectDistance(
-    vec2 point,
-    vec2 rectTopLeft,
-    vec2 rectBottomRight
-) {
-    if(getPointInRect(point, rectTopLeft, rectBottomRight)) {
+vec2 getPointRectDistance(vec2 point, vec2 rectTopLeft, vec2 rectBottomRight) {
+    if (getPointInRect(point, rectTopLeft, rectBottomRight)) {
         return vec2(0.0, 0.0);
     }
+
     vec2 rectTopRight = vec2(rectBottomRight.x, rectTopLeft.y);
     vec2 rectBottomLeft = vec2(rectTopLeft.x, rectBottomRight.y);
+
     vec2 v0 = getPointLineDistance(point, rectTopLeft, rectTopRight);
     vec2 v1 = getPointLineDistance(point, rectBottomLeft, rectBottomRight);
     vec2 v2 = getPointLineDistance(point, rectTopLeft, rectBottomLeft);
     vec2 v3 = getPointLineDistance(point, rectTopRight, rectBottomRight);
+
     float v0LengthSq = dot(v0, v0);
     float v1LengthSq = dot(v1, v1);
     float v2LengthSq = dot(v2, v2);
     float v3LengthSq = dot(v3, v3);
-    float minLengthSq = min(
-        min(v0LengthSq, v1LengthSq),
-        min(v2LengthSq, v3LengthSq)
-    );
-    if(minLengthSq == v0LengthSq) {
-        return v0;
-    }
-    else if(minLengthSq == v1LengthSq) {
-        return v1;
-    }
-    else if(minLengthSq == v2LengthSq) {
-        return v2;
-    }
-    else {
-        return v3;
-    }
+
+    float minLengthSq = min(min(v0LengthSq, v1LengthSq), min(v2LengthSq, v3LengthSq));
+
+    if (minLengthSq == v0LengthSq) return v0;
+    if (minLengthSq == v1LengthSq) return v1;
+    if (minLengthSq == v2LengthSq) return v2;
+    return v3;
 }
 
 /**
@@ -1035,33 +1027,28 @@ vec2 getPointRectDistance(
  * corner.
  * Returns (0, 0) for points within the subpixel.
  */
-vec2 getPointSubpixelDistance(
-    vec2 point,
-    vec2 subpixelCenter,
-    vec2 subpixelSizeHalf
-) {
+vec2 getPointSubpixelDistance(vec2 point, vec2 subpixelCenter, vec2 subpixelSizeHalf) {
     float rectLeft = subpixelCenter.x - subpixelSizeHalf.x;
     float rectRight = subpixelCenter.x + subpixelSizeHalf.x;
     float rectTop = subpixelCenter.y - subpixelSizeHalf.y;
     float rectBottom = subpixelCenter.y + subpixelSizeHalf.y;
+
     vec2 offsetLeft = getPointRectDistance(
         point,
         vec2(rectLeft, rectTop + SubpixelTabHeight),
         vec2(subpixelCenter.x, rectBottom)
     );
+
     vec2 offsetRight = getPointRectDistance(
         point,
         vec2(subpixelCenter.x, rectTop),
         vec2(rectRight, rectBottom)
     );
+
     float offsetLeftLengthSq = dot(offsetLeft, offsetLeft);
     float offsetRightLengthSq = dot(offsetRight, offsetRight);
-    if(offsetLeftLengthSq <= offsetRightLengthSq) {
-        return offsetLeft;
-    }
-    else {
-        return offsetRight;
-    }
+
+    return (offsetLeftLengthSq <= offsetRightLengthSq) ? offsetLeft : offsetRight;
 }
 
 /**
@@ -1072,33 +1059,23 @@ vec2 getPointSubpixelDistance(
  * Spread represents the subpixel's horizontal
  * position within the pixel.
  */
-float getSubpixelIntensity(
-    vec2 pixelPosition,
-    float spread
-) {
+float getSubpixelIntensity(vec2 pixelPosition, float spread) {
     vec2 subpixelCenter = vec2(
         0.5 + (spread * SubpixelSpread),
         1.0 - SubpixelVerticalOffset
     );
-    vec2 subpixelSizeHalf = 0.5 * vec2(
-        SubpixelLightWidth,
-        SubpixelLightHeight
-    );
-    vec2 offset = getPointSubpixelDistance(
-        pixelPosition,
-        subpixelCenter,
-        subpixelSizeHalf
-    );
-    if(SubpixelLightGlow <= 0) {
-        return dot(offset, offset) <= 0.0 ? 1.0 : 0.0;
-    }
-    else {
-        float dist = length(offset);
-        float glow = max(0.0,
-            1.0 - (dist / SubpixelLightGlow)
-        );
-        return glow;
+
+    vec2 subpixelSizeHalf = 0.5 * vec2(SubpixelLightWidth, SubpixelLightHeight);
+
+    vec2 offset = getPointSubpixelDistance(pixelPosition, subpixelCenter, subpixelSizeHalf);
+
+    if (SubpixelLightGlow <= 0.0) {
+        return (dot(offset, offset) <= 0.0) ? 1.0 : 0.0;
     }
+
+    float dist = length(offset);
+    float glow = max(0.0, 1.0 - (dist / SubpixelLightGlow));
+    return glow;
 }
 
 /**
@@ -1108,10 +1085,7 @@ float getSubpixelIntensity(
  * more strongly coerced to more accurately represent
  * the underlying pixel color.
  */
-float applySubpixelBleed(
-    float subpixelIntensity,
-    float colorSourceChannel
-) {
+float applySubpixelBleed(float subpixelIntensity, float colorSourceChannel) {
     return subpixelIntensity * (
         SubpixelColorBleed +
         ((1.0 - SubpixelColorBleed) * colorSourceChannel)
@@ -1130,19 +1104,17 @@ void main() {
     ));
     // Determine how much each subpixel's light should
     // affect this fragment.
-    vec2 pixelPosition = (
-        mod(texCoord * texSize * SubpixelScale, 1.0)
-    );
+    vec2 pixelPosition = mod(texCoord * texSize * SubpixelScale, 1.0);
     float subpixelIntensityRed = applySubpixelBleed(
         getSubpixelIntensity(pixelPosition, -1.0),
         colorSourceAdjusted.r
     );
     float subpixelIntensityGreen = applySubpixelBleed(
-        getSubpixelIntensity(pixelPosition, +0.0),
+        getSubpixelIntensity(pixelPosition,  0.0),
         colorSourceAdjusted.g
     );
     float subpixelIntensityBlue = applySubpixelBleed(
-        getSubpixelIntensity(pixelPosition, +1.0),
+        getSubpixelIntensity(pixelPosition,  1.0),
         colorSourceAdjusted.b
     );
     vec3 subpixelLightColor = SubpixelGamma * (
@@ -1151,22 +1123,16 @@ void main() {
         (subpixelIntensityBlue * SubpixelColorBlue)
     );
     // Compute final color
-    vec3 colorResult = clamp(
-        subpixelLightColor * colorSourceAdjusted, 0.0, 1.0
-    );
-    vec3 colorResultBlended = (
+    vec3 colorResult = clamp(subpixelLightColor * colorSourceAdjusted, 0.0, 1.0);
+
+    vec3 colorResultBlended =
         ((1.0 - SubpixelBlendAmount) * colorSourceAdjusted) +
-        (SubpixelBlendAmount * colorResult)
-    );
-    colorResultBlended = BaseColor + (
-        (colorResultBlended * (vec3(1.0, 1.0, 1.0) - BaseColor))
-    );
-    gl_FragColor = vec4(
-        colorResultBlended,
-        1.0
-    );
-}
-This is free and unencumbered software released into the public domain.
+        (SubpixelBlendAmount * colorResult);
+
+    colorResultBlended = BaseColor + (colorResultBlended * (ONE - BaseColor));
+
+    gl_FragColor = vec4(colorResultBlended, 1.0);
+}This is free and unencumbered software released into the public domain.
 
 Anyone is free to copy, modify, publish, use, compile, sell, or
 distribute this software, either in source code form or as a compiled