@aguacerowx/react-native 0.0.33 → 0.0.34

package/lib/commonjs/ios/InspectorModule.swift

@@ -1,64 +1,64 @@
-import Foundation
-import React
-
-@objc(InspectorModule)
-class InspectorModule: NSObject {
-    
-@objc(getValueAtGridIndex:j:resolver:rejecter:)
-    func getValueAtGridIndex(
-        i: NSNumber,
-        j: NSNumber,
-        resolve: @escaping RCTPromiseResolveBlock,
-        reject: @escaping RCTPromiseRejectBlock
-    ) {
-        
-        DispatchQueue.global(qos: .userInitiated).async {
-            let cache = InspectorDataCache.shared
-
-            guard let data = cache.lastDecompressedData else {
-                resolve(nil)
-                return
-            }
-            
-            let nx = cache.nx
-            let scale = cache.scale
-            let offset = cache.offset
-            let missing = cache.missing
-            let scaleType = cache.scaleType
-            
-            let index = j.intValue * nx + i.intValue
-            
-            guard index >= 0 && index < data.count else {
-                print("🔍 [Inspector] ERROR: Index out of bounds")
-                resolve(nil)
-                return
-            }
-            
-            // Read as signed value
-            let signedQuantizedValue = Int(Int8(bitPattern: data[index]))
-            let missingQuantized = Int(round(missing))
-            
-            // Check for missing value with tolerance
-            if abs(signedQuantizedValue - missingQuantized) < 1 {
-                resolve(nil)
-                return
-            }
-            
-            // Step 1: Linear dequantization
-            let intermediateValue = Double(signedQuantizedValue) * Double(scale) + Double(offset)
-            var finalValue = intermediateValue
-            
-            // Step 2: Apply sqrt inverse transformation if needed
-            if scaleType == 1 {
-                finalValue = intermediateValue * abs(intermediateValue)
-            } 
-            
-            resolve(finalValue)
-        }
-    }
-    
-    @objc
-    static func requiresMainQueueSetup() -> Bool {
-        return false
-    }
+import Foundation
+import React
+
+@objc(InspectorModule)
+class InspectorModule: NSObject {
+    
+@objc(getValueAtGridIndex:j:resolver:rejecter:)
+    func getValueAtGridIndex(
+        i: NSNumber,
+        j: NSNumber,
+        resolve: @escaping RCTPromiseResolveBlock,
+        reject: @escaping RCTPromiseRejectBlock
+    ) {
+        
+        DispatchQueue.global(qos: .userInitiated).async {
+            let cache = InspectorDataCache.shared
+
+            guard let data = cache.lastDecompressedData else {
+                resolve(nil)
+                return
+            }
+            
+            let nx = cache.nx
+            let scale = cache.scale
+            let offset = cache.offset
+            let missing = cache.missing
+            let scaleType = cache.scaleType
+            
+            let index = j.intValue * nx + i.intValue
+            
+            guard index >= 0 && index < data.count else {
+                print("🔍 [Inspector] ERROR: Index out of bounds")
+                resolve(nil)
+                return
+            }
+            
+            // Read as signed value
+            let signedQuantizedValue = Int(Int8(bitPattern: data[index]))
+            let missingQuantized = Int(round(missing))
+            
+            // Check for missing value with tolerance
+            if abs(signedQuantizedValue - missingQuantized) < 1 {
+                resolve(nil)
+                return
+            }
+            
+            // Step 1: Linear dequantization
+            let intermediateValue = Double(signedQuantizedValue) * Double(scale) + Double(offset)
+            var finalValue = intermediateValue
+            
+            // Step 2: Apply sqrt inverse transformation if needed
+            if scaleType == 1 {
+                finalValue = intermediateValue * abs(intermediateValue)
+            } 
+            
+            resolve(finalValue)
+        }
+    }
+    
+    @objc
+    static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
 }

package/lib/commonjs/ios/Shaders.metal

@@ -1,191 +1,328 @@
-#include <metal_stdlib>
-using namespace metal;
-
-// Struct to match the vertex buffer layout in Swift
-struct Vertex {
-    float2 position [[attribute(0)]];
-    float2 texCoord [[attribute(1)]];
-};
-
-// Struct for passing data from vertex to fragment shader
-struct RasterizerData {
-    float4 position [[position]];
-    float2 texCoord;
-};
-
-// Uniforms passed from the CPU to the fragment shader
-struct FragmentUniforms {
-    float opacity;
-    float2 dataRange;
-    float scale;
-    float offset;
-    float missingQuantized;
-    float2 textureSize;
-    int smoothing;
-    int scaleType;
-    int isPtype;
-    int isMRMS;
-};
-
-// --- Vertex Shader (Unchanged) ---
-vertex RasterizerData vertex_main(const Vertex in [[stage_in]],
-                                  constant float4x4 &mvp [[buffer(1)]]) {
-    RasterizerData out;
-    out.position = mvp * float4(in.position, 0.0, 1.0);
-    out.texCoord = in.texCoord;
-    return out;
-}
-
-
-// --- HELPER FUNCTIONS FOR FRAGMENT SHADER ---
-
-// Dequantizes a signed value (-127 to 127) into a physical value
-float dequantize_val(float q_val, constant FragmentUniforms &uniforms) {
-    if (abs(q_val - uniforms.missingQuantized) < 0.5) {
-        return -9999.0;
-    }
-    float intermediate = q_val * uniforms.scale + uniforms.offset;
-    if (uniforms.scaleType == 1) { // 1 = sqrt
-        return intermediate * abs(intermediate);
-    }
-    return intermediate;
-}
-
-// Samples texture, converts 0-255 to signed -128-127 range.
-// Returns a quantized value, or a large positive sentinel for missing data.
-float get_value(texture2d<float, access::sample> dataTexture, sampler dataSampler, float2 coord, constant FragmentUniforms &uniforms) {
-    // Note: The sampler should be set to 'nearest' when calling this for ptype logic.
-    float value_0_to_255 = dataTexture.sample(dataSampler, coord).r * 255.0;
-    float val = value_0_to_255 - 128.0;
-    float missing_in_texture_range_0_255 = uniforms.missingQuantized + 128.0;
-    if (abs(value_0_to_255 - missing_in_texture_range_0_255) < 0.5) {
-        return 99999.0; // Sentinel for "missing"
-    }
-    return val;
-}
-
-// Maps a physical value to a precipitation type category
-// Maps a physical value to a precipitation type category
-float get_ptype_from_physical(float val, constant FragmentUniforms &uniforms) {  // ADD uniforms parameter
-    if (val < 0.0) return -1.0;
-    
-    if (uniforms.isMRMS == 1) {  // ADD THIS BRANCH
-        // MRMS: 0-100 rain, 100-200 snow, 200-300 freezing rain
-        if (val < 100.0) return 0.0;
-        if (val < 200.0) return 1.0;
-        if (val < 300.0) return 2.0;
-        return -1.0;
-    } else {
-        // Models: 0-100 rain, 100-200 snow, 200-300 freezing rain, 300-400 ice pellets
-        if (val < 100.0) return 0.0;
-        if (val < 200.0) return 1.0;
-        if (val < 300.0) return 2.0;
-        if (val < 400.0) return 3.0;
-        return -1.0;
-    }
-}
-
-// --- Main Fragment Shader ---
-fragment float4 fragment_main(RasterizerData in [[stage_in]],
-                                constant FragmentUniforms &uniforms [[buffer(0)]],
-                                texture2d<float, access::sample> dataTexture [[texture(0)]],
-                                texture2d<float, access::sample> colormapTexture [[texture(1)]],
-                                sampler dataSampler [[sampler(0)]],
-                                sampler colormapSampler [[sampler(1)]])
-{
-    float raw_value;
-    float alpha_multiplier = 1.0; // Used for alpha feathering at data edges
-
-    if (uniforms.smoothing == 0) { // Nearest neighbor
-        float quantized_value = get_value(dataTexture, dataSampler, in.texCoord, uniforms);
-        if (quantized_value >= 99999.0) {
-             discard_fragment();
-        }
-        raw_value = dequantize_val(quantized_value, uniforms);
-
-    } else { // Bilinear interpolation
-        float2 texel_size = 1.0 / uniforms.textureSize;
-        float2 tex_coord_in_texels = in.texCoord * uniforms.textureSize;
-        float2 bl_texel_index = floor(tex_coord_in_texels - 0.5);
-        float2 f = fract(tex_coord_in_texels - 0.5); // Interpolation factors
-
-        // Coordinates of the 4 neighboring texels
-        float2 v00_coord = (bl_texel_index + float2(0.5, 0.5)) * texel_size;
-        float2 v10_coord = (bl_texel_index + float2(1.5, 0.5)) * texel_size;
-        float2 v01_coord = (bl_texel_index + float2(0.5, 1.5)) * texel_size;
-        float2 v11_coord = (bl_texel_index + float2(1.5, 1.5)) * texel_size;
-
-        if (uniforms.isPtype == 1) {
-            // --- PTYPE-SPECIFIC INTERPOLATION (CATEGORICAL) ---
-            float v00 = dequantize_val(get_value(dataTexture, dataSampler, v00_coord, uniforms), uniforms);
-            float v10 = dequantize_val(get_value(dataTexture, dataSampler, v10_coord, uniforms), uniforms);
-            float v01 = dequantize_val(get_value(dataTexture, dataSampler, v01_coord, uniforms), uniforms);
-            float v11 = dequantize_val(get_value(dataTexture, dataSampler, v11_coord, uniforms), uniforms);
-
-            float p00 = get_ptype_from_physical(v00, uniforms);
-            float p10 = get_ptype_from_physical(v10, uniforms);
-            float p01 = get_ptype_from_physical(v01, uniforms);
-            float p11 = get_ptype_from_physical(v11, uniforms);
-
-            // Determine the dominant precipitation type for this pixel
-            float dominant_ptype = -1.0;
-            if (p00 != -1.0) dominant_ptype = p00;
-            else if (p10 != -1.0) dominant_ptype = p10;
-            else if (p01 != -1.0) dominant_ptype = p01;
-            else if (p11 != -1.0) dominant_ptype = p11;
-            
-            if (dominant_ptype == -1.0) discard_fragment();
-
-            // Interpolate ONLY the values that match the dominant ptype
-            float total_value = 0.0;
-            float total_weight = 0.0;
-            if (p00 == dominant_ptype) { float w = (1.0-f.x)*(1.0-f.y); total_value+=v00*w; total_weight+=w; }
-            if (p10 == dominant_ptype) { float w = f.x*(1.0-f.y);       total_value+=v10*w; total_weight+=w; }
-            if (p01 == dominant_ptype) { float w = (1.0-f.x)*f.y;       total_value+=v01*w; total_weight+=w; }
-            if (p11 == dominant_ptype) { float w = f.x*f.y;             total_value+=v11*w; total_weight+=w; }
-
-            if (total_weight <= 0.0) discard_fragment();
-            raw_value = total_value / total_weight;
-            
-            // Force full alpha to prevent dark borders between ptype regions
-            alpha_multiplier = 1.0;
-
-        } else {
-            // --- STANDARD INTERPOLATION (CONTINUOUS) ---
-            float v00_q = get_value(dataTexture, dataSampler, v00_coord, uniforms);
-            float v10_q = get_value(dataTexture, dataSampler, v10_coord, uniforms);
-            float v01_q = get_value(dataTexture, dataSampler, v01_coord, uniforms);
-            float v11_q = get_value(dataTexture, dataSampler, v11_coord, uniforms);
-
-            float total_value_q = 0.0;
-            float total_weight = 0.0;
-            if (v00_q < 99999.0) { float w = (1.0-f.x)*(1.0-f.y); total_value_q+=v00_q*w; total_weight+=w; }
-            if (v10_q < 99999.0) { float w = f.x*(1.0-f.y);       total_value_q+=v10_q*w; total_weight+=w; }
-            if (v01_q < 99999.0) { float w = (1.0-f.x)*f.y;       total_value_q+=v01_q*w; total_weight+=w; }
-            if (v11_q < 99999.0) { float w = f.x*f.y;             total_value_q+=v11_q*w; total_weight+=w; }
-
-            if (total_weight <= 0.0) discard_fragment();
-            raw_value = dequantize_val(total_value_q / total_weight, uniforms);
-            alpha_multiplier = total_weight; // Feather the edges of the data
-        }
-    }
-
-    // --- COMMON FINAL STEPS ---
-
-    if (raw_value < uniforms.dataRange.x) {
-        discard_fragment();
-    }
-
-    float colormap_coord = (raw_value - uniforms.dataRange.x) / (uniforms.dataRange.y - uniforms.dataRange.x);
-    colormap_coord = clamp(colormap_coord, 0.0, 1.0);
-    
-    float4 color = colormapTexture.sample(colormapSampler, float2(colormap_coord, 0.5));
-    
-    // Discard if the colormap specifies transparency
-    if (color.a < 0.1) {
-        discard_fragment();
-    }
-
-    float final_alpha = color.a * uniforms.opacity * alpha_multiplier;
-    return float4(color.rgb * final_alpha, final_alpha);
+#include <metal_stdlib>
+using namespace metal;
+
+// Struct to match the vertex buffer layout in Swift
+struct Vertex {
+    float2 position [[attribute(0)]];
+    float2 texCoord [[attribute(1)]];
+};
+
+// Struct for passing data from vertex to fragment shader
+struct RasterizerData {
+    float4 position [[position]];
+    float2 texCoord;
+};
+
+// Uniforms passed from the CPU to the fragment shader
+struct FragmentUniforms {
+    float opacity;
+    float2 dataRange;
+    float scale;
+    float offset;
+    float missingQuantized;
+    float2 textureSize;
+    int smoothing;
+    int scaleType;
+    int isPtype;
+    int isMRMS;
+};
+
+// --- Vertex Shader (Unchanged) ---
+vertex RasterizerData vertex_main(const Vertex in [[stage_in]],
+                                  constant float4x4 &mvp [[buffer(1)]]) {
+    RasterizerData out;
+    out.position = mvp * float4(in.position, 0.0, 1.0);
+    out.texCoord = in.texCoord;
+    return out;
+}
+
+
+// --- HELPER FUNCTIONS FOR FRAGMENT SHADER ---
+
+// Dequantizes a signed value (-127 to 127) into a physical value
+float dequantize_val(float q_val, constant FragmentUniforms &uniforms) {
+    if (abs(q_val - uniforms.missingQuantized) < 0.5) {
+        return -9999.0;
+    }
+    float intermediate = q_val * uniforms.scale + uniforms.offset;
+    if (uniforms.scaleType == 1) { // 1 = sqrt
+        return intermediate * abs(intermediate);
+    }
+    return intermediate;
+}
+
+// Samples texture, converts 0-255 to signed -128-127 range.
+// Returns a quantized value, or a large positive sentinel for missing data.
+float get_value(texture2d<float, access::sample> dataTexture, sampler dataSampler, float2 coord, constant FragmentUniforms &uniforms) {
+    // Note: The sampler should be set to 'nearest' when calling this for ptype logic.
+    float value_0_to_255 = dataTexture.sample(dataSampler, coord).r * 255.0;
+    float val = value_0_to_255 - 128.0;
+    float missing_in_texture_range_0_255 = uniforms.missingQuantized + 128.0;
+    if (abs(value_0_to_255 - missing_in_texture_range_0_255) < 0.5) {
+        return 99999.0; // Sentinel for "missing"
+    }
+    return val;
+}
+
+// Maps a physical value to a precipitation type category
+// Maps a physical value to a precipitation type category
+float get_ptype_from_physical(float val, constant FragmentUniforms &uniforms) {  // ADD uniforms parameter
+    if (val < 0.0) return -1.0;
+    
+    if (uniforms.isMRMS == 1) {  // ADD THIS BRANCH
+        // MRMS: 0-100 rain, 100-200 snow, 200-300 freezing rain
+        if (val < 100.0) return 0.0;
+        if (val < 200.0) return 1.0;
+        if (val < 300.0) return 2.0;
+        return -1.0;
+    } else {
+        // Models: 0-100 rain, 100-200 snow, 200-300 freezing rain, 300-400 ice pellets
+        if (val < 100.0) return 0.0;
+        if (val < 200.0) return 1.0;
+        if (val < 300.0) return 2.0;
+        if (val < 400.0) return 3.0;
+        return -1.0;
+    }
+}
+
+// --- Main Fragment Shader ---
+fragment float4 fragment_main(RasterizerData in [[stage_in]],
+                                constant FragmentUniforms &uniforms [[buffer(0)]],
+                                texture2d<float, access::sample> dataTexture [[texture(0)]],
+                                texture2d<float, access::sample> colormapTexture [[texture(1)]],
+                                sampler dataSampler [[sampler(0)]],
+                                sampler colormapSampler [[sampler(1)]])
+{
+    float raw_value;
+    float alpha_multiplier = 1.0; // Used for alpha feathering at data edges
+
+    if (uniforms.smoothing == 0) { // Nearest neighbor
+        float quantized_value = get_value(dataTexture, dataSampler, in.texCoord, uniforms);
+        if (quantized_value >= 99999.0) {
+             discard_fragment();
+        }
+        raw_value = dequantize_val(quantized_value, uniforms);
+
+    } else { // Bilinear interpolation
+        float2 texel_size = 1.0 / uniforms.textureSize;
+        float2 tex_coord_in_texels = in.texCoord * uniforms.textureSize;
+        float2 bl_texel_index = floor(tex_coord_in_texels - 0.5);
+        float2 f = fract(tex_coord_in_texels - 0.5); // Interpolation factors
+
+        // Coordinates of the 4 neighboring texels
+        float2 v00_coord = (bl_texel_index + float2(0.5, 0.5)) * texel_size;
+        float2 v10_coord = (bl_texel_index + float2(1.5, 0.5)) * texel_size;
+        float2 v01_coord = (bl_texel_index + float2(0.5, 1.5)) * texel_size;
+        float2 v11_coord = (bl_texel_index + float2(1.5, 1.5)) * texel_size;
+
+        if (uniforms.isPtype == 1) {
+            // --- ENHANCED PTYPE-SPECIFIC INTERPOLATION ---
+            float v00 = dequantize_val(get_value(dataTexture, dataSampler, v00_coord, uniforms), uniforms);
+            float v10 = dequantize_val(get_value(dataTexture, dataSampler, v10_coord, uniforms), uniforms);
+            float v01 = dequantize_val(get_value(dataTexture, dataSampler, v01_coord, uniforms), uniforms);
+            float v11 = dequantize_val(get_value(dataTexture, dataSampler, v11_coord, uniforms), uniforms);
+
+            float p00 = get_ptype_from_physical(v00, uniforms);
+            float p10 = get_ptype_from_physical(v10, uniforms);
+            float p01 = get_ptype_from_physical(v01, uniforms);
+            float p11 = get_ptype_from_physical(v11, uniforms);
+
+            // Count unique valid precipitation types
+            bool has_type_0 = false;
+            bool has_type_1 = false;
+            bool has_type_2 = false;
+            bool has_type_3 = false;
+            int valid_count = 0;
+            
+            if (p00 >= 0.0) { 
+                int ptype = int(p00);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p10 >= 0.0) { 
+                int ptype = int(p10);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p01 >= 0.0) { 
+                int ptype = int(p01);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            if (p11 >= 0.0) { 
+                int ptype = int(p11);
+                if (ptype == 0) has_type_0 = true;
+                else if (ptype == 1) has_type_1 = true;
+                else if (ptype == 2) has_type_2 = true;
+                else if (ptype == 3) has_type_3 = true;
+                valid_count++; 
+            }
+            
+            if (valid_count == 0) discard_fragment();
+            
+            // Count how many unique types we have
+            int unique_types = 0;
+            if (has_type_0) unique_types++;
+            if (has_type_1) unique_types++;
+            if (has_type_2) unique_types++;
+            if (has_type_3) unique_types++;
+            
+            if (unique_types == 1) {
+                // ALL SAME TYPE - smooth interpolation across all valid pixels
+                float total_value = 0.0;
+                float total_weight = 0.0;
+                
+                if (p00 >= 0.0) {
+                    float weight = (1.0 - f.x) * (1.0 - f.y);
+                    total_value += v00 * weight;
+                    total_weight += weight;
+                }
+                if (p10 >= 0.0) {
+                    float weight = f.x * (1.0 - f.y);
+                    total_value += v10 * weight;
+                    total_weight += weight;
+                }
+                if (p01 >= 0.0) {
+                    float weight = (1.0 - f.x) * f.y;
+                    total_value += v01 * weight;
+                    total_weight += weight;
+                }
+                if (p11 >= 0.0) {
+                    float weight = f.x * f.y;
+                    total_value += v11 * weight;
+                    total_weight += weight;
+                }
+                
+                if (total_weight <= 0.0) discard_fragment();
+                raw_value = total_value / total_weight;
+                
+            } else {
+                // MULTIPLE TYPES - weighted voting to determine dominant type
+                float type_weight_0 = 0.0;
+                float type_weight_1 = 0.0;
+                float type_weight_2 = 0.0;
+                float type_weight_3 = 0.0;
+                
+                if (p00 >= 0.0) {
+                    float w = (1.0 - f.x) * (1.0 - f.y);
+                    int ptype = int(p00);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p10 >= 0.0) {
+                    float w = f.x * (1.0 - f.y);
+                    int ptype = int(p10);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p01 >= 0.0) {
+                    float w = (1.0 - f.x) * f.y;
+                    int ptype = int(p01);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                if (p11 >= 0.0) {
+                    float w = f.x * f.y;
+                    int ptype = int(p11);
+                    if (ptype == 0) type_weight_0 += w;
+                    else if (ptype == 1) type_weight_1 += w;
+                    else if (ptype == 2) type_weight_2 += w;
+                    else if (ptype == 3) type_weight_3 += w;
+                }
+                
+                // Find the type with the highest weight at this pixel location
+                float max_type_weight = 0.0;
+                float winning_type = -1.0;
+                if (type_weight_0 > max_type_weight) { max_type_weight = type_weight_0; winning_type = 0.0; }
+                if (type_weight_1 > max_type_weight) { max_type_weight = type_weight_1; winning_type = 1.0; }
+                if (type_weight_2 > max_type_weight) { max_type_weight = type_weight_2; winning_type = 2.0; }
+                if (type_weight_3 > max_type_weight) { max_type_weight = type_weight_3; winning_type = 3.0; }
+                
+                if (winning_type == -1.0) discard_fragment();
+                
+                // Now smoothly interpolate only among pixels of the winning type
+                float total_value = 0.0;
+                float total_weight = 0.0;
+                
+                if (p00 == winning_type) {
+                    float weight = (1.0 - f.x) * (1.0 - f.y);
+                    total_value += v00 * weight;
+                    total_weight += weight;
+                }
+                if (p10 == winning_type) {
+                    float weight = f.x * (1.0 - f.y);
+                    total_value += v10 * weight;
+                    total_weight += weight;
+                }
+                if (p01 == winning_type) {
+                    float weight = (1.0 - f.x) * f.y;
+                    total_value += v01 * weight;
+                    total_weight += weight;
+                }
+                if (p11 == winning_type) {
+                    float weight = f.x * f.y;
+                    total_value += v11 * weight;
+                    total_weight += weight;
+                }
+                
+                if (total_weight <= 0.0) discard_fragment();
+                raw_value = total_value / total_weight;
+            }
+            
+            // Force full alpha to prevent dark borders between ptype regions
+            alpha_multiplier = 1.0;
+
+        } else {
+            // --- STANDARD INTERPOLATION (CONTINUOUS) ---
+            float v00_q = get_value(dataTexture, dataSampler, v00_coord, uniforms);
+            float v10_q = get_value(dataTexture, dataSampler, v10_coord, uniforms);
+            float v01_q = get_value(dataTexture, dataSampler, v01_coord, uniforms);
+            float v11_q = get_value(dataTexture, dataSampler, v11_coord, uniforms);
+
+            float total_value_q = 0.0;
+            float total_weight = 0.0;
+            if (v00_q < 99999.0) { float w = (1.0-f.x)*(1.0-f.y); total_value_q+=v00_q*w; total_weight+=w; }
+            if (v10_q < 99999.0) { float w = f.x*(1.0-f.y);       total_value_q+=v10_q*w; total_weight+=w; }
+            if (v01_q < 99999.0) { float w = (1.0-f.x)*f.y;       total_value_q+=v01_q*w; total_weight+=w; }
+            if (v11_q < 99999.0) { float w = f.x*f.y;             total_value_q+=v11_q*w; total_weight+=w; }
+
+            if (total_weight <= 0.0) discard_fragment();
+            raw_value = dequantize_val(total_value_q / total_weight, uniforms);
+            alpha_multiplier = total_weight; // Feather the edges of the data
+        }
+    }
+
+    // --- COMMON FINAL STEPS ---
+
+    if (raw_value < uniforms.dataRange.x) {
+        discard_fragment();
+    }
+
+    float colormap_coord = (raw_value - uniforms.dataRange.x) / (uniforms.dataRange.y - uniforms.dataRange.x);
+    colormap_coord = clamp(colormap_coord, 0.0, 1.0);
+    
+    float4 color = colormapTexture.sample(colormapSampler, float2(colormap_coord, 0.5));
+    
+    // Discard if the colormap specifies transparency
+    if (color.a < 0.1) {
+        discard_fragment();
+    }
+
+    float final_alpha = color.a * uniforms.opacity * alpha_multiplier;
+    return float4(color.rgb * final_alpha, final_alpha);
 }