Stop clamping radial gradient t values to [0.0, 1.0].

pcwalton · pcwalton · commit 6a32f8c055d8 · 2020-07-16T10:30:39.000-07:00
Closes #393.
diff --git a/resources/shaders/gl3/d3d9/tile.fs.glsl b/resources/shaders/gl3/d3d9/tile.fs.glsl
@@ -319,7 +319,7 @@ vec4 filterRadialGradient(vec2 colorTexCoord,
         if(ts . x > ts . y)
             ts = ts . yx;
         float t = ts . x >= 0.0 ? ts . x : ts . y;
-        color = texture(colorTexture, uvOrigin + vec2(clamp(t, 0.0, 1.0), 0.0));
+        color = texture(colorTexture, uvOrigin + vec2(t, 0.0));
     }
 
     return color;
diff --git a/resources/shaders/gl4/d3d11/tile.cs.glsl b/resources/shaders/gl4/d3d11/tile.cs.glsl
@@ -321,7 +321,7 @@ vec4 filterRadialGradient(vec2 colorTexCoord,
         if(ts . x > ts . y)
             ts = ts . yx;
         float t = ts . x >= 0.0 ? ts . x : ts . y;
-        color = texture(colorTexture, uvOrigin + vec2(clamp(t, 0.0, 1.0), 0.0));
+        color = texture(colorTexture, uvOrigin + vec2(t, 0.0));
     }
 
     return color;
diff --git a/resources/shaders/gl4/d3d9/tile.fs.glsl b/resources/shaders/gl4/d3d9/tile.fs.glsl
@@ -319,7 +319,7 @@ vec4 filterRadialGradient(vec2 colorTexCoord,
         if(ts . x > ts . y)
             ts = ts . yx;
         float t = ts . x >= 0.0 ? ts . x : ts . y;
-        color = texture(colorTexture, uvOrigin + vec2(clamp(t, 0.0, 1.0), 0.0));
+        color = texture(colorTexture, uvOrigin + vec2(t, 0.0));
     }
 
     return color;
diff --git a/resources/shaders/metal/d3d11/tile.cs.metal b/resources/shaders/metal/d3d11/tile.cs.metal
@@ -18,7 +18,7 @@ struct bTiles
 
 constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(16u, 4u, 1u);
 
-constant float3 _1082 = {};
+constant float3 _1081 = {};
 
 // Implementation of the GLSL mod() function, which is slightly different than Metal fmod()
 template<typename Tx, typename Ty>
@@ -133,7 +133,7 @@ float4 filterRadialGradient(thread const float2& colorTexCoord, thread const tex
             _595 = ts.y;
         }
         float t = _595;
-        color = colorTexture.sample(colorTextureSmplr, (uvOrigin + float2(fast::clamp(t, 0.0, 1.0), 0.0)), level(0.0));
+        color = colorTexture.sample(colorTextureSmplr, (uvOrigin + float2(t, 0.0)), level(0.0));
     }
     return color;
 }
@@ -146,19 +146,19 @@ float4 filterBlur(thread const float2& colorTexCoord, thread const texture2d<flo
     float3 gaussCoeff = filterParams1.xyz;
     float gaussSum = gaussCoeff.x;
     float4 color = colorTexture.sample(colorTextureSmplr, colorTexCoord, level(0.0)) * gaussCoeff.x;
-    float2 _640 = gaussCoeff.xy * gaussCoeff.yz;
-    gaussCoeff = float3(_640.x, _640.y, gaussCoeff.z);
+    float2 _639 = gaussCoeff.xy * gaussCoeff.yz;
+    gaussCoeff = float3(_639.x, _639.y, gaussCoeff.z);
     for (int i = 1; i <= support; i += 2)
     {
         float gaussPartialSum = gaussCoeff.x;
-        float2 _660 = gaussCoeff.xy * gaussCoeff.yz;
-        gaussCoeff = float3(_660.x, _660.y, gaussCoeff.z);
+        float2 _659 = gaussCoeff.xy * gaussCoeff.yz;
+        gaussCoeff = float3(_659.x, _659.y, gaussCoeff.z);
         gaussPartialSum += gaussCoeff.x;
         float2 srcOffset = srcOffsetScale * (float(i) + (gaussCoeff.x / gaussPartialSum));
         color += ((colorTexture.sample(colorTextureSmplr, (colorTexCoord - srcOffset), level(0.0)) + colorTexture.sample(colorTextureSmplr, (colorTexCoord + srcOffset), level(0.0))) * gaussPartialSum);
         gaussSum += (2.0 * gaussPartialSum);
-        float2 _700 = gaussCoeff.xy * gaussCoeff.yz;
-        gaussCoeff = float3(_700.x, _700.y, gaussCoeff.z);
+        float2 _699 = gaussCoeff.xy * gaussCoeff.yz;
+        gaussCoeff = float3(_699.x, _699.y, gaussCoeff.z);
     }
     return color / float4(gaussSum);
 }
