@aguacerowx/react-native 0.0.20 → 0.0.22

package/lib/module/ios/Shaders.metal

@@ -22,7 +22,9 @@ struct FragmentUniforms {
     float missingQuantized;
     float2 textureSize;
     int smoothing;
-    int scaleType; // 0 for linear, 1 for sqrt
+    int scaleType;
+    int isPtype;
+    int isMRMS;
 };
 
 // --- Vertex Shader (Unchanged) ---
@@ -34,52 +36,56 @@ vertex RasterizerData vertex_main(const Vertex in [[stage_in]],
     return out;
 }
 
-float sampleDataTextureSmooth(
-    texture2d<float, access::sample> dataTexture,
-    sampler dataSampler,
-    float2 uv,
-    constant FragmentUniforms &uniforms)
-{
-    float missing_value = uniforms.missingQuantized + 128.0;
-
-    // Calculate the fractional part for interpolation and the size of one texel.
-    float2 texel_size = 1.0 / uniforms.textureSize;
-    float2 pixel_coord = uv * uniforms.textureSize;
-    float2 pixel_floor = floor(pixel_coord - 0.5);
-    float2 f = fract(pixel_coord - 0.5);
-
-    // Calculate the precise UV coordinates for the CENTER of the four surrounding texels.
-    float2 uv00 = (pixel_floor + float2(0.5, 0.5)) * texel_size;
-    float2 uv10 = (pixel_floor + float2(1.5, 0.5)) * texel_size;
-    float2 uv01 = (pixel_floor + float2(0.5, 1.5)) * texel_size;
-    float2 uv11 = (pixel_floor + float2(1.5, 1.5)) * texel_size;
-
-    // Sample the four corner texels.
-    float s00 = dataTexture.sample(dataSampler, uv00).r * 255.0;
-    float s10 = dataTexture.sample(dataSampler, uv10).r * 255.0;
-    float s01 = dataTexture.sample(dataSampler, uv01).r * 255.0;
-    float s11 = dataTexture.sample(dataSampler, uv11).r * 255.0;
-
-    // THE CRITICAL CHECK: If any surrounding pixel is a "missing" value,
-    // treat this entire fragment as missing to prevent interpolation.
-    if (abs(s00 - missing_value) < 0.5 ||
-        abs(s10 - missing_value) < 0.5 ||
-        abs(s01 - missing_value) < 0.5 ||
-        abs(s11 - missing_value) < 0.5)
-    {
-        return missing_value;
+
+// --- 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;
+}
 
-    // All neighbors are valid data, so we can safely perform manual bilinear interpolation.
-    float s0 = mix(s00, s10, f.x); // Interpolate the top row
-    float s1 = mix(s01, s11, f.x); // Interpolate the bottom row
+// 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;
     
-    // --- THE FIX IS HERE ---
-    // Remove the incorrect "1.0 - f.y" inversion. The vertical mix should use f.y directly.
-    return mix(s0, s1, f.y);
+    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;
+    }
 }
 
-// --- Fragment Shader (NEW & IMPROVED) ---
+// --- Main Fragment Shader ---
 fragment float4 fragment_main(RasterizerData in [[stage_in]],
                                 constant FragmentUniforms &uniforms [[buffer(0)]],
                                 texture2d<float, access::sample> dataTexture [[texture(0)]],
@@ -87,45 +93,99 @@ fragment float4 fragment_main(RasterizerData in [[stage_in]],
                                 sampler dataSampler [[sampler(0)]],
                                 sampler colormapSampler [[sampler(1)]])
 {
-    // Choose the sampling method based on the smoothing uniform.
-    float value_in_texture;
-    if (uniforms.smoothing == 1) {
-        // Use our custom function that prevents edge artifacts.
-        value_in_texture = sampleDataTextureSmooth(dataTexture, dataSampler, in.texCoord, uniforms);
-    } else {
-        // Smoothing is off. The sampler is already set to 'nearest' by the Swift code,
-        // so a standard sample call produces the correct pixelated result.
-        value_in_texture = dataTexture.sample(dataSampler, in.texCoord).r * 255.0;
-    }
+    float raw_value;
+    float alpha_multiplier = 1.0; // Used for alpha feathering at data edges
 
-    float missing_value = uniforms.missingQuantized + 128.0;
+    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);
 
-    // Discard if the pixel is a predefined missing value (either originally or from our function).
-    if (abs(value_in_texture - missing_value) < 0.5) {
-        discard_fragment();
-    }
+    } 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
 
-    // Dequantize the value to its real-world representation.
-    float quantized_value = value_in_texture - 128.0;
-    float intermediate_value = quantized_value * uniforms.scale + uniforms.offset;
-    float raw_value = intermediate_value;
-    
-    // Apply non-linear inverse scaling if specified.
-    if (uniforms.scaleType == 1) { // 'sqrt'
-        raw_value = intermediate_value * abs(intermediate_value);
+        // 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
+        }
     }
