@aguacerowx/react-native 0.0.42 → 0.0.44

package/lib/commonjs/android/build/intermediates/local_only_symbol_list/debug/parseDebugLocalResources/R-def.txt

@@ -3,4 +3,6 @@ local
 raw debug_fragment_shader
 raw debug_vertex_shader
 raw fragment_shader
+raw nexrad_fragment
+raw nexrad_vertex
 raw vertex_shader

package/lib/commonjs/android/build/intermediates/packaged_res/debug/packageDebugResources/raw/nexrad_fragment.glsl

@@ -0,0 +1,87 @@
+precision highp float;
+varying highp vec2 v_uv;
+uniform sampler2D u_gate_texture;
+uniform sampler2D u_lut_texture;
+uniform vec2 u_texture_size;
+uniform vec2 u_value_scale_offset;
+uniform vec2 u_lut_value_range;
+uniform float u_discrete_integer_lut;
+uniform float u_opacity;
+uniform float u_gate_smooth_polar;
+
+float decodeInt16(vec2 encoded) {
+    float hi = floor(encoded.x * 255.0 + 0.5);
+    float lo = floor(encoded.y * 255.0 + 0.5);
+    float raw = lo + hi * 256.0;
+    if (raw >= 32768.0) raw -= 65536.0;
+    return raw;
+}
+
+float sampleGateRawBilinear(vec2 gxy) {
+    vec2 sz = u_texture_size;
+    float x_px = gxy.x * sz.x - 0.5;
+    float y_px = gxy.y * sz.y - 0.5;
+    vec2 i0 = floor(vec2(x_px, y_px));
+    vec2 f = vec2(x_px, y_px) - i0;
+    vec2 i1 = i0 + 1.0;
+    i0.x = clamp(i0.x, 0.0, sz.x - 1.0);
+    i1.x = clamp(i1.x, 0.0, sz.x - 1.0);
+    i0.y = mod(i0.y + sz.y, sz.y);
+    i1.y = mod(i1.y + sz.y, sz.y);
+    float w00 = (1.0 - f.x) * (1.0 - f.y);
+    float w10 = f.x * (1.0 - f.y);
+    float w01 = (1.0 - f.x) * f.y;
+    float w11 = f.x * f.y;
+    vec2 invSz = 1.0 / sz;
+    vec4 p00 = texture2D(u_gate_texture, (vec2(i0.x, i0.y) + 0.5) * invSz);
+    vec4 p10 = texture2D(u_gate_texture, (vec2(i1.x, i0.y) + 0.5) * invSz);
+    vec4 p01 = texture2D(u_gate_texture, (vec2(i0.x, i1.y) + 0.5) * invSz);
+    vec4 p11 = texture2D(u_gate_texture, (vec2(i1.x, i1.y) + 0.5) * invSz);
+    float r00 = decodeInt16(vec2(p00.r, p00.a));
+    float r10 = decodeInt16(vec2(p10.r, p10.a));
+    float r01 = decodeInt16(vec2(p01.r, p01.a));
+    float r11 = decodeInt16(vec2(p11.r, p11.a));
+    float acc = 0.0;
+    float wsum = 0.0;
+    if (r00 > -32768.0) { acc += r00 * w00; wsum += w00; }
+    if (r10 > -32768.0) { acc += r10 * w10; wsum += w10; }
+    if (r01 > -32768.0) { acc += r01 * w01; wsum += w01; }
+    if (r11 > -32768.0) { acc += r11 * w11; wsum += w11; }
+    if (wsum < 1e-6) return -32768.0;
+    return acc / wsum;
+}
+
+float sampleGateRawNearest(vec2 gxy) {
+    vec2 sz = u_texture_size;
+    vec2 px = gxy * sz;
+    vec2 i = floor(px);
+    i.x = clamp(i.x, 0.0, sz.x - 1.0);
+    i.y = mod(i.y + sz.y, sz.y);
+    vec4 p = texture2D(u_gate_texture, (i + 0.5) / sz);
+    return decodeInt16(vec2(p.r, p.a));
+}
+
+void main() {
+    float raw;
+    if (u_gate_smooth_polar < 0.5) {
+        raw = sampleGateRawNearest(v_uv);
+    } else {
+        raw = sampleGateRawBilinear(v_uv);
+    }
+    if (raw <= -32768.0) discard;
+
+    float physical = raw * u_value_scale_offset.x + u_value_scale_offset.y;
+    if (physical < u_lut_value_range.x || physical > u_lut_value_range.y) discard;
+
+    float lutT;
+    if (u_discrete_integer_lut > 0.5) {
+        float n = u_lut_value_range.y - u_lut_value_range.x + 1.0;
+        lutT = (physical - u_lut_value_range.x + 0.5) / max(n, 0.0001);
+    } else {
+        lutT = (physical - u_lut_value_range.x) / max(u_lut_value_range.y - u_lut_value_range.x, 0.0001);
+    }
+    lutT = clamp(lutT, 0.0, 1.0);
+    vec4 color = texture2D(u_lut_texture, vec2(lutT, 0.5));
+    if (color.a <= 0.001) discard;
+    gl_FragColor = vec4(color.rgb, color.a * u_opacity);
+}