@@ -361,34 +361,34 @@ float3 compositeScreen(thread const float3& destColor, thread const float3& srcC
 static inline __attribute__((always_inline))
 float3 compositeSelect(thread const bool3& cond, thread const float3& ifTrue, thread const float3& ifFalse)
 {
-    float _766;
+    float _765;
     if (cond.x)
     {
-        _766 = ifTrue.x;
+        _765 = ifTrue.x;
     }
     else
     {
-        _766 = ifFalse.x;
+        _765 = ifFalse.x;
     }
-    float _777;
+    float _776;
     if (cond.y)
     {
-        _777 = ifTrue.y;
+        _776 = ifTrue.y;
     }
     else
     {
-        _777 = ifFalse.y;
+        _776 = ifFalse.y;
     }
-    float _788;
+    float _787;
     if (cond.z)
     {
-        _788 = ifTrue.z;
+        _787 = ifTrue.z;
     }
     else
     {
-        _788 = ifFalse.z;
+        _787 = ifFalse.z;
     }
-    return float3(_766, _777, _788);
+    return float3(_765, _776, _787);
 }
 
 static inline __attribute__((always_inline))
@@ -433,16 +433,16 @@ float3 compositeSoftLight(thread const float3& destColor, thread const float3& s
 static inline __attribute__((always_inline))
 float compositeDivide(thread const float& num, thread const float& denom)
 {
-    float _802;
+    float _801;
     if (denom != 0.0)
     {
-        _802 = num / denom;
+        _801 = num / denom;
     }
     else
     {
-        _802 = 0.0;
+        _801 = 0.0;
     }
-    return _802;
+    return _801;
 }
 
 static inline __attribute__((always_inline))
@@ -452,25 +452,25 @@ float3 compositeRGBToHSL(thread const float3& rgb)
     float xMin = fast::min(fast::min(rgb.x, rgb.y), rgb.z);
     float c = v - xMin;
     float l = mix(xMin, v, 0.5);
-    float3 _908;
+    float3 _907;
     if (rgb.x == v)
     {
-        _908 = float3(0.0, rgb.yz);
+        _907 = float3(0.0, rgb.yz);
     }
     else
     {
-        float3 _921;
+        float3 _920;
         if (rgb.y == v)
         {
-            _921 = float3(2.0, rgb.zx);
+            _920 = float3(2.0, rgb.zx);
         }
         else
         {
-            _921 = float3(4.0, rgb.xy);
+            _920 = float3(4.0, rgb.xy);
         }
-        _908 = _921;
+        _907 = _920;
     }
-    float3 terms = _908;
+    float3 terms = _907;
     float param = ((terms.x * c) + terms.y) - terms.z;
     float param_1 = c;
     float h = 1.0471975803375244140625 * compositeDivide(param, param_1);
@@ -642,17 +642,17 @@ float4 calculateColor(thread const float2& fragCoord, thread const texture2d<flo
     float2 param_17 = fragCoord;
     int param_18 = compositeOp;
     color = composite(param_15, destTexture, destTextureSmplr, param_16, param_17, param_18);
-    float3 _1364 = color.xyz * color.w;
-    color = float4(_1364.x, _1364.y, _1364.z, color.w);
+    float3 _1363 = color.xyz * color.w;
+    color = float4(_1363.x, _1363.y, _1363.z, color.w);
     return color;
 }
 
-kernel void main0(constant int2& uFramebufferTileSize [[buffer(3)]], constant int& uLoadAction [[buffer(4)]], constant int2& uTextureMetadataSize [[buffer(7)]], constant float2& uFramebufferSize [[buffer(0)]], constant float2& uTileSize [[buffer(1)]], constant float4& uClearColor [[buffer(5)]], constant float2& uColorTextureSize0 [[buffer(8)]], constant float2& uMaskTextureSize0 [[buffer(9)]], const device bFirstTileMap& _1510 [[buffer(2)]], const device bTiles& _1603 [[buffer(6)]], texture2d<float, access::read_write> uDestImage [[texture(0)]], texture2d<float> uTextureMetadata [[texture(1)]], texture2d<float> uColorTexture0 [[texture(2)]], texture2d<float> uMaskTexture0 [[texture(3)]], texture2d<float> uGammaLUT [[texture(4)]], sampler uTextureMetadataSmplr [[sampler(0)]], sampler uColorTexture0Smplr [[sampler(1)]], sampler uMaskTexture0Smplr [[sampler(2)]], sampler uGammaLUTSmplr [[sampler(3)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]])
+kernel void main0(constant int2& uFramebufferTileSize [[buffer(3)]], constant int& uLoadAction [[buffer(4)]], constant int2& uTextureMetadataSize [[buffer(7)]], constant float2& uFramebufferSize [[buffer(0)]], constant float2& uTileSize [[buffer(1)]], constant float4& uClearColor [[buffer(5)]], constant float2& uColorTextureSize0 [[buffer(8)]], constant float2& uMaskTextureSize0 [[buffer(9)]], const device bFirstTileMap& _1509 [[buffer(2)]], const device bTiles& _1602 [[buffer(6)]], texture2d<float, access::read_write> uDestImage [[texture(0)]], texture2d<float> uTextureMetadata [[texture(1)]], texture2d<float> uColorTexture0 [[texture(2)]], texture2d<float> uMaskTexture0 [[texture(3)]], texture2d<float> uGammaLUT [[texture(4)]], sampler uTextureMetadataSmplr [[sampler(0)]], sampler uColorTexture0Smplr [[sampler(1)]], sampler uMaskTexture0Smplr [[sampler(2)]], sampler uGammaLUTSmplr [[sampler(3)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]])
 {
     int2 tileCoord = int2(gl_WorkGroupID.xy);
     int2 firstTileSubCoord = int2(gl_LocalInvocationID.xy) * int2(1, 4);
     int2 firstFragCoord = (tileCoord * int2(uTileSize)) + firstTileSubCoord;
-    int tileIndex = _1510.iFirstTileMap[tileCoord.x + (uFramebufferTileSize.x * tileCoord.y)];
+    int tileIndex = _1509.iFirstTileMap[tileCoord.x + (uFramebufferTileSize.x * tileCoord.y)];
     if ((tileIndex < 0) && (uLoadAction != 0))
     {
         return;
@@ -685,8 +685,8 @@ kernel void main0(constant int2& uFramebufferTileSize [[buffer(3)]], constant in
         {
             int2 tileSubCoord = firstTileSubCoord + int2(0, subY_1);
             float2 fragCoord = float2(firstFragCoord + int2(0, subY_1)) + float2(0.5);
-            int alphaTileIndex = int(_1603.iTiles[(tileIndex * 4) + 2] << uint(8)) >> 8;
-            uint tileControlWord = _1603.iTiles[(tileIndex * 4) + 3];
+            int alphaTileIndex = int(_1602.iTiles[(tileIndex * 4) + 2] << uint(8)) >> 8;
+            uint tileControlWord = _1602.iTiles[(tileIndex * 4) + 3];
             uint colorEntry = tileControlWord & 65535u;
             int tileCtrl = int((tileControlWord >> uint(16)) & 255u);
             if (alphaTileIndex >= 0)
@@ -726,7 +726,7 @@ kernel void main0(constant int2& uFramebufferTileSize [[buffer(3)]], constant in
             float4 srcColor = calculateColor(param_10, uColorTexture0, uColorTexture0Smplr, uMaskTexture0, uMaskTexture0Smplr, uColorTexture0, uColorTexture0Smplr, uGammaLUT, uGammaLUTSmplr, param_11, param_12, param_13, param_14, param_15, param_16, param_17, param_18, param_19, param_20, param_21);
             destColors[subY_1] = (destColors[subY_1] * (1.0 - srcColor.w)) + srcColor;
         }
-        tileIndex = int(_1603.iTiles[(tileIndex * 4) + 0]);
+        tileIndex = int(_1602.iTiles[(tileIndex * 4) + 0]);
     }
     for (int subY_2 = 0; subY_2 < 4; subY_2++)
     {
diff --git a/resources/shaders/metal/d3d9/tile.fs.metal b/resources/shaders/metal/d3d9/tile.fs.metal
@@ -6,7 +6,7 @@
 
 using namespace metal;
 
-constant float3 _1056 = {};
+constant float3 _1055 = {};
 
 struct main0_out
 {
@@ -85,7 +85,7 @@ float4 filterRadialGradient(thread const float2& colorTexCoord, thread const tex
             _569 = ts.y;
         }
         float t = _569;
-        color = colorTexture.sample(colorTextureSmplr, (uvOrigin + float2(fast::clamp(t, 0.0, 1.0), 0.0)));
+        color = colorTexture.sample(colorTextureSmplr, (uvOrigin + float2(t, 0.0)));
     }
     return color;
 }
@@ -98,19 +98,19 @@ float4 filterBlur(thread const float2& colorTexCoord, thread const texture2d<flo
     float3 gaussCoeff = filterParams1.xyz;
     float gaussSum = gaussCoeff.x;
     float4 color = colorTexture.sample(colorTextureSmplr, colorTexCoord) * gaussCoeff.x;
-    float2 _614 = gaussCoeff.xy * gaussCoeff.yz;
-    gaussCoeff = float3(_614.x, _614.y, gaussCoeff.z);
+    float2 _613 = gaussCoeff.xy * gaussCoeff.yz;
+    gaussCoeff = float3(_613.x, _613.y, gaussCoeff.z);
     for (int i = 1; i <= support; i += 2)
     {
         float gaussPartialSum = gaussCoeff.x;
-        float2 _634 = gaussCoeff.xy * gaussCoeff.yz;
-        gaussCoeff = float3(_634.x, _634.y, gaussCoeff.z);
+        float2 _633 = gaussCoeff.xy * gaussCoeff.yz;
+        gaussCoeff = float3(_633.x, _633.y, gaussCoeff.z);
         gaussPartialSum += gaussCoeff.x;
         float2 srcOffset = srcOffsetScale * (float(i) + (gaussCoeff.x / gaussPartialSum));
         color += ((colorTexture.sample(colorTextureSmplr, (colorTexCoord - srcOffset)) + colorTexture.sample(colorTextureSmplr, (colorTexCoord + srcOffset))) * gaussPartialSum);
         gaussSum += (2.0 * gaussPartialSum);
-        float2 _674 = gaussCoeff.xy * gaussCoeff.yz;
-        gaussCoeff = float3(_674.x, _674.y, gaussCoeff.z);
+        float2 _673 = gaussCoeff.xy * gaussCoeff.yz;
+        gaussCoeff = float3(_673.x, _673.y, gaussCoeff.z);
     }
     return color / float4(gaussSum);
 }
@@ -313,34 +313,34 @@ float3 compositeScreen(thread const float3& destColor, thread const float3& srcC
 static inline __attribute__((always_inline))
 float3 compositeSelect(thread const bool3& cond, thread const float3& ifTrue, thread const float3& ifFalse)
 {
-    float _740;
+    float _739;
     if (cond.x)
     {
-        _740 = ifTrue.x;
+        _739 = ifTrue.x;
     }
     else
     {
-        _740 = ifFalse.x;
+        _739 = ifFalse.x;
     }
-    float _751;
+    float _750;
     if (cond.y)
     {
-        _751 = ifTrue.y;
+        _750 = ifTrue.y;
     }
     else
     {
-        _751 = ifFalse.y;
+        _750 = ifFalse.y;
     }
-    float _762;
+    float _761;
     if (cond.z)
     {
-        _762 = ifTrue.z;
+        _761 = ifTrue.z;
     }
     else
     {
-        _762 = ifFalse.z;
+        _761 = ifFalse.z;
     }
-    return float3(_740, _751, _762);
+    return float3(_739, _750, _761);
 }
 
 static inline __attribute__((always_inline))
@@ -385,16 +385,16 @@ float3 compositeSoftLight(thread const float3& destColor, thread const float3& s
 static inline __attribute__((always_inline))
 float compositeDivide(thread const float& num, thread const float& denom)
 {
-    float _776;
+    float _775;
     if (denom != 0.0)
     {
-        _776 = num / denom;
+        _775 = num / denom;
     }
     else
     {
-        _776 = 0.0;
+        _775 = 0.0;
     }
-    return _776;
+    return _775;
 }
 
 static inline __attribute__((always_inline))
@@ -404,25 +404,25 @@ float3 compositeRGBToHSL(thread const float3& rgb)
     float xMin = fast::min(fast::min(rgb.x, rgb.y), rgb.z);
     float c = v - xMin;
     float l = mix(xMin, v, 0.5);
-    float3 _882;
+    float3 _881;
     if (rgb.x == v)
     {
-        _882 = float3(0.0, rgb.yz);
+        _881 = float3(0.0, rgb.yz);
     }
     else
     {
-        float3 _895;
+        float3 _894;
         if (rgb.y == v)
         {
-            _895 = float3(2.0, rgb.zx);
+            _894 = float3(2.0, rgb.zx);
         }
         else
         {
-            _895 = float3(4.0, rgb.xy);
+            _894 = float3(4.0, rgb.xy);
         }
-        _882 = _895;
+        _881 = _894;
     }
-    float3 terms = _882;
+    float3 terms = _881;
     float param = ((terms.x * c) + terms.y) - terms.z;
     float param_1 = c;
     float h = 1.0471975803375244140625 * compositeDivide(param, param_1);
@@ -594,8 +594,8 @@ float4 calculateColor(thread const float2& fragCoord, thread const texture2d<flo
     float2 param_17 = fragCoord;
     int param_18 = compositeOp;
     color = composite(param_15, destTexture, destTextureSmplr, param_16, param_17, param_18);
-    float3 _1340 = color.xyz * color.w;
-    color = float4(_1340.x, _1340.y, _1340.z, color.w);
+    float3 _1339 = color.xyz * color.w;
+    color = float4(_1339.x, _1339.y, _1339.z, color.w);
     return color;
 }
 
diff --git a/shaders/tile_fragment.inc.glsl b/shaders/tile_fragment.inc.glsl
@@ -296,7 +296,7 @@ vec4 filterRadialGradient(vec2 colorTexCoord,
         if (ts.x > ts.y)
             ts = ts.yx;
         float t = ts.x >= 0.0 ? ts.x : ts.y;
-        color = texture(colorTexture, uvOrigin + vec2(clamp(t, 0.0, 1.0), 0.0));
+        color = texture(colorTexture, uvOrigin + vec2(t, 0.0));
     }
 
     return color;

Original file line number	Diff line number	Diff line change
`@@ -319,7 +319,7 @@ vec4 filterRadialGradient(vec2 colorTexCoord,`
`319`	`319`	`if(ts . x > ts . y)`
`320`	`320`	`ts = ts . yx;`
`321`	`321`	`float t = ts . x >= 0.0 ? ts . x : ts . y;`
`322`		`- color = texture(colorTexture, uvOrigin + vec2(clamp(t, 0.0, 1.0), 0.0));`
	`322`	`+ color = texture(colorTexture, uvOrigin + vec2(t, 0.0));`
`323`	`323`	`}`
`324`	`324`
`325`	`325`	`return color;`
Original file line number	Diff line number	Diff line change
`@@ -321,7 +321,7 @@ vec4 filterRadialGradient(vec2 colorTexCoord,`
`321`	`321`	`if(ts . x > ts . y)`
`322`	`322`	`ts = ts . yx;`
`323`	`323`	`float t = ts . x >= 0.0 ? ts . x : ts . y;`
`324`		`- color = texture(colorTexture, uvOrigin + vec2(clamp(t, 0.0, 1.0), 0.0));`
	`324`	`+ color = texture(colorTexture, uvOrigin + vec2(t, 0.0));`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`return color;`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ struct bTiles`
`18`	`18`
`19`	`19`	`constant uint3 gl_WorkGroupSize [[maybe_unused]] = uint3(16u, 4u, 1u);`
`20`	`20`
`21`		`-constant float3 _1082 = {};`
	`21`	`+constant float3 _1081 = {};`
`22`	`22`
`23`	`23`	`// Implementation of the GLSL mod() function, which is slightly different than Metal fmod()`
`24`	`24`	`template<typename Tx, typename Ty>`
`@@ -133,7 +133,7 @@ float4 filterRadialGradient(thread const float2& colorTexCoord, thread const tex`
`133`	`133`	`_595 = ts.y;`
`134`	`134`	`}`
`135`	`135`	`float t = _595;`
`136`		`- color = colorTexture.sample(colorTextureSmplr, (uvOrigin + float2(fast::clamp(t, 0.0, 1.0), 0.0)), level(0.0));`
	`136`	`+ color = colorTexture.sample(colorTextureSmplr, (uvOrigin + float2(t, 0.0)), level(0.0));`
`137`	`137`	`}`
`138`	`138`	`return color;`
`139`	`139`	`}`
`@@ -146,19 +146,19 @@ float4 filterBlur(thread const float2& colorTexCoord, thread const texture2d<flo`
`146`	`146`	`float3 gaussCoeff = filterParams1.xyz;`
`147`	`147`	`float gaussSum = gaussCoeff.x;`
`148`	`148`	`float4 color = colorTexture.sample(colorTextureSmplr, colorTexCoord, level(0.0)) * gaussCoeff.x;`
`149`		`- float2 _640 = gaussCoeff.xy * gaussCoeff.yz;`
`150`		`- gaussCoeff = float3(_640.x, _640.y, gaussCoeff.z);`
	`149`	`+ float2 _639 = gaussCoeff.xy * gaussCoeff.yz;`
	`150`	`+ gaussCoeff = float3(_639.x, _639.y, gaussCoeff.z);`
`151`	`151`	`for (int i = 1; i <= support; i += 2)`
`152`	`152`	`{`
`153`	`153`	`float gaussPartialSum = gaussCoeff.x;`
`154`		`- float2 _660 = gaussCoeff.xy * gaussCoeff.yz;`
`155`		`- gaussCoeff = float3(_660.x, _660.y, gaussCoeff.z);`
	`154`	`+ float2 _659 = gaussCoeff.xy * gaussCoeff.yz;`
	`155`	`+ gaussCoeff = float3(_659.x, _659.y, gaussCoeff.z);`
`156`	`156`	`gaussPartialSum += gaussCoeff.x;`
`157`	`157`	`float2 srcOffset = srcOffsetScale * (float(i) + (gaussCoeff.x / gaussPartialSum));`
`158`	`158`	`color += ((colorTexture.sample(colorTextureSmplr, (colorTexCoord - srcOffset), level(0.0)) + colorTexture.sample(colorTextureSmplr, (colorTexCoord + srcOffset), level(0.0))) * gaussPartialSum);`
`159`	`159`	`gaussSum += (2.0 * gaussPartialSum);`
`160`		`- float2 _700 = gaussCoeff.xy * gaussCoeff.yz;`
`161`		`- gaussCoeff = float3(_700.x, _700.y, gaussCoeff.z);`
	`160`	`+ float2 _699 = gaussCoeff.xy * gaussCoeff.yz;`
	`161`	`+ gaussCoeff = float3(_699.x, _699.y, gaussCoeff.z);`
`162`	`162`	`}`
`163`	`163`	`return color / float4(gaussSum);`
`164`	`164`	`}`
`@@ -361,34 +361,34 @@ float3 compositeScreen(thread const float3& destColor, thread const float3& srcC`
`361`	`361`	`static inline __attribute__((always_inline))`
`362`	`362`	`float3 compositeSelect(thread const bool3& cond, thread const float3& ifTrue, thread const float3& ifFalse)`
`363`	`363`	`{`
`364`		`- float _766;`
	`364`	`+ float _765;`
`365`	`365`	`if (cond.x)`
`366`	`366`	`{`
`367`		`- _766 = ifTrue.x;`
	`367`	`+ _765 = ifTrue.x;`
`368`	`368`	`}`
`369`	`369`	`else`
`370`	`370`	`{`
`371`		`- _766 = ifFalse.x;`
	`371`	`+ _765 = ifFalse.x;`
`372`	`372`	`}`
`373`		`- float _777;`
	`373`	`+ float _776;`
`374`	`374`	`if (cond.y)`
`375`	`375`	`{`
`376`		`- _777 = ifTrue.y;`
	`376`	`+ _776 = ifTrue.y;`
`377`	`377`	`}`
`378`	`378`	`else`
`379`	`379`	`{`
`380`		`- _777 = ifFalse.y;`
	`380`	`+ _776 = ifFalse.y;`
`381`	`381`	`}`
`382`		`- float _788;`
	`382`	`+ float _787;`
`383`	`383`	`if (cond.z)`
`384`	`384`	`{`
`385`		`- _788 = ifTrue.z;`
	`385`	`+ _787 = ifTrue.z;`
`386`	`386`	`}`
`387`	`387`	`else`
`388`	`388`	`{`
`389`		`- _788 = ifFalse.z;`
	`389`	`+ _787 = ifFalse.z;`
`390`	`390`	`}`
`391`		`- return float3(_766, _777, _788);`
	`391`	`+ return float3(_765, _776, _787);`
`392`	`392`	`}`
`393`	`393`
`394`	`394`	`static inline __attribute__((always_inline))`
`@@ -433,16 +433,16 @@ float3 compositeSoftLight(thread const float3& destColor, thread const float3& s`
`433`	`433`	`static inline __attribute__((always_inline))`
`434`	`434`	`float compositeDivide(thread const float& num, thread const float& denom)`
`435`	`435`	`{`
`436`		`- float _802;`
	`436`	`+ float _801;`
`437`	`437`	`if (denom != 0.0)`
`438`	`438`	`{`
`439`		`- _802 = num / denom;`
	`439`	`+ _801 = num / denom;`
`440`	`440`	`}`
`441`	`441`	`else`
`442`	`442`	`{`
`443`		`- _802 = 0.0;`
	`443`	`+ _801 = 0.0;`
`444`	`444`	`}`
`445`		`- return _802;`
	`445`	`+ return _801;`
`446`	`446`	`}`
`447`	`447`
`448`	`448`	`static inline __attribute__((always_inline))`
`@@ -452,25 +452,25 @@ float3 compositeRGBToHSL(thread const float3& rgb)`
`452`	`452`	`float xMin = fast::min(fast::min(rgb.x, rgb.y), rgb.z);`
`453`	`453`	`float c = v - xMin;`
`454`	`454`	`float l = mix(xMin, v, 0.5);`
`455`		`- float3 _908;`
	`455`	`+ float3 _907;`
`456`	`456`	`if (rgb.x == v)`
`457`	`457`	`{`
`458`		`- _908 = float3(0.0, rgb.yz);`
	`458`	`+ _907 = float3(0.0, rgb.yz);`
`459`	`459`	`}`
`460`	`460`	`else`
`461`	`461`	`{`
`462`		`- float3 _921;`
	`462`	`+ float3 _920;`
`463`	`463`	`if (rgb.y == v)`
`464`	`464`	`{`
`465`		`- _921 = float3(2.0, rgb.zx);`
	`465`	`+ _920 = float3(2.0, rgb.zx);`
`466`	`466`	`}`
`467`	`467`	`else`
`468`	`468`	`{`
`469`		`- _921 = float3(4.0, rgb.xy);`
	`469`	`+ _920 = float3(4.0, rgb.xy);`
`470`	`470`	`}`
`471`		`- _908 = _921;`
	`471`	`+ _907 = _920;`
`472`	`472`	`}`
`473`		`- float3 terms = _908;`
	`473`	`+ float3 terms = _907;`
`474`	`474`	`float param = ((terms.x * c) + terms.y) - terms.z;`
`475`	`475`	`float param_1 = c;`
`476`	`476`	`float h = 1.0471975803375244140625 * compositeDivide(param, param_1);`
`@@ -642,17 +642,17 @@ float4 calculateColor(thread const float2& fragCoord, thread const texture2d<flo`
`642`	`642`	`float2 param_17 = fragCoord;`
`643`	`643`	`int param_18 = compositeOp;`
`644`	`644`	`color = composite(param_15, destTexture, destTextureSmplr, param_16, param_17, param_18);`
`645`		`- float3 _1364 = color.xyz * color.w;`
`646`		`- color = float4(_1364.x, _1364.y, _1364.z, color.w);`
	`645`	`+ float3 _1363 = color.xyz * color.w;`
	`646`	`+ color = float4(_1363.x, _1363.y, _1363.z, color.w);`
`647`	`647`	`return color;`
`648`	`648`	`}`
`649`	`649`
`650`		-kernel void main0(constant int2& uFramebufferTileSize [[buffer(3)]], constant int& uLoadAction [[buffer(4)]], constant int2& uTextureMetadataSize [[buffer(7)]], constant float2& uFramebufferSize [[buffer(0)]], constant float2& uTileSize [[buffer(1)]], constant float4& uClearColor [[buffer(5)]], constant float2& uColorTextureSize0 [[buffer(8)]], constant float2& uMaskTextureSize0 [[buffer(9)]], const device bFirstTileMap& _1510 [[buffer(2)]], const device bTiles& _1603 [[buffer(6)]], texture2d<float, access::read_write> uDestImage [[texture(0)]], texture2d<float> uTextureMetadata [[texture(1)]], texture2d<float> uColorTexture0 [[texture(2)]], texture2d<float> uMaskTexture0 [[texture(3)]], texture2d<float> uGammaLUT [[texture(4)]], sampler uTextureMetadataSmplr [[sampler(0)]], sampler uColorTexture0Smplr [[sampler(1)]], sampler uMaskTexture0Smplr [[sampler(2)]], sampler uGammaLUTSmplr [[sampler(3)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]])
	`650`	+kernel void main0(constant int2& uFramebufferTileSize [[buffer(3)]], constant int& uLoadAction [[buffer(4)]], constant int2& uTextureMetadataSize [[buffer(7)]], constant float2& uFramebufferSize [[buffer(0)]], constant float2& uTileSize [[buffer(1)]], constant float4& uClearColor [[buffer(5)]], constant float2& uColorTextureSize0 [[buffer(8)]], constant float2& uMaskTextureSize0 [[buffer(9)]], const device bFirstTileMap& _1509 [[buffer(2)]], const device bTiles& _1602 [[buffer(6)]], texture2d<float, access::read_write> uDestImage [[texture(0)]], texture2d<float> uTextureMetadata [[texture(1)]], texture2d<float> uColorTexture0 [[texture(2)]], texture2d<float> uMaskTexture0 [[texture(3)]], texture2d<float> uGammaLUT [[texture(4)]], sampler uTextureMetadataSmplr [[sampler(0)]], sampler uColorTexture0Smplr [[sampler(1)]], sampler uMaskTexture0Smplr [[sampler(2)]], sampler uGammaLUTSmplr [[sampler(3)]], uint3 gl_WorkGroupID [[threadgroup_position_in_grid]], uint3 gl_LocalInvocationID [[thread_position_in_threadgroup]])
`651`	`651`	`{`
`652`	`652`	`int2 tileCoord = int2(gl_WorkGroupID.xy);`
`653`	`653`	`int2 firstTileSubCoord = int2(gl_LocalInvocationID.xy) * int2(1, 4);`
`654`	`654`	`int2 firstFragCoord = (tileCoord * int2(uTileSize)) + firstTileSubCoord;`
`655`		`- int tileIndex = _1510.iFirstTileMap[tileCoord.x + (uFramebufferTileSize.x * tileCoord.y)];`
	`655`	`+ int tileIndex = _1509.iFirstTileMap[tileCoord.x + (uFramebufferTileSize.x * tileCoord.y)];`
`656`	`656`	`if ((tileIndex < 0) && (uLoadAction != 0))`
`657`	`657`	`{`
`658`	`658`	`return;`
`@@ -685,8 +685,8 @@ kernel void main0(constant int2& uFramebufferTileSize [[buffer(3)]], constant in`
`685`	`685`	`{`
`686`	`686`	`int2 tileSubCoord = firstTileSubCoord + int2(0, subY_1);`
`687`	`687`	`float2 fragCoord = float2(firstFragCoord + int2(0, subY_1)) + float2(0.5);`
`688`		`- int alphaTileIndex = int(_1603.iTiles[(tileIndex * 4) + 2] << uint(8)) >> 8;`
`689`		`- uint tileControlWord = _1603.iTiles[(tileIndex * 4) + 3];`
	`688`	`+ int alphaTileIndex = int(_1602.iTiles[(tileIndex * 4) + 2] << uint(8)) >> 8;`
	`689`	`+ uint tileControlWord = _1602.iTiles[(tileIndex * 4) + 3];`
`690`	`690`	`uint colorEntry = tileControlWord & 65535u;`
`691`	`691`	`int tileCtrl = int((tileControlWord >> uint(16)) & 255u);`
`692`	`692`	`if (alphaTileIndex >= 0)`
`@@ -726,7 +726,7 @@ kernel void main0(constant int2& uFramebufferTileSize [[buffer(3)]], constant in`
`726`	`726`	`float4 srcColor = calculateColor(param_10, uColorTexture0, uColorTexture0Smplr, uMaskTexture0, uMaskTexture0Smplr, uColorTexture0, uColorTexture0Smplr, uGammaLUT, uGammaLUTSmplr, param_11, param_12, param_13, param_14, param_15, param_16, param_17, param_18, param_19, param_20, param_21);`
`727`	`727`	`destColors[subY_1] = (destColors[subY_1] * (1.0 - srcColor.w)) + srcColor;`
`728`	`728`	`}`
`729`		`- tileIndex = int(_1603.iTiles[(tileIndex * 4) + 0]);`
	`729`	`+ tileIndex = int(_1602.iTiles[(tileIndex * 4) + 0]);`
`730`	`730`	`}`
`731`	`731`	`for (int subY_2 = 0; subY_2 < 4; subY_2++)`
`732`	`732`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`
`7`	`7`	`using namespace metal;`
`8`	`8`
`9`		`-constant float3 _1056 = {};`
	`9`	`+constant float3 _1055 = {};`
`10`	`10`
`11`	`11`	`struct main0_out`
`12`	`12`	`{`
`@@ -85,7 +85,7 @@ float4 filterRadialGradient(thread const float2& colorTexCoord, thread const tex`
`85`	`85`	`_569 = ts.y;`
`86`	`86`	`}`
`87`	`87`	`float t = _569;`
`88`		`- color = colorTexture.sample(colorTextureSmplr, (uvOrigin + float2(fast::clamp(t, 0.0, 1.0), 0.0)));`
	`88`	`+ color = colorTexture.sample(colorTextureSmplr, (uvOrigin + float2(t, 0.0)));`
`89`	`89`	`}`
`90`	`90`	`return color;`
`91`	`91`	`}`
`@@ -98,19 +98,19 @@ float4 filterBlur(thread const float2& colorTexCoord, thread const texture2d<flo`
`98`	`98`	`float3 gaussCoeff = filterParams1.xyz;`
`99`	`99`	`float gaussSum = gaussCoeff.x;`
`100`	`100`	`float4 color = colorTexture.sample(colorTextureSmplr, colorTexCoord) * gaussCoeff.x;`
`101`		`- float2 _614 = gaussCoeff.xy * gaussCoeff.yz;`
`102`		`- gaussCoeff = float3(_614.x, _614.y, gaussCoeff.z);`
	`101`	`+ float2 _613 = gaussCoeff.xy * gaussCoeff.yz;`
	`102`	`+ gaussCoeff = float3(_613.x, _613.y, gaussCoeff.z);`
`103`	`103`	`for (int i = 1; i <= support; i += 2)`
`104`	`104`	`{`
`105`	`105`	`float gaussPartialSum = gaussCoeff.x;`
`106`		`- float2 _634 = gaussCoeff.xy * gaussCoeff.yz;`
`107`		`- gaussCoeff = float3(_634.x, _634.y, gaussCoeff.z);`
	`106`	`+ float2 _633 = gaussCoeff.xy * gaussCoeff.yz;`
	`107`	`+ gaussCoeff = float3(_633.x, _633.y, gaussCoeff.z);`
`108`	`108`	`gaussPartialSum += gaussCoeff.x;`
`109`	`109`	`float2 srcOffset = srcOffsetScale * (float(i) + (gaussCoeff.x / gaussPartialSum));`
`110`	`110`	`color += ((colorTexture.sample(colorTextureSmplr, (colorTexCoord - srcOffset)) + colorTexture.sample(colorTextureSmplr, (colorTexCoord + srcOffset))) * gaussPartialSum);`
`111`	`111`	`gaussSum += (2.0 * gaussPartialSum);`
`112`		`- float2 _674 = gaussCoeff.xy * gaussCoeff.yz;`
`113`		`- gaussCoeff = float3(_674.x, _674.y, gaussCoeff.z);`
	`112`	`+ float2 _673 = gaussCoeff.xy * gaussCoeff.yz;`
	`113`	`+ gaussCoeff = float3(_673.x, _673.y, gaussCoeff.z);`
`114`	`114`	`}`
`115`	`115`	`return color / float4(gaussSum);`
`116`	`116`	`}`
`@@ -313,34 +313,34 @@ float3 compositeScreen(thread const float3& destColor, thread const float3& srcC`
`313`	`313`	`static inline __attribute__((always_inline))`
`314`	`314`	`float3 compositeSelect(thread const bool3& cond, thread const float3& ifTrue, thread const float3& ifFalse)`
`315`	`315`	`{`
`316`		`- float _740;`
	`316`	`+ float _739;`
`317`	`317`	`if (cond.x)`
`318`	`318`	`{`
`319`		`- _740 = ifTrue.x;`
	`319`	`+ _739 = ifTrue.x;`
`320`	`320`	`}`
`321`	`321`	`else`
`322`	`322`	`{`
`323`		`- _740 = ifFalse.x;`
	`323`	`+ _739 = ifFalse.x;`
`324`	`324`	`}`
`325`		`- float _751;`
	`325`	`+ float _750;`
`326`	`326`	`if (cond.y)`
`327`	`327`	`{`
`328`		`- _751 = ifTrue.y;`
	`328`	`+ _750 = ifTrue.y;`
`329`	`329`	`}`
`330`	`330`	`else`
`331`	`331`	`{`
`332`		`- _751 = ifFalse.y;`
	`332`	`+ _750 = ifFalse.y;`
`333`	`333`	`}`
`334`		`- float _762;`
	`334`	`+ float _761;`
`335`	`335`	`if (cond.z)`
`336`	`336`	`{`
`337`		`- _762 = ifTrue.z;`
	`337`	`+ _761 = ifTrue.z;`
`338`	`338`	`}`
`339`	`339`	`else`
`340`	`340`	`{`
`341`		`- _762 = ifFalse.z;`
	`341`	`+ _761 = ifFalse.z;`
`342`	`342`	`}`
`343`		`- return float3(_740, _751, _762);`
	`343`	`+ return float3(_739, _750, _761);`
`344`	`344`	`}`
`345`	`345`
`346`	`346`	`static inline __attribute__((always_inline))`
`@@ -385,16 +385,16 @@ float3 compositeSoftLight(thread const float3& destColor, thread const float3& s`
`385`	`385`	`static inline __attribute__((always_inline))`
`386`	`386`	`float compositeDivide(thread const float& num, thread const float& denom)`
`387`	`387`	`{`
`388`		`- float _776;`
	`388`	`+ float _775;`
`389`	`389`	`if (denom != 0.0)`
`390`	`390`	`{`
`391`		`- _776 = num / denom;`
	`391`	`+ _775 = num / denom;`
`392`	`392`	`}`
`393`	`393`	`else`
`394`	`394`	`{`
`395`		`- _776 = 0.0;`
	`395`	`+ _775 = 0.0;`
`396`	`396`	`}`
`397`		`- return _776;`
	`397`	`+ return _775;`
`398`	`398`	`}`
`399`	`399`
`400`	`400`	`static inline __attribute__((always_inline))`
`@@ -404,25 +404,25 @@ float3 compositeRGBToHSL(thread const float3& rgb)`
`404`	`404`	`float xMin = fast::min(fast::min(rgb.x, rgb.y), rgb.z);`
`405`	`405`	`float c = v - xMin;`
`406`	`406`	`float l = mix(xMin, v, 0.5);`
`407`		`- float3 _882;`
	`407`	`+ float3 _881;`
`408`	`408`	`if (rgb.x == v)`
`409`	`409`	`{`
`410`		`- _882 = float3(0.0, rgb.yz);`
	`410`	`+ _881 = float3(0.0, rgb.yz);`
`411`	`411`	`}`
`412`	`412`	`else`
`413`	`413`	`{`
`414`		`- float3 _895;`
	`414`	`+ float3 _894;`
`415`	`415`	`if (rgb.y == v)`
`416`	`416`	`{`
`417`		`- _895 = float3(2.0, rgb.zx);`
	`417`	`+ _894 = float3(2.0, rgb.zx);`
`418`	`418`	`}`
`419`	`419`	`else`
`420`	`420`	`{`
`421`		`- _895 = float3(4.0, rgb.xy);`
	`421`	`+ _894 = float3(4.0, rgb.xy);`
`422`	`422`	`}`
`423`		`- _882 = _895;`
	`423`	`+ _881 = _894;`
`424`	`424`	`}`
`425`		`- float3 terms = _882;`
	`425`	`+ float3 terms = _881;`
`426`	`426`	`float param = ((terms.x * c) + terms.y) - terms.z;`
`427`	`427`	`float param_1 = c;`
`428`	`428`	`float h = 1.0471975803375244140625 * compositeDivide(param, param_1);`
`@@ -594,8 +594,8 @@ float4 calculateColor(thread const float2& fragCoord, thread const texture2d<flo`
`594`	`594`	`float2 param_17 = fragCoord;`
`595`	`595`	`int param_18 = compositeOp;`
`596`	`596`	`color = composite(param_15, destTexture, destTextureSmplr, param_16, param_17, param_18);`
`597`		`- float3 _1340 = color.xyz * color.w;`
`598`		`- color = float4(_1340.x, _1340.y, _1340.z, color.w);`
	`597`	`+ float3 _1339 = color.xyz * color.w;`
	`598`	`+ color = float4(_1339.x, _1339.y, _1339.z, color.w);`
`599`	`599`	`return color;`
`600`	`600`	`}`
`601`	`601`
Original file line number	Diff line number	Diff line change
`@@ -296,7 +296,7 @@ vec4 filterRadialGradient(vec2 colorTexCoord,`
`296`	`296`	`if (ts.x > ts.y)`
`297`	`297`	`ts = ts.yx;`
`298`	`298`	`float t = ts.x >= 0.0 ? ts.x : ts.y;`
`299`		`- color = texture(colorTexture, uvOrigin + vec2(clamp(t, 0.0, 1.0), 0.0));`
	`299`	`+ color = texture(colorTexture, uvOrigin + vec2(t, 0.0));`
`300`	`300`	`}`
`301`	`301`
`302`	`302`	`return color;`