-    
-    // Discard if the data is below the specified visible range.
+
+    // --- COMMON FINAL STEPS ---
+
     if (raw_value < uniforms.dataRange.x) {
         discard_fragment();
     }
-    
-    // Normalize the value to a 0-1 coordinate for colormap lookup.
+
     float colormap_coord = (raw_value - uniforms.dataRange.x) / (uniforms.dataRange.y - uniforms.dataRange.x);
     colormap_coord = clamp(colormap_coord, 0.0, 1.0);
     
-    // Sample the colormap and apply final opacity.
     float4 color = colormapTexture.sample(colormapSampler, float2(colormap_coord, 0.5));
     
-    return float4(color.rgb, color.a * uniforms.opacity);
+    // 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);
 }

package/lib/module/lib/commonjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/react-native",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "Native weather rendering for React Native",
   "license": "ISC",
   "author": "Michael Barletta",
@@ -28,7 +28,7 @@
     "android/src/main/java/com/facebook/react/viewmanagers"
   ],
   "scripts": {
-    "compile-shaders": "./scripts/compile-shaders.sh",
+    "compile-shaders": "node scripts/compile-shaders.js",
     "clean": "node -e \"require('fs').rmSync('lib', {recursive: true, force: true})\"",
     "build": "npm run compile-shaders && npm run clean && bob build",
     "prepare": "npm run build"
@@ -44,7 +44,7 @@
     "react-native-device-info": ">=10.0.0"
   },
   "dependencies": {
-    "@aguacerowx/javascript-sdk": "^0.0.11",
+    "@aguacerowx/javascript-sdk": "^0.0.15",
     "base64-js": "^1.5.1"
   },
   "react-native-builder-bob": {

package/lib/module/lib/commonjs/scripts/compile-shaders.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+"use strict";
+
+const {
+  execSync
+} = require('child_process');
+const os = require('os');
+
+// Check if we're on macOS
+if (os.platform() !== 'darwin') {
+  console.log('⏭️  Skipping shader compilation (macOS only)');
+  process.exit(0);
+}
+
+// Check if xcrun is available
+try {
+  execSync('which xcrun', {
+    stdio: 'ignore'
+  });
+} catch (error) {
+  console.log('⚠️  xcrun not found. Skipping shader compilation.');
+  process.exit(0);
+}
+console.log('🔨 Compiling Metal shaders for all platforms...');
+const SHADER_DIR = 'ios';
+const OUTPUT_DIR = 'ios/compiled-shaders';
+try {
+  // Create output directory
+  execSync(`mkdir -p "${OUTPUT_DIR}"`, {
+    stdio: 'inherit'
+  });
+
+  // Compile for iOS Device (arm64)
+  console.log('  📱 Compiling for iOS device...');
+  execSync(`xcrun -sdk iphoneos metal -c "${SHADER_DIR}/Shaders.metal" -o "${OUTPUT_DIR}/Shaders-device.air"`, {
+    stdio: 'inherit'
+  });
+  execSync(`xcrun -sdk iphoneos metallib "${OUTPUT_DIR}/Shaders-device.air" -o "${OUTPUT_DIR}/Shaders-device.metallib"`, {
+    stdio: 'inherit'
+  });
+
+  // Compile for iOS Simulator (x86_64 + arm64)
+  console.log('  💻 Compiling for iOS simulator...');
+  execSync(`xcrun -sdk iphonesimulator metal -c "${SHADER_DIR}/Shaders.metal" -o "${OUTPUT_DIR}/Shaders-simulator.air"`, {
+    stdio: 'inherit'
+  });
+  execSync(`xcrun -sdk iphonesimulator metallib "${OUTPUT_DIR}/Shaders-simulator.air" -o "${OUTPUT_DIR}/Shaders-simulator.metallib"`, {
+    stdio: 'inherit'
+  });
+
+  // Clean up intermediate files
+  execSync(`rm "${OUTPUT_DIR}"/*.air`, {
+    stdio: 'inherit'
+  });
+  console.log('✅ Metal shaders compiled:');
+  console.log(`   - Device: ${OUTPUT_DIR}/Shaders-device.metallib`);
+  console.log(`   - Simulator: ${OUTPUT_DIR}/Shaders-simulator.metallib`);
+} catch (error) {
+  console.error('❌ Shader compilation failed:', error.message);
+  process.exit(1);
+}
+//# sourceMappingURL=compile-shaders.js.map

package/lib/module/lib/commonjs/scripts/compile-shaders.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["execSync","require","os","platform","console","log","process","exit","stdio","error","SHADER_DIR","OUTPUT_DIR","message"],"sourceRoot":"../../..","sources":["scripts/compile-shaders.js"],"mappings":"AAAA;AAAmB;;AAEnB,MAAM;EAAEA;AAAS,CAAC,GAAGC,OAAO,CAAC,eAAe,CAAC;AAC7C,MAAMC,EAAE,GAAGD,OAAO,CAAC,IAAI,CAAC;;AAExB;AACA,IAAIC,EAAE,CAACC,QAAQ,CAAC,CAAC,KAAK,QAAQ,EAAE;EAC5BC,OAAO,CAACC,GAAG,CAAC,8CAA8C,CAAC;EAC3DC,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC;AACnB;;AAEA;AACA,IAAI;EACAP,QAAQ,CAAC,aAAa,EAAE;IAAEQ,KAAK,EAAE;EAAS,CAAC,CAAC;AAChD,CAAC,CAAC,OAAOC,KAAK,EAAE;EACZL,OAAO,CAACC,GAAG,CAAC,mDAAmD,CAAC;EAChEC,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC;AACnB;AAEAH,OAAO,CAACC,GAAG,CAAC,iDAAiD,CAAC;AAE9D,MAAMK,UAAU,GAAG,KAAK;AACxB,MAAMC,UAAU,GAAG,sBAAsB;AAEzC,IAAI;EACA;EACAX,QAAQ,CAAC,aAAaW,UAAU,GAAG,EAAE;IAAEH,KAAK,EAAE;EAAU,CAAC,CAAC;;EAE1D;EACAJ,OAAO,CAACC,GAAG,CAAC,kCAAkC,CAAC;EAC/CL,QAAQ,CAAC,iCAAiCU,UAAU,uBAAuBC,UAAU,sBAAsB,EAAE;IAAEH,KAAK,EAAE;EAAU,CAAC,CAAC;EAClIR,QAAQ,CAAC,iCAAiCW,UAAU,4BAA4BA,UAAU,2BAA2B,EAAE;IAAEH,KAAK,EAAE;EAAU,CAAC,CAAC;;EAE5I;EACAJ,OAAO,CAACC,GAAG,CAAC,qCAAqC,CAAC;EAClDL,QAAQ,CAAC,wCAAwCU,UAAU,uBAAuBC,UAAU,yBAAyB,EAAE;IAAEH,KAAK,EAAE;EAAU,CAAC,CAAC;EAC5IR,QAAQ,CAAC,wCAAwCW,UAAU,+BAA+BA,UAAU,8BAA8B,EAAE;IAAEH,KAAK,EAAE;EAAU,CAAC,CAAC;;EAEzJ;EACAR,QAAQ,CAAC,OAAOW,UAAU,SAAS,EAAE;IAAEH,KAAK,EAAE;EAAU,CAAC,CAAC;EAE1DJ,OAAO,CAACC,GAAG,CAAC,2BAA2B,CAAC;EACxCD,OAAO,CAACC,GAAG,CAAC,gBAAgBM,UAAU,0BAA0B,CAAC;EACjEP,OAAO,CAACC,GAAG,CAAC,mBAAmBM,UAAU,6BAA6B,CAAC;AAC3E,CAAC,CAAC,OAAOF,KAAK,EAAE;EACZL,OAAO,CAACK,KAAK,CAAC,8BAA8B,EAAEA,KAAK,CAACG,OAAO,CAAC;EAC5DN,OAAO,CAACC,IAAI,CAAC,CAAC,CAAC;AACnB","ignoreList":[]}

