@pixagram/renderart 1.0.1 → 1.0.2

package/src/xbrz-gpu.ts

@@ -10,29 +10,22 @@
 
 import type { ImageInput, ImageOutput, Renderer, XbrzOptions } from './types.js';
 
-// Vertex shader
 const VERTEX_SHADER = `#version 300 es
 layout(location = 0) in vec2 position;
 out vec2 vUv;
-
 void main() {
     vUv = position * 0.5 + 0.5;
     gl_Position = vec4(position, 0.0, 1.0);
 }`;
 
-// Fragment shader with xBRZ algorithm
-const FRAGMENT_SHADER = `#version 300 es
+const COMMON_HEADER = `#version 300 es
 precision highp float;
-
 uniform sampler2D uTex;
 uniform vec2 uInputRes;
-uniform vec2 uOutputRes;
-uniform int uScale;
 uniform float uLuminanceWeight;
 uniform float uEqualColorTolerance;
 uniform float uSteepDirectionThreshold;
 uniform float uDominantDirectionThreshold;
-
 in vec2 vUv;
 out vec4 outColor;
 
@@ -40,61 +33,24 @@ out vec4 outColor;
 #define BLEND_NORMAL 1
 #define BLEND_DOMINANT 2
 
-// Sample source texture with clamping
-vec4 tex(vec2 coord) {
-    return texture(uTex, clamp(coord, vec2(0.0), vec2(1.0)));
-}
+vec4 tex(vec2 coord) { return texture(uTex, clamp(coord, vec2(0.0), vec2(1.0))); }
+float reduce(vec3 c) { return dot(c, vec3(65536.0, 256.0, 1.0)); }
 