package/lib/commonjs/android/build/intermediates/packaged_res/debug/packageDebugResources/raw/nexrad_vertex.glsl

@@ -0,0 +1,9 @@
+precision highp float;
+attribute vec2 a_pos;
+attribute vec2 a_uv;
+varying highp vec2 v_uv;
+uniform mat4 u_matrix;
+void main() {
+    v_uv = a_uv;
+    gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);
+}

package/lib/commonjs/android/build/intermediates/symbol_list_with_package_name/debug/generateDebugRFile/package-aware-r.txt

@@ -2,4 +2,6 @@ com.aguacerowx.reactnative
 raw debug_fragment_shader
 raw debug_vertex_shader
 raw fragment_shader
+raw nexrad_fragment
+raw nexrad_vertex
 raw vertex_shader

package/lib/commonjs/android/build.gradle

@@ -40,6 +40,21 @@ android {
     defaultConfig {
         minSdk 23 
         targetSdk 34
+        ndk {
+            abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
+        }
+        externalNativeBuild {
+            cmake {
+                arguments "-DANDROID_STL=c++_shared"
+            }
+        }
+    }
+
+    externalNativeBuild {
+        cmake {
+            path "src/main/cpp/CMakeLists.txt"
+            version "3.22.1"
+        }
     }
 
     buildTypes {
@@ -71,6 +86,7 @@ dependencies {
     implementation 'com.facebook.react:react-native:+'
     api 'org.locationtech.proj4j:proj4j:1.1.5'
     implementation 'com.github.luben:zstd-jni:1.5.7-6@aar'
+    implementation 'com.squareup.okhttp3:okhttp:4.12.0'
 }
 
 project.afterEvaluate {

package/lib/commonjs/android/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,43 @@
+# Minimal Basis Universal KTX2 transcoder JNI for GOES satellite tiles (parity with mapsgl satelliteKtxWorker.js).
+cmake_minimum_required(VERSION 3.22)
+project(aguacero_satellite_ktx)
+
+set(CMAKE_CXX_STANDARD 17)
+
+include(FetchContent)
+FetchContent_Declare(
+        basis_universal
+        GIT_REPOSITORY https://github.com/BinomialLLC/basis_universal.git
+        GIT_TAG master
+        GIT_SHALLOW TRUE
+)
+# Do NOT use FetchContent_MakeAvailable: upstream CMake always builds the `basisu` CLI and links
+# `-lpthread`, which fails on Android NDK (no separate libpthread). We only need transcoder sources.
+FetchContent_GetProperties(basis_universal)
+if(NOT basis_universal_POPULATED)
+    FetchContent_Populate(basis_universal)
+endif()
+
+set(BASIS_DIR "${basis_universal_SOURCE_DIR}")
+
+add_library(basisu_transcoder_min STATIC
+        ${BASIS_DIR}/transcoder/basisu_transcoder.cpp
+        ${BASIS_DIR}/zstd/zstddeclib.c
+)
+
+target_include_directories(basisu_transcoder_min PUBLIC
+        ${BASIS_DIR}/transcoder
+        ${BASIS_DIR}/zstd
+)
+
+target_compile_options(basisu_transcoder_min PRIVATE -fno-strict-aliasing)
+
+add_library(aguacero_satellite_ktx SHARED satellite_ktx_jni.cpp)
+
+target_include_directories(aguacero_satellite_ktx PRIVATE
+        ${BASIS_DIR}/transcoder
+)
+
+target_link_libraries(aguacero_satellite_ktx PRIVATE basisu_transcoder_min log)
+
+target_compile_options(aguacero_satellite_ktx PRIVATE -fno-strict-aliasing)

package/lib/commonjs/android/src/main/cpp/satellite_ktx_jni.cpp

@@ -0,0 +1,165 @@
+#include <android/log.h>
+#include <jni.h>
+#include <cstring>
+#include <mutex>
+#include <vector>
+
+#include "basisu_transcoder.h"
+
+#define LOG_TAG "AguaceroSatKtx"
+#define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
+
+namespace {
+
+std::once_flag g_basis_init;
+
+void ensure_basis_init() {
+    std::call_once(g_basis_init, []() { basist::basisu_transcoder_init(); });
+}
+
+bool try_transcode(
+        basist::ktx2_transcoder &transcoder,
+        basist::transcoder_texture_format fmt,
+        uint32_t decode_flags,
+        uint32_t width,
+        uint32_t height,
+        std::vector<uint8_t> &out,
+        basist::transcoder_texture_format &out_fmt_used) {
+    if (!basist::basis_is_format_supported(fmt, transcoder.get_basis_tex_format())) {
+        return false;
+    }
+
+    const uint32_t total_bytes =
+            basist::basis_compute_transcoded_image_size_in_bytes(fmt, width, height);
+    const uint32_t bytes_per =
+            basist::basis_get_bytes_per_block_or_pixel(fmt);
+    if (bytes_per == 0 || total_bytes == 0) {
+        return false;
+    }
+
+    const uint32_t total_blocks = total_bytes / bytes_per;
+    out.resize(total_bytes);
+
+    if (!transcoder.transcode_image_level(
+                0,
+                0,
+                0,
+                out.data(),
+                total_blocks,
+                fmt,
+                decode_flags)) {
+        out.clear();
+        return false;
+    }
+
+    out_fmt_used = fmt;
+    return true;
+}
+
+} // namespace
+
+extern "C" JNIEXPORT jbyteArray JNICALL
+Java_com_aguacerowx_reactnative_SatelliteKtxDecoder_nativeTranscodeKtx2(
+        JNIEnv *env,
+        jclass /* clazz */,
+        jbyteArray ktx2_java,
+        jint decode_flags) {
+    ensure_basis_init();
+
+    if (ktx2_java == nullptr) {
+        return nullptr;
+    }
+
+    const jsize ktx_len = env->GetArrayLength(ktx2_java);
+    if (ktx_len <= 0) {
+        return nullptr;
+    }
+
+    std::vector<uint8_t> ktx_data(static_cast<size_t>(ktx_len));
+    env->GetByteArrayRegion(
+            ktx2_java,
+            0,
+            ktx_len,
+            reinterpret_cast<jbyte *>(ktx_data.data()));
+
+    basist::ktx2_transcoder transcoder;
+    if (!transcoder.init(ktx_data.data(), static_cast<uint32_t>(ktx_data.size()))) {
+        ALOGW("ktx2_transcoder.init failed");
+        return nullptr;
+    }
+
+    if (transcoder.is_hdr()) {
+        ALOGW("HDR KTX2 not supported");
+        return nullptr;
+    }
+
+    if (!transcoder.start_transcoding()) {
+        ALOGW("start_transcoding failed");
+        return nullptr;
+    }
+
+    const uint32_t width = transcoder.get_width();
+    const uint32_t height = transcoder.get_height();
+
+    std::vector<uint8_t> out_pixels;
+    basist::transcoder_texture_format used_fmt = basist::transcoder_texture_format::cTFTotalTextureFormats;
+
+    static const basist::transcoder_texture_format k_try_order[] = {
+            basist::transcoder_texture_format::cTFASTC_LDR_4x4_RGBA,
+            basist::transcoder_texture_format::cTFETC2_RGBA,
+            basist::transcoder_texture_format::cTFRGBA32,
+    };
+
+    bool ok = false;
+    for (basist::transcoder_texture_format fmt : k_try_order) {
+        if (try_transcode(
+                    transcoder,
+                    fmt,
+                    static_cast<uint32_t>(decode_flags),
+                    width,
+                    height,
+                    out_pixels,
+                    used_fmt)) {
+            ok = true;
+            break;
+        }
+    }
+
+    if (!ok || out_pixels.empty()) {
+        ALOGW("all transcode attempts failed");
+        return nullptr;
+    }
+
+    const int32_t fmt_ordinal = static_cast<int32_t>(used_fmt);
+
+    const uint32_t header_size = 20;
+    const uint32_t payload_size = static_cast<uint32_t>(out_pixels.size());
+    const jsize total_out = static_cast<jsize>(header_size + payload_size);
+
+    jbyteArray result = env->NewByteArray(total_out);
+    if (result == nullptr) {
+        return nullptr;
+    }
+
+    uint8_t header[20];
+    header[0] = 'A';
+    header[1] = 'G';
+    header[2] = 'S';
+    header[3] = '1';
+    uint32_t w_le = width;
+    uint32_t h_le = height;
+    uint32_t psz_le = payload_size;
+    std::memcpy(header + 4, &w_le, 4);
+    std::memcpy(header + 8, &h_le, 4);
+    std::memcpy(header + 12, &fmt_ordinal, 4);
+    std::memcpy(header + 16, &psz_le, 4);
+
+    env->SetByteArrayRegion(result, 0, 20, reinterpret_cast<const jbyte *>(header));
+    env->SetByteArrayRegion(
+            result,
+            20,
+            static_cast<jsize>(payload_size),
+            reinterpret_cast<const jbyte *>(out_pixels.data()));
+
+    return result;
+}

package/lib/commonjs/android/src/main/java/com/aguacerowx/reactnative/AguaceroDebugLog.java

@@ -0,0 +1,12 @@
+package com.aguacerowx.reactnative;
+
+/**
+ * Gate verbose Aguacero logs. NEXRAD perf / bridge tracing is off by default so logcat stays usable
+ * while debugging readouts (filter {@code [Aguacero][NEXRAD][READOUT]} in Metro).
+ */
+public final class AguaceroDebugLog {
+    private AguaceroDebugLog() {}
+
+    /** When true, emit NEXRAD bridge / GL perf {@code Log.i} lines (very noisy). */
+    public static final boolean NEXRAD_NATIVE_VERBOSE = false;
+}