package/lib/module/lib/commonjs/src/WeatherLayerManager.js

@@ -180,6 +180,14 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
       forecastHour,
       mrmsTimestamp
     } = state;
+
+    // NEW: Fix the current forecast hour if it's invalid for this variable/model combo
+    let effectiveForecastHour = forecastHour;
+    if (!isMRMS && variable === 'ptypeRefl' && model === 'hrrr' && forecastHour === 0) {
+      const validHours = availableHours.filter(hour => hour !== 0);
+      effectiveForecastHour = validHours.length > 0 ? validHours[0] : 0;
+      console.log(`⚠️ [Preload] Correcting invalid hour 0 to ${effectiveForecastHour} for HRRR ptypeRefl`);
+    }
     if (!cachedGeometry.current || !cachedColormap.current) {
       const gridModel = isMRMS ? 'mrms' : model;
       const {
@@ -197,7 +205,18 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
       } = core._getColormapForVariable(variable);
       const toUnit = core._getTargetUnit(baseUnit, units);
       const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-      const dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+      let dataRange;
+      if (variable === 'ptypeRefl' || variable === 'ptypeRate') {
+        if (isMRMS) {
+          console.log('🔧 Using MRMS ptype data range: 5-380');
+          dataRange = [5, 380];
+        } else {
+          console.log('🔧 Using Model ptype data range: 5-380');
+          dataRange = [5, 380];
+        }
+      } else {
+        dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+      }
       const colormapBytes = _generateColormapBytes(finalColormap);
       const colormapAsBase64 = (0, _base64Js.fromByteArray)(colormapBytes);
       gridLayerRef.current.updateColormapTexture(colormapAsBase64);
@@ -211,12 +230,18 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
       });
       hasInitialLoad.current = true;
     }