-// Reduce color to single value for equality comparison
-float reduce(vec3 color) {
-    return dot(color, vec3(65536.0, 256.0, 1.0));
-}
-
-// YCbCr color distance (perceptually weighted)
-float distYCbCr(vec3 pixA, vec3 pixB) {
+float DistYCbCr(vec3 pixA, vec3 pixB) {
     const vec3 w = vec3(0.2627, 0.6780, 0.0593);
     const float scaleB = 0.5 / (1.0 - w.b);
     const float scaleR = 0.5 / (1.0 - w.r);
-    
     vec3 diff = pixA - pixB;
     float Y = dot(diff, w);
     float Cb = scaleB * (diff.b - Y);
     float Cr = scaleR * (diff.r - Y);
-    
     return sqrt((uLuminanceWeight * Y) * (uLuminanceWeight * Y) + Cb * Cb + Cr * Cr);
 }
 
-// Check if two pixels are equal within tolerance
-bool isPixEqual(vec3 pixA, vec3 pixB) {
-    return distYCbCr(pixA, pixB) < uEqualColorTolerance;
-}
-
-// Check if any blending is needed
-bool isBlendingNeeded(ivec4 blend) {
-    return blend.x != BLEND_NONE || blend.y != BLEND_NONE || 
-           blend.z != BLEND_NONE || blend.w != BLEND_NONE;
-}
+bool IsPixEqual(vec3 pixA, vec3 pixB) { return DistYCbCr(pixA, pixB) < uEqualColorTolerance; }
+bool IsBlendingNeeded(ivec4 blend) { return blend.x != 0 || blend.y != 0 || blend.z != 0 || blend.w != 0; }
 
-void main() {
-    vec2 texelSize = 1.0 / uInputRes;
-    
-    // Find which source pixel and sub-pixel position
-    vec2 srcPos = vUv * uInputRes;
-    vec2 srcPixel = floor(srcPos);
-    vec2 f = fract(srcPos);
-    
-    // Sample 5x5 neighborhood
-    // Pixel Mapping:  20|21|22|23|24
-    //                 19|06|07|08|09
-    //                 18|05|00|01|10
-    //                 17|04|03|02|11
-    //                 16|15|14|13|12
-    
-    vec2 tc = (srcPixel + 0.5) * texelSize;
-    float dx = texelSize.x;
-    float dy = texelSize.y;
-    
-    vec3 src[25];
+void sampleNeighborhood(vec2 tc, float dx, float dy, out vec3 src[25], out float v[9]) {
     src[21] = tex(tc + vec2(-dx, -2.0*dy)).rgb;
     src[22] = tex(tc + vec2(  0, -2.0*dy)).rgb;
     src[23] = tex(tc + vec2( dx, -2.0*dy)).rgb;
@@ -116,373 +72,253 @@ void main() {
     src[ 9] = tex(tc + vec2( 2.0*dx,  -dy)).rgb;
     src[10] = tex(tc + vec2( 2.0*dx,    0)).rgb;
     src[11] = tex(tc + vec2( 2.0*dx,   dy)).rgb;
-    
-    // Reduce colors for comparison
-    float v[9];
-    v[0] = reduce(src[0]);
-    v[1] = reduce(src[1]);
-    v[2] = reduce(src[2]);
-    v[3] = reduce(src[3]);
-    v[4] = reduce(src[4]);
-    v[5] = reduce(src[5]);
-    v[6] = reduce(src[6]);
-    v[7] = reduce(src[7]);
-    v[8] = reduce(src[8]);
-    
+    for (int i = 0; i < 9; i++) v[i] = reduce(src[i]);
+}
+
+ivec4 detectCorners(vec3 src[25], float v[9]) {
     ivec4 blendResult = ivec4(BLEND_NONE);
-    
-    // Preprocess corners - determine blend type for each
-    
-    // Corner (1, 1) - bottom-right
+    // Corner (1, 1)
     if (!((v[0] == v[1] && v[3] == v[2]) || (v[0] == v[3] && v[1] == v[2]))) {
-        float dist_03_01 = distYCbCr(src[4], src[0]) + distYCbCr(src[0], src[8]) + 
-                          distYCbCr(src[14], src[2]) + distYCbCr(src[2], src[10]) + 
-                          4.0 * distYCbCr(src[3], src[1]);
-        float dist_00_02 = distYCbCr(src[5], src[3]) + distYCbCr(src[3], src[13]) + 
-                          distYCbCr(src[7], src[1]) + distYCbCr(src[1], src[11]) + 
-                          4.0 * distYCbCr(src[0], src[2]);
-        bool dominantGradient = (uDominantDirectionThreshold * dist_03_01) < dist_00_02;
-        blendResult[2] = ((dist_03_01 < dist_00_02) && (v[0] != v[1]) && (v[0] != v[3])) 
-            ? (dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
+        float dist_03_01 = DistYCbCr(src[4], src[0]) + DistYCbCr(src[0], src[8]) + DistYCbCr(src[14], src[2]) + DistYCbCr(src[2], src[10]) + 4.0 * DistYCbCr(src[3], src[1]);
+        float dist_00_02 = DistYCbCr(src[5], src[3]) + DistYCbCr(src[3], src[13]) + DistYCbCr(src[7], src[1]) + DistYCbCr(src[1], src[11]) + 4.0 * DistYCbCr(src[0], src[2]);
+        bool dominant = (uDominantDirectionThreshold * dist_03_01) < dist_00_02;
+        blendResult[2] = ((dist_03_01 < dist_00_02) && (v[0] != v[1]) && (v[0] != v[3])) ? (dominant ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
     }
-    
-    // Corner (0, 1) - bottom-left
+    // Corner (0, 1)
     if (!((v[5] == v[0] && v[4] == v[3]) || (v[5] == v[4] && v[0] == v[3]))) {
-        float dist_04_00 = distYCbCr(src[17], src[5]) + distYCbCr(src[5], src[7]) + 
-                          distYCbCr(src[15], src[3]) + distYCbCr(src[3], src[1]) + 
-                          4.0 * distYCbCr(src[4], src[0]);
-        float dist_05_03 = distYCbCr(src[18], src[4]) + distYCbCr(src[4], src[14]) + 
-                          distYCbCr(src[6], src[0]) + distYCbCr(src[0], src[2]) + 
-                          4.0 * distYCbCr(src[5], src[3]);
-        bool dominantGradient = (uDominantDirectionThreshold * dist_05_03) < dist_04_00;
-        blendResult[3] = ((dist_04_00 > dist_05_03) && (v[0] != v[5]) && (v[0] != v[3])) 
-            ? (dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
+        float dist_04_00 = DistYCbCr(src[17], src[5]) + DistYCbCr(src[5], src[7]) + DistYCbCr(src[15], src[3]) + DistYCbCr(src[3], src[1]) + 4.0 * DistYCbCr(src[4], src[0]);
+        float dist_05_03 = DistYCbCr(src[18], src[4]) + DistYCbCr(src[4], src[14]) + DistYCbCr(src[6], src[0]) + DistYCbCr(src[0], src[2]) + 4.0 * DistYCbCr(src[5], src[3]);
+        bool dominant = (uDominantDirectionThreshold * dist_05_03) < dist_04_00;
+        blendResult[3] = ((dist_04_00 > dist_05_03) && (v[0] != v[5]) && (v[0] != v[3])) ? (dominant ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
     }
-    
-    // Corner (1, 0) - top-right
+    // Corner (1, 0)
     if (!((v[7] == v[8] && v[0] == v[1]) || (v[7] == v[0] && v[8] == v[1]))) {
-        float dist_00_08 = distYCbCr(src[5], src[7]) + distYCbCr(src[7], src[23]) + 
-                          distYCbCr(src[3], src[1]) + distYCbCr(src[1], src[9]) + 
-                          4.0 * distYCbCr(src[0], src[8]);
-        float dist_07_01 = distYCbCr(src[6], src[0]) + distYCbCr(src[0], src[2]) + 
-                          distYCbCr(src[22], src[8]) + distYCbCr(src[8], src[10]) + 
-                          4.0 * distYCbCr(src[7], src[1]);
-        bool dominantGradient = (uDominantDirectionThreshold * dist_07_01) < dist_00_08;
-        blendResult[1] = ((dist_00_08 > dist_07_01) && (v[0] != v[7]) && (v[0] != v[1])) 
-            ? (dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
+        float dist_00_08 = DistYCbCr(src[5], src[7]) + DistYCbCr(src[7], src[23]) + DistYCbCr(src[3], src[1]) + DistYCbCr(src[1], src[9]) + 4.0 * DistYCbCr(src[0], src[8]);
+        float dist_07_01 = DistYCbCr(src[6], src[0]) + DistYCbCr(src[0], src[2]) + DistYCbCr(src[22], src[8]) + DistYCbCr(src[8], src[10]) + 4.0 * DistYCbCr(src[7], src[1]);
+        bool dominant = (uDominantDirectionThreshold * dist_07_01) < dist_00_08;
+        blendResult[1] = ((dist_00_08 > dist_07_01) && (v[0] != v[7]) && (v[0] != v[1])) ? (dominant ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
     }
-    
-    // Corner (0, 0) - top-left
+    // Corner (0, 0)
     if (!((v[6] == v[7] && v[5] == v[0]) || (v[6] == v[5] && v[7] == v[0]))) {
-        float dist_05_07 = distYCbCr(src[18], src[6]) + distYCbCr(src[6], src[22]) + 
-                          distYCbCr(src[4], src[0]) + distYCbCr(src[0], src[8]) + 
-                          4.0 * distYCbCr(src[5], src[7]);
-        float dist_06_00 = distYCbCr(src[19], src[5]) + distYCbCr(src[5], src[3]) + 
-                          distYCbCr(src[21], src[7]) + distYCbCr(src[7], src[1]) + 
-                          4.0 * distYCbCr(src[6], src[0]);
-        bool dominantGradient = (uDominantDirectionThreshold * dist_05_07) < dist_06_00;
-        blendResult[0] = ((dist_05_07 < dist_06_00) && (v[0] != v[5]) && (v[0] != v[7])) 
-            ? (dominantGradient ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
+        float dist_05_07 = DistYCbCr(src[18], src[6]) + DistYCbCr(src[6], src[22]) + DistYCbCr(src[4], src[0]) + DistYCbCr(src[0], src[8]) + 4.0 * DistYCbCr(src[5], src[7]);
+        float dist_06_00 = DistYCbCr(src[19], src[5]) + DistYCbCr(src[5], src[3]) + DistYCbCr(src[21], src[7]) + DistYCbCr(src[7], src[1]) + 4.0 * DistYCbCr(src[6], src[0]);
+        bool dominant = (uDominantDirectionThreshold * dist_05_07) < dist_06_00;
+        blendResult[0] = ((dist_05_07 < dist_06_00) && (v[0] != v[5]) && (v[0] != v[7])) ? (dominant ? BLEND_DOMINANT : BLEND_NORMAL) : BLEND_NONE;
     }
+    return blendResult;
+}
+`;
+
+// 2x xBRZ fragment shader
+const FRAG_2X = COMMON_HEADER + `
+const float M_PI = 3.1415926535897932384626433832795;
+
+void main() {
+    vec2 texelSize = 1.0 / uInputRes;
+    vec2 srcPos = vUv * uInputRes;
+    vec2 srcPixel = floor(srcPos);
+    vec2 f = fract(srcPos);
+    vec2 tc = (srcPixel + 0.5) * texelSize;
     
-    // Start with center pixel for all output pixels
-    vec3 result = src[0];
+    vec3 src[25]; float v[9];
+    sampleNeighborhood(tc, texelSize.x, texelSize.y, src, v);
+    ivec4 blendResult = detectCorners(src, v);
     
-    if (isBlendingNeeded(blendResult)) {
-        // Scale-dependent blending
-        if (uScale == 2) {
-            // 2x output: 4 pixels per source pixel
-            // Output Mapping: 00|01
-            //                 03|02
-            
-            vec3 dst[4];
-            dst[0] = src[0]; dst[1] = src[0];
-            dst[2] = src[0]; dst[3] = src[0];
-            
-            // Process each corner with rotation
-            for (int rot = 0; rot < 4; rot++) {
-                // Rotated kernel indices
-                int k1, k2, k3, k4, k5, k6, k7, k8;
-                ivec4 blend;
-                
-                if (rot == 0) {
-                    k1 = 1; k2 = 2; k3 = 3; k4 = 4; k5 = 5; k6 = 6; k7 = 7; k8 = 8;
-                    blend = blendResult;
-                } else if (rot == 1) {
-                    k1 = 7; k2 = 8; k3 = 1; k4 = 2; k5 = 3; k6 = 4; k7 = 5; k8 = 6;
-                    blend = blendResult.wxyz;
-                } else if (rot == 2) {
-                    k1 = 5; k2 = 6; k3 = 7; k4 = 8; k5 = 1; k6 = 2; k7 = 3; k8 = 4;
-                    blend = blendResult.zwxy;
-                } else {
-                    k1 = 3; k2 = 4; k3 = 5; k4 = 6; k5 = 7; k6 = 8; k7 = 1; k8 = 2;
-                    blend = blendResult.yzwx;
-                }
-                
-                vec3 k[9];
-                k[0] = src[0];
-                k[1] = (rot == 0) ? src[1] : (rot == 1) ? src[7] : (rot == 2) ? src[5] : src[3];
-                k[2] = (rot == 0) ? src[2] : (rot == 1) ? src[8] : (rot == 2) ? src[6] : src[4];
-                k[3] = (rot == 0) ? src[3] : (rot == 1) ? src[1] : (rot == 2) ? src[7] : src[5];
-                k[4] = (rot == 0) ? src[4] : (rot == 1) ? src[2] : (rot == 2) ? src[8] : src[6];
-                k[5] = (rot == 0) ? src[5] : (rot == 1) ? src[3] : (rot == 2) ? src[1] : src[7];
-                k[6] = (rot == 0) ? src[6] : (rot == 1) ? src[4] : (rot == 2) ? src[2] : src[8];
-                k[7] = (rot == 0) ? src[7] : (rot == 1) ? src[5] : (rot == 2) ? src[3] : src[1];
-                k[8] = (rot == 0) ? src[8] : (rot == 1) ? src[6] : (rot == 2) ? src[4] : src[2];
-                
-                float vk0 = reduce(k[0]);
-                float vk4 = reduce(k[4]);
-                float vk5 = reduce(k[5]);
-                float vk7 = reduce(k[7]);
-                float vk8 = reduce(k[8]);
-                
-                float dist_01_04 = distYCbCr(k[1], k[4]);
-                float dist_03_08 = distYCbCr(k[3], k[8]);
-                bool haveShallowLine = (uSteepDirectionThreshold * dist_01_04 <= dist_03_08) && (vk0 != vk4) && (vk5 != vk4);
-                bool haveSteepLine = (uSteepDirectionThreshold * dist_03_08 <= dist_01_04) && (vk0 != vk8) && (vk7 != vk8);
-                bool needBlend = (blend[2] != BLEND_NONE);
-                bool doLineBlend = blend[2] >= BLEND_DOMINANT ||
-                    !((blend[1] != BLEND_NONE && !isPixEqual(k[0], k[4])) ||
-                      (blend[3] != BLEND_NONE && !isPixEqual(k[0], k[8])) ||
-                      (isPixEqual(k[4], k[3]) && isPixEqual(k[3], k[2]) && 
-                       isPixEqual(k[2], k[1]) && isPixEqual(k[1], k[8]) && !isPixEqual(k[0], k[2])));
-                
-                vec3 blendPix = (distYCbCr(k[0], k[1]) <= distYCbCr(k[0], k[3])) ? k[1] : k[3];
-                
-                const float PI = 3.14159265359;
-                
-                // Apply blends to rotated destination
-                int d1 = (rot == 0) ? 1 : (rot == 1) ? 0 : (rot == 2) ? 3 : 2;
-                int d2 = (rot == 0) ? 2 : (rot == 1) ? 1 : (rot == 2) ? 0 : 3;
-                int d3 = (rot == 0) ? 3 : (rot == 1) ? 2 : (rot == 2) ? 1 : 0;
-                
-                float blend1 = (needBlend && doLineBlend && haveSteepLine) ? 0.25 : 0.0;
-                float blend2 = needBlend ? (doLineBlend ? 
-                    (haveShallowLine ? (haveSteepLine ? 5.0/6.0 : 0.75) : (haveSteepLine ? 0.75 : 0.5)) 
-                    : (1.0 - PI/4.0)) : 0.0;
-                float blend3 = (needBlend && doLineBlend && haveShallowLine) ? 0.25 : 0.0;
-                
-                dst[d1] = mix(dst[d1], blendPix, blend1);
-                dst[d2] = mix(dst[d2], blendPix, blend2);
-                dst[d3] = mix(dst[d3], blendPix, blend3);
-            }
-            
-            // Select output pixel based on sub-pixel position
-            result = mix(mix(dst[0], dst[1], step(0.5, f.x)),
-                        mix(dst[3], dst[2], step(0.5, f.x)), step(0.5, f.y));
-                        
-        } else if (uScale == 3) {
-            // 3x output: 9 pixels per source pixel
-            vec3 dst[9];
-            for (int i = 0; i < 9; i++) dst[i] = src[0];
+    vec3 dst[4];
+    dst[0] = src[0]; dst[1] = src[0]; dst[2] = src[0]; dst[3] = src[0];
+    
+    if (IsBlendingNeeded(blendResult)) {
+        // Process all 4 corners
+        for (int corner = 0; corner < 4; corner++) {
+            vec3 k1, k3, k4, k5, k7, k8;
+            int blendIdx;
+            if (corner == 0) { k1=src[1]; k3=src[3]; k4=src[4]; k5=src[5]; k7=src[7]; k8=src[8]; blendIdx=2; }
+            else if (corner == 1) { k1=src[7]; k3=src[1]; k4=src[2]; k5=src[3]; k7=src[5]; k8=src[6]; blendIdx=1; }
+            else if (corner == 2) { k1=src[5]; k3=src[7]; k4=src[8]; k5=src[1]; k7=src[3]; k8=src[4]; blendIdx=0; }
+            else { k1=src[3]; k3=src[5]; k4=src[6]; k5=src[7]; k7=src[1]; k8=src[2]; blendIdx=3; }
             
-            // Process all 4 corners with rotation
-            for (int rot = 0; rot < 4; rot++) {
-                ivec4 blend = (rot == 0) ? blendResult : 
-                             (rot == 1) ? blendResult.wxyz :
-                             (rot == 2) ? blendResult.zwxy : blendResult.yzwx;
-                
-                vec3 k[9];
-                k[0] = src[0];
-                k[1] = (rot == 0) ? src[1] : (rot == 1) ? src[7] : (rot == 2) ? src[5] : src[3];
-                k[2] = (rot == 0) ? src[2] : (rot == 1) ? src[8] : (rot == 2) ? src[6] : src[4];
-                k[3] = (rot == 0) ? src[3] : (rot == 1) ? src[1] : (rot == 2) ? src[7] : src[5];
-                k[4] = (rot == 0) ? src[4] : (rot == 1) ? src[2] : (rot == 2) ? src[8] : src[6];
-                k[5] = (rot == 0) ? src[5] : (rot == 1) ? src[3] : (rot == 2) ? src[1] : src[7];
-                k[6] = (rot == 0) ? src[6] : (rot == 1) ? src[4] : (rot == 2) ? src[2] : src[8];
-                k[7] = (rot == 0) ? src[7] : (rot == 1) ? src[5] : (rot == 2) ? src[3] : src[1];
-                k[8] = (rot == 0) ? src[8] : (rot == 1) ? src[6] : (rot == 2) ? src[4] : src[2];
-                
-                float vk0 = reduce(k[0]);
-                float vk4 = reduce(k[4]);
-                float vk5 = reduce(k[5]);
-                float vk7 = reduce(k[7]);
-                float vk8 = reduce(k[8]);
-                
-                float dist_01_04 = distYCbCr(k[1], k[4]);
-                float dist_03_08 = distYCbCr(k[3], k[8]);
-                bool haveShallowLine = (uSteepDirectionThreshold * dist_01_04 <= dist_03_08) && (vk0 != vk4) && (vk5 != vk4);
-                bool haveSteepLine = (uSteepDirectionThreshold * dist_03_08 <= dist_01_04) && (vk0 != vk8) && (vk7 != vk8);
-                bool needBlend = (blend[2] != BLEND_NONE);
-                bool doLineBlend = blend[2] >= BLEND_DOMINANT ||
-                    !((blend[1] != BLEND_NONE && !isPixEqual(k[0], k[4])) ||
-                      (blend[3] != BLEND_NONE && !isPixEqual(k[0], k[8])) ||
-                      (isPixEqual(k[4], k[3]) && isPixEqual(k[3], k[2]) && 
-                       isPixEqual(k[2], k[1]) && isPixEqual(k[1], k[8]) && !isPixEqual(k[0], k[2])));
-                
-                vec3 blendPix = (distYCbCr(k[0], k[1]) <= distYCbCr(k[0], k[3])) ? k[1] : k[3];
-                
-                // 3x specific blend weights
-                // Output mapping for rot=0:  0|1|2
-                //                            3|4|5
-                //                            6|7|8
-                // Corner is at position 8
-                
-                int idx[4];
-                if (rot == 0) { idx[0] = 5; idx[1] = 8; idx[2] = 7; idx[3] = 2; }
-                else if (rot == 1) { idx[0] = 1; idx[1] = 2; idx[2] = 5; idx[3] = 0; }
-                else if (rot == 2) { idx[0] = 3; idx[1] = 0; idx[2] = 1; idx[3] = 6; }
-                else { idx[0] = 7; idx[1] = 6; idx[2] = 3; idx[3] = 8; }
-                
-                dst[idx[0]] = mix(dst[idx[0]], blendPix, (needBlend && doLineBlend && haveSteepLine) ? 0.25 : 0.0);
-                dst[idx[1]] = mix(dst[idx[1]], blendPix, needBlend ? (doLineBlend ? 
-                    (haveShallowLine ? (haveSteepLine ? 2.0/3.0 : 0.75) : (haveSteepLine ? 0.75 : 0.5)) : 0.3) : 0.0);
-                dst[idx[2]] = mix(dst[idx[2]], blendPix, (needBlend && doLineBlend && haveShallowLine) ? 0.25 : 0.0);
-            }
+            float vk0 = v[0], vk4 = reduce(k4), vk5 = reduce(k5), vk7 = reduce(k7), vk8 = reduce(k8);
+            float dist_01_04 = DistYCbCr(k1, k4);
+            float dist_03_08 = DistYCbCr(k3, k8);
+            bool haveShallowLine = (uSteepDirectionThreshold * dist_01_04 <= dist_03_08) && (vk0 != vk4) && (vk5 != vk4);
+            bool haveSteepLine = (uSteepDirectionThreshold * dist_03_08 <= dist_01_04) && (vk0 != vk8) && (vk7 != vk8);
+            bool needBlend = (blendResult[blendIdx] != BLEND_NONE);
+            bool doLineBlend = blendResult[blendIdx] >= BLEND_DOMINANT ||
+                !((blendResult[(blendIdx+3)%4] != BLEND_NONE && !IsPixEqual(src[0], k4)) ||
+                  (blendResult[(blendIdx+1)%4] != BLEND_NONE && !IsPixEqual(src[0], k8)) ||
+                  (IsPixEqual(k4, k3) && IsPixEqual(k3, k8) && !IsPixEqual(src[0], k3)));
             
-            // Select output based on 3x3 grid position
-            float fx = f.x * 3.0;
-            float fy = f.y * 3.0;
-            int xi = int(fx);
-            int yi = int(fy);
-            int idx = yi * 3 + xi;
+            vec3 blendPix = (DistYCbCr(src[0], k1) <= DistYCbCr(src[0], k3)) ? k1 : k3;
+            float b1 = (needBlend && doLineBlend && haveSteepLine) ? 0.25 : 0.0;
+            float b2 = needBlend ? (doLineBlend ? (haveShallowLine ? (haveSteepLine ? 5.0/6.0 : 0.75) : (haveSteepLine ? 0.75 : 0.5)) : (1.0 - M_PI/4.0)) : 0.0;
+            float b3 = (needBlend && doLineBlend && haveShallowLine) ? 0.25 : 0.0;
             
-            result = dst[clamp(idx, 0, 8)];
+            if (corner == 0) { dst[1] = mix(dst[1], blendPix, b1); dst[2] = mix(dst[2], blendPix, b2); dst[3] = mix(dst[3], blendPix, b3); }
+            else if (corner == 1) { dst[0] = mix(dst[0], blendPix, b1); dst[1] = mix(dst[1], blendPix, b2); dst[2] = mix(dst[2], blendPix, b3); }
+            else if (corner == 2) { dst[3] = mix(dst[3], blendPix, b1); dst[0] = mix(dst[0], blendPix, b2); dst[1] = mix(dst[1], blendPix, b3); }
+            else { dst[2] = mix(dst[2], blendPix, b1); dst[3] = mix(dst[3], blendPix, b2); dst[0] = mix(dst[0], blendPix, b3); }
+        }
+    }
+    
+    vec2 ff = step(0.5, f);
+    vec3 res = mix(mix(dst[0], dst[1], ff.x), mix(dst[3], dst[2], ff.x), ff.y);
+    outColor = vec4(res, tex(tc).a);
+}`;
+
+// 3x xBRZ fragment shader
+const FRAG_3X = COMMON_HEADER + `
+const float one_third = 1.0 / 3.0;
+const float two_third = 2.0 / 3.0;
+
+void main() {
+    vec2 texelSize = 1.0 / uInputRes;
+    vec2 srcPos = vUv * uInputRes;
+    vec2 srcPixel = floor(srcPos);
+    vec2 f = fract(srcPos);
+    vec2 tc = (srcPixel + 0.5) * texelSize;
+    
+    vec3 src[25]; float v[9];
+    sampleNeighborhood(tc, texelSize.x, texelSize.y, src, v);
+    ivec4 blendResult = detectCorners(src, v);
+    
+    // Output: 06|07|08 / 05|00|01 / 04|03|02
+    vec3 dst[9];
+    for (int i = 0; i < 9; i++) dst[i] = src[0];
+    
+    if (IsBlendingNeeded(blendResult)) {
+        for (int corner = 0; corner < 4; corner++) {
+            vec3 k1, k3, k4, k5, k7, k8;
+            int blendIdx;
+            if (corner == 0) { k1=src[1]; k3=src[3]; k4=src[4]; k5=src[5]; k7=src[7]; k8=src[8]; blendIdx=2; }
+            else if (corner == 1) { k1=src[7]; k3=src[1]; k4=src[2]; k5=src[3]; k7=src[5]; k8=src[6]; blendIdx=1; }
+            else if (corner == 2) { k1=src[5]; k3=src[7]; k4=src[8]; k5=src[1]; k7=src[3]; k8=src[4]; blendIdx=0; }
+            else { k1=src[3]; k3=src[5]; k4=src[6]; k5=src[7]; k7=src[1]; k8=src[2]; blendIdx=3; }
             
-        } else {
-            // 4x, 5x, 6x - use 4x algorithm with interpolation
-            vec3 dst[16];
-            for (int i = 0; i < 16; i++) dst[i] = src[0];
+            float vk0 = v[0], vk4 = reduce(k4), vk5 = reduce(k5), vk7 = reduce(k7), vk8 = reduce(k8);
+            float dist_01_04 = DistYCbCr(k1, k4);
+            float dist_03_08 = DistYCbCr(k3, k8);
+            bool haveShallowLine = (uSteepDirectionThreshold * dist_01_04 <= dist_03_08) && (vk0 != vk4) && (vk5 != vk4);
+            bool haveSteepLine = (uSteepDirectionThreshold * dist_03_08 <= dist_01_04) && (vk0 != vk8) && (vk7 != vk8);
+            bool needBlend = (blendResult[blendIdx] != BLEND_NONE);
+            bool doLineBlend = blendResult[blendIdx] >= BLEND_DOMINANT ||
+                !((blendResult[(blendIdx+3)%4] != BLEND_NONE && !IsPixEqual(src[0], k4)) ||
+                  (blendResult[(blendIdx+1)%4] != BLEND_NONE && !IsPixEqual(src[0], k8)) ||
+                  (IsPixEqual(k4, k3) && IsPixEqual(k3, k8) && !IsPixEqual(src[0], k3)));
             
-            // Process all 4 corners
-            for (int rot = 0; rot < 4; rot++) {
-                ivec4 blend = (rot == 0) ? blendResult : 
-                             (rot == 1) ? blendResult.wxyz :
-                             (rot == 2) ? blendResult.zwxy : blendResult.yzwx;
-                
-                vec3 k[9];
-                k[0] = src[0];
-                k[1] = (rot == 0) ? src[1] : (rot == 1) ? src[7] : (rot == 2) ? src[5] : src[3];
-                k[2] = (rot == 0) ? src[2] : (rot == 1) ? src[8] : (rot == 2) ? src[6] : src[4];
-                k[3] = (rot == 0) ? src[3] : (rot == 1) ? src[1] : (rot == 2) ? src[7] : src[5];
-                k[4] = (rot == 0) ? src[4] : (rot == 1) ? src[2] : (rot == 2) ? src[8] : src[6];
-                k[5] = (rot == 0) ? src[5] : (rot == 1) ? src[3] : (rot == 2) ? src[1] : src[7];
-                k[6] = (rot == 0) ? src[6] : (rot == 1) ? src[4] : (rot == 2) ? src[2] : src[8];
-                k[7] = (rot == 0) ? src[7] : (rot == 1) ? src[5] : (rot == 2) ? src[3] : src[1];
-                k[8] = (rot == 0) ? src[8] : (rot == 1) ? src[6] : (rot == 2) ? src[4] : src[2];
-                
-                float vk0 = reduce(k[0]);
-                float vk4 = reduce(k[4]);
-                float vk5 = reduce(k[5]);
-                float vk7 = reduce(k[7]);
-                float vk8 = reduce(k[8]);
-                
-                float dist_01_04 = distYCbCr(k[1], k[4]);
-                float dist_03_08 = distYCbCr(k[3], k[8]);
-                bool haveShallowLine = (uSteepDirectionThreshold * dist_01_04 <= dist_03_08) && (vk0 != vk4) && (vk5 != vk4);
-                bool haveSteepLine = (uSteepDirectionThreshold * dist_03_08 <= dist_01_04) && (vk0 != vk8) && (vk7 != vk8);
-                bool needBlend = (blend[2] != BLEND_NONE);
-                bool doLineBlend = blend[2] >= BLEND_DOMINANT ||
-                    !((blend[1] != BLEND_NONE && !isPixEqual(k[0], k[4])) ||
-                      (blend[3] != BLEND_NONE && !isPixEqual(k[0], k[8])) ||
-                      (isPixEqual(k[4], k[3]) && isPixEqual(k[3], k[2]) && 
-                       isPixEqual(k[2], k[1]) && isPixEqual(k[1], k[8]) && !isPixEqual(k[0], k[2])));
-                
-                vec3 blendPix = (distYCbCr(k[0], k[1]) <= distYCbCr(k[0], k[3])) ? k[1] : k[3];
-                
-                // 4x layout with rotation
-                // Output mapping: 06|07|08|09
-                //                 05|00|01|10
-                //                 04|03|02|11
-                //                 15|14|13|12
-                
-                const float NOLINEBLEND = 0.08677704501;
-                const float LINEBLEND_CENTER = 0.6848532563;
-                
-                // Apply blends based on rotation
-                if (rot == 0) {
-                    dst[2] = mix(dst[2], blendPix, (needBlend && doLineBlend) ? 
-                        (haveShallowLine ? (haveSteepLine ? 1.0/3.0 : 0.25) : (haveSteepLine ? 0.25 : 0.0)) : 0.0);
-                    dst[9] = mix(dst[9], blendPix, (needBlend && doLineBlend && haveSteepLine) ? 0.25 : 0.0);
-                    dst[10] = mix(dst[10], blendPix, (needBlend && doLineBlend && haveSteepLine) ? 0.75 : 0.0);
-                    dst[11] = mix(dst[11], blendPix, needBlend ? (doLineBlend ? 
-                        (haveSteepLine ? 1.0 : (haveShallowLine ? 0.75 : 0.5)) : NOLINEBLEND) : 0.0);
-                    dst[12] = mix(dst[12], blendPix, needBlend ? (doLineBlend ? 1.0 : LINEBLEND_CENTER) : 0.0);
-                    dst[13] = mix(dst[13], blendPix, needBlend ? (doLineBlend ? 
-                        (haveShallowLine ? 1.0 : (haveSteepLine ? 0.75 : 0.5)) : NOLINEBLEND) : 0.0);
-                    dst[14] = mix(dst[14], blendPix, (needBlend && doLineBlend && haveShallowLine) ? 0.75 : 0.0);
-                    dst[15] = mix(dst[15], blendPix, (needBlend && doLineBlend && haveShallowLine) ? 0.25 : 0.0);
-                } else if (rot == 1) {
-                    dst[1] = mix(dst[1], blendPix, (needBlend && doLineBlend) ? 
-                        (haveShallowLine ? (haveSteepLine ? 1.0/3.0 : 0.25) : (haveSteepLine ? 0.25 : 0.0)) : 0.0);
-                    dst[6] = mix(dst[6], blendPix, (needBlend && doLineBlend && haveSteepLine) ? 0.25 : 0.0);
-                    dst[7] = mix(dst[7], blendPix, (needBlend && doLineBlend && haveSteepLine) ? 0.75 : 0.0);
-                    dst[8] = mix(dst[8], blendPix, needBlend ? (doLineBlend ? 
-                        (haveSteepLine ? 1.0 : (haveShallowLine ? 0.75 : 0.5)) : NOLINEBLEND) : 0.0);
-                    dst[9] = mix(dst[9], blendPix, needBlend ? (doLineBlend ? 1.0 : LINEBLEND_CENTER) : 0.0);
-                    dst[10] = mix(dst[10], blendPix, needBlend ? (doLineBlend ? 
-                        (haveShallowLine ? 1.0 : (haveSteepLine ? 0.75 : 0.5)) : NOLINEBLEND) : 0.0);
-                    dst[11] = mix(dst[11], blendPix, (needBlend && doLineBlend && haveShallowLine) ? 0.75 : 0.0);
-                    dst[12] = mix(dst[12], blendPix, (needBlend && doLineBlend && haveShallowLine) ? 0.25 : 0.0);
-                } else if (rot == 2) {
-                    dst[0] = mix(dst[0], blendPix, (needBlend && doLineBlend) ? 
-                        (haveShallowLine ? (haveSteepLine ? 1.0/3.0 : 0.25) : (haveSteepLine ? 0.25 : 0.0)) : 0.0);
-                    dst[15] = mix(dst[15], blendPix, (needBlend && doLineBlend && haveSteepLine) ? 0.25 : 0.0);
-                    dst[4] = mix(dst[4], blendPix, (needBlend && doLineBlend && haveSteepLine) ? 0.75 : 0.0);
-                    dst[5] = mix(dst[5], blendPix, needBlend ? (doLineBlend ? 
-                        (haveSteepLine ? 1.0 : (haveShallowLine ? 0.75 : 0.5)) : NOLINEBLEND) : 0.0);
-                    dst[6] = mix(dst[6], blendPix, needBlend ? (doLineBlend ? 1.0 : LINEBLEND_CENTER) : 0.0);
-                    dst[7] = mix(dst[7], blendPix, needBlend ? (doLineBlend ? 
-                        (haveShallowLine ? 1.0 : (haveSteepLine ? 0.75 : 0.5)) : NOLINEBLEND) : 0.0);
-                    dst[8] = mix(dst[8], blendPix, (needBlend && doLineBlend && haveShallowLine) ? 0.75 : 0.0);
-                    dst[9] = mix(dst[9], blendPix, (needBlend && doLineBlend && haveShallowLine) ? 0.25 : 0.0);
-                } else {
-                    dst[3] = mix(dst[3], blendPix, (needBlend && doLineBlend) ? 
-                        (haveShallowLine ? (haveSteepLine ? 1.0/3.0 : 0.25) : (haveSteepLine ? 0.25 : 0.0)) : 0.0);
-                    dst[12] = mix(dst[12], blendPix, (needBlend && doLineBlend && haveSteepLine) ? 0.25 : 0.0);
-                    dst[13] = mix(dst[13], blendPix, (needBlend && doLineBlend && haveSteepLine) ? 0.75 : 0.0);
-                    dst[14] = mix(dst[14], blendPix, needBlend ? (doLineBlend ? 
-                        (haveSteepLine ? 1.0 : (haveShallowLine ? 0.75 : 0.5)) : NOLINEBLEND) : 0.0);
-                    dst[15] = mix(dst[15], blendPix, needBlend ? (doLineBlend ? 1.0 : LINEBLEND_CENTER) : 0.0);
-                    dst[4] = mix(dst[4], blendPix, needBlend ? (doLineBlend ? 
-                        (haveShallowLine ? 1.0 : (haveSteepLine ? 0.75 : 0.5)) : NOLINEBLEND) : 0.0);
-                    dst[5] = mix(dst[5], blendPix, (needBlend && doLineBlend && haveShallowLine) ? 0.75 : 0.0);
-                    dst[6] = mix(dst[6], blendPix, (needBlend && doLineBlend && haveShallowLine) ? 0.25 : 0.0);
-                }
-            }
+            vec3 blendPix = (DistYCbCr(src[0], k1) <= DistYCbCr(src[0], k3)) ? k1 : k3;
+            float b1 = (needBlend && doLineBlend) ? (haveSteepLine ? 0.75 : (haveShallowLine ? 0.25 : 0.125)) : 0.0;
+            float b2 = needBlend ? (doLineBlend ? ((!haveShallowLine && !haveSteepLine) ? 0.875 : 1.0) : 0.4545939598) : 0.0;
+            float b3 = (needBlend && doLineBlend) ? (haveShallowLine ? 0.75 : (haveSteepLine ? 0.25 : 0.125)) : 0.0;
+            float b4 = (needBlend && doLineBlend && haveShallowLine) ? 0.25 : 0.0;
+            float b8 = (needBlend && doLineBlend && haveSteepLine) ? 0.25 : 0.0;
             
-            // Map 4x4 to output with bilinear interpolation for 5x, 6x
-            float scale4 = 4.0;
-            float fx = f.x * scale4;
-            float fy = f.y * scale4;
+            if (corner == 0) { dst[1]=mix(dst[1],blendPix,b1); dst[2]=mix(dst[2],blendPix,b2); dst[3]=mix(dst[3],blendPix,b3); dst[4]=mix(dst[4],blendPix,b4); dst[8]=mix(dst[8],blendPix,b8); }
+            else if (corner == 1) { dst[7]=mix(dst[7],blendPix,b1); dst[8]=mix(dst[8],blendPix,b2); dst[1]=mix(dst[1],blendPix,b3); dst[2]=mix(dst[2],blendPix,b4); dst[6]=mix(dst[6],blendPix,b8); }
+            else if (corner == 2) { dst[5]=mix(dst[5],blendPix,b1); dst[6]=mix(dst[6],blendPix,b2); dst[7]=mix(dst[7],blendPix,b3); dst[8]=mix(dst[8],blendPix,b4); dst[4]=mix(dst[4],blendPix,b8); }
+            else { dst[3]=mix(dst[3],blendPix,b1); dst[4]=mix(dst[4],blendPix,b2); dst[5]=mix(dst[5],blendPix,b3); dst[6]=mix(dst[6],blendPix,b4); dst[2]=mix(dst[2],blendPix,b8); }
+        }
+    }
+    
+    vec3 res = mix(mix(dst[6], mix(dst[7], dst[8], step(two_third, f.x)), step(one_third, f.x)),
+                   mix(mix(dst[5], mix(dst[0], dst[1], step(two_third, f.x)), step(one_third, f.x)),
+                       mix(dst[4], mix(dst[3], dst[2], step(two_third, f.x)), step(one_third, f.x)), step(two_third, f.y)),
+                   step(one_third, f.y));
+    outColor = vec4(res, tex(tc).a);
+}`;
+
+// 4x xBRZ fragment shader
+const FRAG_4X = COMMON_HEADER + `
+void main() {
+    vec2 texelSize = 1.0 / uInputRes;
+    vec2 srcPos = vUv * uInputRes;
+    vec2 srcPixel = floor(srcPos);
+    vec2 f = fract(srcPos);
+    vec2 tc = (srcPixel + 0.5) * texelSize;
+    
+    vec3 src[25]; float v[9];
+    sampleNeighborhood(tc, texelSize.x, texelSize.y, src, v);
+    ivec4 blendResult = detectCorners(src, v);
+    
+    // Output: 06|07|08|09 / 05|00|01|10 / 04|03|02|11 / 15|14|13|12
+    vec3 dst[16];
+    for (int i = 0; i < 16; i++) dst[i] = src[0];
+    
+    if (IsBlendingNeeded(blendResult)) {
+        for (int corner = 0; corner < 4; corner++) {
+            vec3 k1, k3, k4, k5, k7, k8;
+            int blendIdx;
+            if (corner == 0) { k1=src[1]; k3=src[3]; k4=src[4]; k5=src[5]; k7=src[7]; k8=src[8]; blendIdx=2; }
+            else if (corner == 1) { k1=src[7]; k3=src[1]; k4=src[2]; k5=src[3]; k7=src[5]; k8=src[6]; blendIdx=1; }
+            else if (corner == 2) { k1=src[5]; k3=src[7]; k4=src[8]; k5=src[1]; k7=src[3]; k8=src[4]; blendIdx=0; }
+            else { k1=src[3]; k3=src[5]; k4=src[6]; k5=src[7]; k7=src[1]; k8=src[2]; blendIdx=3; }
             
-            // 4x layout: 06|07|08|09
-            //            05|00|01|10
-            //            04|03|02|11
-            //            15|14|13|12
-            int mapping[16] = int[16](6, 7, 8, 9, 5, 0, 1, 10, 4, 3, 2, 11, 15, 14, 13, 12);
+            float vk0 = v[0], vk4 = reduce(k4), vk5 = reduce(k5), vk7 = reduce(k7), vk8 = reduce(k8);
+            float dist_01_04 = DistYCbCr(k1, k4);
+            float dist_03_08 = DistYCbCr(k3, k8);
+            bool haveShallowLine = (uSteepDirectionThreshold * dist_01_04 <= dist_03_08) && (vk0 != vk4) && (vk5 != vk4);
+            bool haveSteepLine = (uSteepDirectionThreshold * dist_03_08 <= dist_01_04) && (vk0 != vk8) && (vk7 != vk8);
+            bool needBlend = (blendResult[blendIdx] != BLEND_NONE);
+            bool doLineBlend = blendResult[blendIdx] >= BLEND_DOMINANT ||
+                !((blendResult[(blendIdx+3)%4] != BLEND_NONE && !IsPixEqual(src[0], k4)) ||
+                  (blendResult[(blendIdx+1)%4] != BLEND_NONE && !IsPixEqual(src[0], k8)) ||
+                  (IsPixEqual(k4, k3) && IsPixEqual(k3, k8) && !IsPixEqual(src[0], k3)));
             
-            // Bilinear interpolation within 4x grid
-            int xi = clamp(int(fx), 0, 3);
-            int yi = clamp(int(fy), 0, 3);
-            float xf = fract(fx);
-            float yf = fract(fy);
+            vec3 blendPix = (DistYCbCr(src[0], k1) <= DistYCbCr(src[0], k3)) ? k1 : k3;
             
-            int i00 = mapping[yi * 4 + xi];
-            int i10 = mapping[yi * 4 + min(xi + 1, 3)];
-            int i01 = mapping[min(yi + 1, 3) * 4 + xi];
-            int i11 = mapping[min(yi + 1, 3) * 4 + min(xi + 1, 3)];
+            // 4x specific blend weights
+            float bCorner = (needBlend && doLineBlend) ? (haveShallowLine ? (haveSteepLine ? 1.0/3.0 : 0.25) : (haveSteepLine ? 0.25 : 0.0)) : 0.0;
+            float bSteep1 = (needBlend && doLineBlend && haveSteepLine) ? 0.25 : 0.0;
+            float bSteep2 = (needBlend && doLineBlend && haveSteepLine) ? 0.75 : 0.0;
+            float bEdge1 = needBlend ? (doLineBlend ? (haveSteepLine ? 1.0 : (haveShallowLine ? 0.75 : 0.5)) : 0.08677704501) : 0.0;
+            float bCenter = needBlend ? (doLineBlend ? 1.0 : 0.6848532563) : 0.0;
+            float bEdge2 = needBlend ? (doLineBlend ? (haveShallowLine ? 1.0 : (haveSteepLine ? 0.75 : 0.5)) : 0.08677704501) : 0.0;
+            float bShallow1 = (needBlend && doLineBlend && haveShallowLine) ? 0.75 : 0.0;
+            float bShallow2 = (needBlend && doLineBlend && haveShallowLine) ? 0.25 : 0.0;
             
-            result = mix(mix(dst[i00], dst[i10], xf),
-                        mix(dst[i01], dst[i11], xf), yf);
+            if (corner == 0) {
+                dst[2]=mix(dst[2],blendPix,bCorner); dst[9]=mix(dst[9],blendPix,bSteep1); dst[10]=mix(dst[10],blendPix,bSteep2);
+                dst[11]=mix(dst[11],blendPix,bEdge1); dst[12]=mix(dst[12],blendPix,bCenter); dst[13]=mix(dst[13],blendPix,bEdge2);
+                dst[14]=mix(dst[14],blendPix,bShallow1); dst[15]=mix(dst[15],blendPix,bShallow2);
+            } else if (corner == 1) {
+                dst[1]=mix(dst[1],blendPix,bCorner); dst[6]=mix(dst[6],blendPix,bSteep1); dst[7]=mix(dst[7],blendPix,bSteep2);
+                dst[8]=mix(dst[8],blendPix,bEdge1); dst[9]=mix(dst[9],blendPix,bCenter); dst[10]=mix(dst[10],blendPix,bEdge2);
+                dst[11]=mix(dst[11],blendPix,bShallow1); dst[12]=mix(dst[12],blendPix,bShallow2);
+            } else if (corner == 2) {
+                dst[0]=mix(dst[0],blendPix,bCorner); dst[15]=mix(dst[15],blendPix,bSteep1); dst[4]=mix(dst[4],blendPix,bSteep2);
+                dst[5]=mix(dst[5],blendPix,bEdge1); dst[6]=mix(dst[6],blendPix,bCenter); dst[7]=mix(dst[7],blendPix,bEdge2);
+                dst[8]=mix(dst[8],blendPix,bShallow1); dst[9]=mix(dst[9],blendPix,bShallow2);
+            } else {
+                dst[3]=mix(dst[3],blendPix,bCorner); dst[12]=mix(dst[12],blendPix,bSteep1); dst[13]=mix(dst[13],blendPix,bSteep2);
+                dst[14]=mix(dst[14],blendPix,bEdge1); dst[15]=mix(dst[15],blendPix,bCenter); dst[4]=mix(dst[4],blendPix,bEdge2);
+                dst[5]=mix(dst[5],blendPix,bShallow1); dst[6]=mix(dst[6],blendPix,bShallow2);
+            }
         }
     }
     
-    outColor = vec4(result, tex(tc).a);
+    vec3 res = mix(mix(mix(mix(dst[6], dst[7], step(0.25, f.x)), mix(dst[8], dst[9], step(0.75, f.x)), step(0.5, f.x)),
+                       mix(mix(dst[5], dst[0], step(0.25, f.x)), mix(dst[1], dst[10], step(0.75, f.x)), step(0.5, f.x)), step(0.25, f.y)),
+                   mix(mix(mix(dst[4], dst[3], step(0.25, f.x)), mix(dst[2], dst[11], step(0.75, f.x)), step(0.5, f.x)),
+                       mix(mix(dst[15], dst[14], step(0.25, f.x)), mix(dst[13], dst[12], step(0.75, f.x)), step(0.5, f.x)), step(0.75, f.y)),
+                   step(0.5, f.y));
+    outColor = vec4(res, tex(tc).a);
 }`;
 
+// 5x and 6x use 4x with interpolation
+const FRAG_5X = FRAG_4X;
+const FRAG_6X = FRAG_4X;
+
 /** xBRZ GPU Renderer */
 export class XbrzGpuRenderer implements Renderer<XbrzOptions> {
   private gl: WebGL2RenderingContext | null = null;
   private canvas: OffscreenCanvas | null = null;
-  private program: WebGLProgram | null = null;
+  private programs: Map<number, WebGLProgram> = new Map();
   private texture: WebGLTexture | null = null;
-  private uniforms: Record<string, WebGLUniformLocation | null> = {};
+  private uniforms: Map<number, Record<string, WebGLUniformLocation | null>> = new Map();
   private initialized = false;
   private currentCanvasSize = { width: 0, height: 0 };
   private currentTexSize = { width: 0, height: 0 };
+  private currentScale = 0;
 
-  /** Create a new xBRZ GPU renderer */
   static create(): XbrzGpuRenderer {
     const renderer = new XbrzGpuRenderer();
     renderer.init();
@@ -490,72 +326,46 @@ export class XbrzGpuRenderer implements Renderer<XbrzOptions> {
   }
 
   private init(): void {
-    if (typeof OffscreenCanvas === 'undefined') {
-      throw new Error('OffscreenCanvas not supported');
-    }
-
+    if (typeof OffscreenCanvas === 'undefined') throw new Error('OffscreenCanvas not supported');
     this.canvas = new OffscreenCanvas(1, 1);
-    this.gl = this.canvas.getContext('webgl2', {
-      alpha: true,
-      premultipliedAlpha: false,
-      desynchronized: true,
-      powerPreference: 'high-performance',
-      antialias: false,
-    });
-
-    if (!this.gl) {
-      throw new Error('WebGL2 not supported');
-    }
+    this.gl = this.canvas.getContext('webgl2', { alpha: true, premultipliedAlpha: false, desynchronized: true, powerPreference: 'high-performance', antialias: false });
+    if (!this.gl) throw new Error('WebGL2 not supported');
 
     const gl = this.gl;
-
-    // Create shaders
     const vs = this.createShader(gl.VERTEX_SHADER, VERTEX_SHADER);
-    const fs = this.createShader(gl.FRAGMENT_SHADER, FRAGMENT_SHADER);
-
-    // Create program
-    this.program = gl.createProgram()!;
-    gl.attachShader(this.program, vs);
-    gl.attachShader(this.program, fs);
-    gl.linkProgram(this.program);
-
-    if (!gl.getProgramParameter(this.program, gl.LINK_STATUS)) {
-      throw new Error('Shader program link failed: ' + gl.getProgramInfoLog(this.program));
+    const shaders: Record<number, string> = { 2: FRAG_2X, 3: FRAG_3X, 4: FRAG_4X, 5: FRAG_5X, 6: FRAG_6X };
+
+    for (const [scale, fragSource] of Object.entries(shaders)) {
+      const fs = this.createShader(gl.FRAGMENT_SHADER, fragSource);
+      const program = gl.createProgram()!;
+      gl.attachShader(program, vs);
+      gl.attachShader(program, fs);
+      gl.linkProgram(program);
+      if (!gl.getProgramParameter(program, gl.LINK_STATUS)) throw new Error(`Shader link failed for ${scale}x: ` + gl.getProgramInfoLog(program));
+      this.programs.set(Number(scale), program);
+      this.uniforms.set(Number(scale), {
+        uTex: gl.getUniformLocation(program, 'uTex'),
+        uInputRes: gl.getUniformLocation(program, 'uInputRes'),
+        uLuminanceWeight: gl.getUniformLocation(program, 'uLuminanceWeight'),
+        uEqualColorTolerance: gl.getUniformLocation(program, 'uEqualColorTolerance'),
+        uSteepDirectionThreshold: gl.getUniformLocation(program, 'uSteepDirectionThreshold'),
+        uDominantDirectionThreshold: gl.getUniformLocation(program, 'uDominantDirectionThreshold'),
+      });
     }
 
-    gl.useProgram(this.program);
-
-    // Get uniform locations
-    this.uniforms = {
-      uTex: gl.getUniformLocation(this.program, 'uTex'),
-      uInputRes: gl.getUniformLocation(this.program, 'uInputRes'),
-      uOutputRes: gl.getUniformLocation(this.program, 'uOutputRes'),
-      uScale: gl.getUniformLocation(this.program, 'uScale'),
-      uLuminanceWeight: gl.getUniformLocation(this.program, 'uLuminanceWeight'),
-      uEqualColorTolerance: gl.getUniformLocation(this.program, 'uEqualColorTolerance'),
-      uSteepDirectionThreshold: gl.getUniformLocation(this.program, 'uSteepDirectionThreshold'),
-      uDominantDirectionThreshold: gl.getUniformLocation(this.program, 'uDominantDirectionThreshold'),
-    };
-
-    gl.uniform1i(this.uniforms.uTex, 0);
-
-    // Setup geometry (fullscreen triangle)
     const buf = gl.createBuffer();
     gl.bindBuffer(gl.ARRAY_BUFFER, buf);
     gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 3, -1, -1, 3]), gl.STATIC_DRAW);
     gl.enableVertexAttribArray(0);
     gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
 
-    // Create texture with NEAREST filtering for pixel art
     this.texture = gl.createTexture();
     gl.bindTexture(gl.TEXTURE_2D, this.texture);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-
     gl.clearColor(0.0, 0.0, 0.0, 0.0);
-
     this.initialized = true;
   }
 
@@ -564,37 +374,36 @@ export class XbrzGpuRenderer implements Renderer<XbrzOptions> {
     const shader = gl.createShader(type)!;
     gl.shaderSource(shader, source);
     gl.compileShader(shader);
-
     if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
       const info = gl.getShaderInfoLog(shader);
       gl.deleteShader(shader);
       throw new Error('Shader compile failed: ' + info);
     }
-
     return shader;
   }
 
-  /** Check if renderer is ready */
-  isReady(): boolean {
-    return this.initialized;
-  }
+  isReady(): boolean { return this.initialized; }
 
-  /** Render xBRZ effect */
   render(input: ImageInput | ImageData, options: XbrzOptions = {}): ImageOutput {
-    if (!this.initialized || !this.gl || !this.canvas) {
-      throw new Error('Renderer not initialized');
-    }
-
+    if (!this.initialized || !this.gl || !this.canvas) throw new Error('Renderer not initialized');
     const gl = this.gl;
     const data = input instanceof ImageData ? input.data : input.data;
     const width = input.width;
     const height = input.height;
-
     const scale = Math.min(6, Math.max(2, options.scale ?? 2));
     const outWidth = width * scale;
     const outHeight = height * scale;
 
-    // Resize canvas if needed
+    const program = this.programs.get(scale);
+    const uniforms = this.uniforms.get(scale);
+    if (!program || !uniforms) throw new Error(`No program for scale ${scale}`);
+
+    if (this.currentScale !== scale) {
+      gl.useProgram(program);
+      gl.uniform1i(uniforms.uTex, 0);
+      this.currentScale = scale;
+    }
+
     if (this.currentCanvasSize.width !== outWidth || this.currentCanvasSize.height !== outHeight) {
       this.canvas.width = outWidth;
       this.canvas.height = outHeight;
@@ -602,16 +411,12 @@ export class XbrzGpuRenderer implements Renderer<XbrzOptions> {
       gl.viewport(0, 0, outWidth, outHeight);
     }
 
-    // Update uniforms
-    gl.uniform2f(this.uniforms.uInputRes, width, height);
-    gl.uniform2f(this.uniforms.uOutputRes, outWidth, outHeight);
-    gl.uniform1i(this.uniforms.uScale, scale);
-    gl.uniform1f(this.uniforms.uLuminanceWeight, options.luminanceWeight ?? 1.0);
-    gl.uniform1f(this.uniforms.uEqualColorTolerance, (options.equalColorTolerance ?? 30) / 255.0);
-    gl.uniform1f(this.uniforms.uSteepDirectionThreshold, options.steepDirectionThreshold ?? 2.2);
-    gl.uniform1f(this.uniforms.uDominantDirectionThreshold, options.dominantDirectionThreshold ?? 3.6);
+    gl.uniform2f(uniforms.uInputRes, width, height);
+    gl.uniform1f(uniforms.uLuminanceWeight, options.luminanceWeight ?? 1.0);
+    gl.uniform1f(uniforms.uEqualColorTolerance, (options.equalColorTolerance ?? 30) / 255.0);
+    gl.uniform1f(uniforms.uSteepDirectionThreshold, options.steepDirectionThreshold ?? 2.2);
+    gl.uniform1f(uniforms.uDominantDirectionThreshold, options.dominantDirectionThreshold ?? 3.6);
 
-    // Update texture
     gl.bindTexture(gl.TEXTURE_2D, this.texture);
     if (this.currentTexSize.width !== width || this.currentTexSize.height !== height) {
       gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, data);
@@ -620,52 +425,30 @@ export class XbrzGpuRenderer implements Renderer<XbrzOptions> {
       gl.texSubImage2D(gl.TEXTURE_2D, 0, 0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, data);
     }
 
-    // Render
     gl.clear(gl.COLOR_BUFFER_BIT);
     gl.drawArrays(gl.TRIANGLES, 0, 3);
 
-    // Read pixels
     const pixels = new Uint8ClampedArray(outWidth * outHeight * 4);
     gl.readPixels(0, 0, outWidth, outHeight, gl.RGBA, gl.UNSIGNED_BYTE, pixels);
-
-    return {
-      data: pixels,
-      width: outWidth,
-      height: outHeight,
-    };
+    return { data: pixels, width: outWidth, height: outHeight };
   }
 
-  /** Dispose resources */
   dispose(): void {
     if (this.gl) {
       if (this.texture) this.gl.deleteTexture(this.texture);
-      if (this.program) this.gl.deleteProgram(this.program);
+      for (const program of this.programs.values()) this.gl.deleteProgram(program);
       this.gl = null;
     }
     this.canvas = null;
+    this.programs.clear();
+    this.uniforms.clear();
     this.initialized = false;
   }
 }
 
-/** xBRZ presets */
 export const XBRZ_PRESETS: Record<string, Partial<XbrzOptions>> = {
   default: {},
-  sharp: {
-    luminanceWeight: 1.0,
-    equalColorTolerance: 20,
-    steepDirectionThreshold: 2.0,
-    dominantDirectionThreshold: 3.2,
-  },
-  smooth: {
-    luminanceWeight: 1.0,
-    equalColorTolerance: 40,
-    steepDirectionThreshold: 2.4,
-    dominantDirectionThreshold: 4.0,
-  },
-  colorful: {
-    luminanceWeight: 0.5,
-    equalColorTolerance: 30,
-    steepDirectionThreshold: 2.2,
-    dominantDirectionThreshold: 3.6,
-  },
+  sharp: { luminanceWeight: 1.0, equalColorTolerance: 20, steepDirectionThreshold: 2.0, dominantDirectionThreshold: 3.2 },
+  smooth: { luminanceWeight: 1.0, equalColorTolerance: 40, steepDirectionThreshold: 2.4, dominantDirectionThreshold: 4.0 },
+  colorful: { luminanceWeight: 0.5, equalColorTolerance: 30, steepDirectionThreshold: 2.2, dominantDirectionThreshold: 3.6 },
 };