-    const allFrames = isMRMS ? availableTimestamps : availableHours;
+
+    // Apply the same filtering logic as in AguaceroCore._emitStateChange
+    let filteredHours = availableHours;
+    if (!isMRMS && variable === 'ptypeRefl' && model === 'hrrr' && availableHours && availableHours.length > 0) {
+      filteredHours = availableHours.filter(hour => hour !== 0);
+    }
+    const allFrames = isMRMS ? availableTimestamps : filteredHours;
     if (!allFrames || allFrames.length === 0) {
       console.warn('🟡 [preloadAllFramesToDisk] No frames available to download.');
       return;
     }
-    const currentFrame = isMRMS ? mrmsTimestamp : forecastHour;
+    const currentFrame = isMRMS ? mrmsTimestamp : effectiveForecastHour;
     const prioritizedFrames = [currentFrame, ...allFrames.filter(frame => frame !== currentFrame)];
     console.log(`[Preload] Prioritizing frame: ${currentFrame}. Total frames: ${prioritizedFrames.length}`);
     const {
@@ -230,7 +255,7 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
     prioritizedFrames.forEach((frame, index) => {
       const cacheKey = isMRMS ? `mrms-${frame}-${variable}` : `${model}-${date}-${run}-${frame}-${variable}`;
       if (preloadedDataCache.current.has(cacheKey)) {
-        return; // Use 'return' here as it's a forEach loop
+        return;
       }
       let resourcePath;
       if (isMRMS) {
@@ -259,8 +284,6 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
         const toUnit = core._getTargetUnit(baseUnit, units);
         let dataScale = result.scale;
         let dataOffset = result.offset;
-
-        // Calculate converted values for immediate use
         let convertedScale = dataScale;
         let convertedOffset = dataOffset;
         if (baseUnit !== toUnit) {
@@ -281,22 +304,18 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
             }
           }
         }
-
-        // Store with ORIGINAL values for unit conversion later
         const frameData = {
           filePath: result.filePath,
           nx,
           ny,
           scale: convertedScale,
-          // Current converted values
           offset: convertedOffset,
           missing: result.missing,
           corners,
           gridDef,
           scaleType: result.scaleType,
           originalScale: result.scale,
-          // CRITICAL: Always original
-          originalOffset: result.offset // CRITICAL: Always original
+          originalOffset: result.offset
         };
         preloadedDataCache.current.set(cacheKey, frameData);
         const isCurrentFrame = index === 0;
@@ -321,14 +340,11 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
                 nx: frameData.nx,
                 ny: frameData.ny,
                 scale: frameData.scale,
-                // Current converted scale
                 offset: frameData.offset,
-                // Current converted offset
                 missing: frameData.missing,
                 scaleType: frameData.scaleType || 'linear',
                 originalScale: frameData.originalScale,
-                // ADD THIS
-                originalOffset: frameData.originalOffset // ADD THIS
+                originalOffset: frameData.originalOffset
               }
             };
             gridLayerRef.current.primeGpuCache(frameInfoForGpu);
@@ -402,7 +418,16 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
       } = core._getColormapForVariable(variable);
       const toUnit = core._getTargetUnit(baseUnit, units);
       const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-      const dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+      let dataRange;
+      if (variable === 'ptypeRefl' || variable === 'ptypeRate') {
+        if (isMRMS) {
+          dataRange = [5, 380];
+        } else {
+          dataRange = [5, 380];
+        }
+      } else {
+        dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+      }
       const colormapBytes = _generateColormapBytes(finalColormap);
       const colormapAsBase64 = (0, _base64Js.fromByteArray)(colormapBytes);
       gridLayerRef.current.updateColormapTexture(colormapAsBase64);
@@ -617,7 +642,16 @@ const WeatherLayerManager = exports.WeatherLayerManager = /*#__PURE__*/(0, _reac
             colormap
           } = core._getColormapForVariable(variable);
           const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-          const dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+          let dataRange;
+          if (variable === 'ptypeRefl' || variable === 'ptypeRate') {
+            if (isMRMS) {
+              dataRange = [5, 380];
+            } else {
+              dataRange = [5, 380];
+            }
+          } else {
+            dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+          }
           const colormapBytes = _generateColormapBytes(finalColormap);
           const colormapAsBase64 = (0, _base64Js.fromByteArray)(colormapBytes);
           gridLayerRef.current.updateColormapTexture(colormapAsBase64);