react-native-cesium 1.0.1

package/android/src/main/cpp/vulkan/VulkanBackend.h

@@ -0,0 +1,190 @@
+#pragma once
+
+#include "renderer/IGPUBackend.hpp"
+
+#define VK_USE_PLATFORM_ANDROID_KHR
+#include <vulkan/vulkan.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <deque>
+#include <mutex>
+#include <vector>
+
+namespace reactnativecesium {
+
+struct VulkanTexture {
+  VkImage         image         = VK_NULL_HANDLE;
+  VkDeviceMemory  memory        = VK_NULL_HANDLE;
+  VkImageView     imageView     = VK_NULL_HANDLE;
+  VkSampler       sampler       = VK_NULL_HANDLE;
+  VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
+};
+
+class VulkanBackend : public IGPUBackend {
+public:
+  VulkanBackend();
+  ~VulkanBackend() override;
+
+  void initialize(void* nativeSurface, int width, int height) override;
+  void resize(int width, int height) override;
+  void shutdown() override;
+
+  void beginFrame(const FrameParams& params) override;
+  void drawScene(const FrameResult& frame) override;
+  void endFrame() override;
+
+  void* createRasterTexture(const uint8_t* pixels, int32_t width, int32_t height);
+  void  freeRasterTexture(void* tex);
+
+  // Water mask textures — same pixel format but allocated from a separate pool
+  // so they can be bound at descriptor set 2 (vs imagery at set 1).
+  void* createWaterMaskTexture(const uint8_t* pixels, int32_t width, int32_t height);
+  void  freeWaterMaskTexture(void* tex);
+
+  void setMsaaSampleCount(int sampleCount);
+
+private:
+  void createInstance();
+  void pickPhysicalDevice();
+  void createDevice();
+  void createSwapchain();
+  void createRenderPass();
+  void createDepthResources();
+  void createFramebuffers();
+  void createCommandPool();
+  void createCommandBuffers();
+  void createSyncObjects();
+  void createDescriptorSetLayout();
+  void createPipelineLayout();
+  void createSkyPipeline();
+  void createTerrainPipeline();
+  void createFallbackTexture();
+  void createDescriptorPool();
+  void createWaterMaskPool();
+  void createWaterMaskFallback();
+
+  void cleanupSwapchain();
+  void recreateSwapchain();
+
+  VkFormat pickDepthFormat() const;
+
+  uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags props);
+  void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage,
+                    VkMemoryPropertyFlags props, VkBuffer& buffer,
+                    VkDeviceMemory& memory);
+  void ensureBuffer(VkBuffer& buffer, VkDeviceMemory& memory, size_t& capacity,
+                    size_t needed, const void* data, VkBufferUsageFlags usage);
+  VkCommandBuffer beginSingleTimeCommands();
+  void endSingleTimeCommands(VkCommandBuffer commandBuffer);
+
+  // Upload pixel data from a staging buffer into image, transitioning layout
+  // UNDEFINED → TRANSFER_DST → SHADER_READ_ONLY in a single command buffer.
+  void uploadToImage(VkBuffer staging, VkImage image, uint32_t width, uint32_t height);
+
+  void* window_ = nullptr; // ANativeWindow*
+
+  VkInstance               instance_       = VK_NULL_HANDLE;
+  VkPhysicalDevice         physicalDevice_ = VK_NULL_HANDLE;
+  VkDevice                 device_         = VK_NULL_HANDLE;
+  VkQueue                  graphicsQueue_  = VK_NULL_HANDLE;
+  VkQueue                  presentQueue_   = VK_NULL_HANDLE;
+  uint32_t                 graphicsFamily_ = 0;
+  VkSurfaceKHR             surface_        = VK_NULL_HANDLE;
+  VkSwapchainKHR           swapchain_      = VK_NULL_HANDLE;
+  VkFormat                 swapchainFormat_    = VK_FORMAT_UNDEFINED;
+  VkFormat                 depthFormat_        = VK_FORMAT_D32_SFLOAT;
+  VkExtent2D               swapchainExtent_    = {0, 0};
+  std::vector<VkImage>     swapchainImages_;
+  std::vector<VkImageView> swapchainImageViews_;
+
+  VkRenderPass             renderPass_     = VK_NULL_HANDLE;
+  std::vector<VkFramebuffer> framebuffers_;
+
+  VkImage        depthImage_      = VK_NULL_HANDLE;
+  VkDeviceMemory depthMemory_     = VK_NULL_HANDLE;
+  VkImageView    depthImageView_  = VK_NULL_HANDLE;
+
+  VkCommandPool              commandPool_ = VK_NULL_HANDLE;
+  std::vector<VkCommandBuffer> commandBuffers_;
+
+  VkDescriptorSetLayout terrainDescSetLayout_ = VK_NULL_HANDLE; // set 0: UBO
+  VkDescriptorSetLayout terrainTexLayout_     = VK_NULL_HANDLE; // set 1: texture
+  VkDescriptorSetLayout skyDescSetLayout_     = VK_NULL_HANDLE;
+  VkPipelineLayout      terrainPipelineLayout_ = VK_NULL_HANDLE;
+  VkPipelineLayout      skyPipelineLayout_     = VK_NULL_HANDLE;
+  VkPipeline            terrainPipeline_       = VK_NULL_HANDLE;
+  VkPipeline            skyPipeline_           = VK_NULL_HANDLE;
+
+  VkDescriptorPool descriptorPool_     = VK_NULL_HANDLE;
+  VkDescriptorPool waterMaskPool_      = VK_NULL_HANDLE;
+
+  VulkanTexture   fallbackTexture_;
+  VkDescriptorSet fallbackTexDescSet_     = VK_NULL_HANDLE;
+  VulkanTexture   fallbackWaterMaskTex_;
+  VkDescriptorSet fallbackWaterMaskDescSet_ = VK_NULL_HANDLE;
+
+  // Sky UBO — persistently mapped
+  VkBuffer        skyUboBuffer_  = VK_NULL_HANDLE;
+  VkDeviceMemory  skyUboMemory_  = VK_NULL_HANDLE;
+  void*           skyUboMapped_  = nullptr;
+  VkDescriptorSet skyDescSet_    = VK_NULL_HANDLE;
+
+  static constexpr int kMaxFramesInFlight = 3;
+  // Upper bound on simultaneously live raster overlay textures.
+  // Cesium can cache many hundreds of tiles at high zoom; 2048 gives headroom.
+  static constexpr int kMaxRasterTextures = 2048;
+
+  std::vector<VkSemaphore> imageAvailableSemaphores_;
+  std::vector<VkSemaphore> renderFinishedSemaphores_;
+  std::vector<VkFence>     inFlightFences_;
+  int      frameIndex_  = 0;
+  uint32_t imageIndex_  = 0;
+  bool     frameBegan_  = false;
+
+  // Triple-buffered persistent vertex/index/UV/altitude buffers
+  VkBuffer       vtxBufs_[kMaxFramesInFlight] = {};
+  VkDeviceMemory vtxMems_[kMaxFramesInFlight] = {};
+  size_t         vtxCaps_[kMaxFramesInFlight] = {};
+
+  VkBuffer       idxBufs_[kMaxFramesInFlight] = {};
+  VkDeviceMemory idxMems_[kMaxFramesInFlight] = {};
+  size_t         idxCaps_[kMaxFramesInFlight] = {};
+
+  VkBuffer       uvBufs_[kMaxFramesInFlight]  = {};
+  VkDeviceMemory uvMems_[kMaxFramesInFlight]  = {};
+  size_t         uvCaps_[kMaxFramesInFlight]  = {};
+
+  VkBuffer       altBufs_[kMaxFramesInFlight] = {};  // float altitude per vertex
+  VkDeviceMemory altMems_[kMaxFramesInFlight] = {};
+  size_t         altCaps_[kMaxFramesInFlight] = {};
+
+  // Per-frame UBO: just cameraEcef (fragment stage, used for lighting vd).
+  // MVP is now per-draw via push constants.
+  VkBuffer        terrainUboBufs_[kMaxFramesInFlight] = {};
+  VkDeviceMemory  terrainUboMems_[kMaxFramesInFlight] = {};
+  void*           terrainUboMapped_[kMaxFramesInFlight] = {};
+  VkDescriptorSet terrainDescSets_[kMaxFramesInFlight] = {};
+
+  int  viewportWidth_  = 0;
+  int  viewportHeight_ = 0;
+  bool needsSwapchainRecreate_ = false;
+
+  // Deferred texture deletion — freeRasterTexture enqueues here so no GPU stall
+  // on eviction; beginFrame flushes entries old enough to be safe.
+  // pool identifies which VkDescriptorPool owns the descriptor set; if
+  // VK_NULL_HANDLE the fallback / UBO pool (descriptorPool_) is used.
+  struct PendingDelete {
+    VulkanTexture*   tex;
+    uint64_t         frameIndex;
+    VkDescriptorPool pool = VK_NULL_HANDLE;
+  };
+  std::deque<PendingDelete> pendingDeletes_;
+  std::mutex                pendingDeletesMutex_;
+  uint64_t                  totalFrameCount_ = 0;
+
+  void flushPendingDeletes();
+  void destroyTexture(VulkanTexture* tex, VkDescriptorPool pool);
+};
+
+} // namespace reactnativecesium

package/android/src/main/cpp/vulkan/shaders/sky.frag

@@ -0,0 +1,86 @@
+#version 450
+
+layout(set = 0, binding = 0) uniform SkyUniforms {
+  mat4 invVP;
+  vec4 cameraEcef;
+  vec4 lightDir;
+} u;
+
+layout(location = 0) in vec2 ndc;
+layout(location = 0) out vec4 outColor;
+
+const float ER = 6371000.0, AR = ER + 111000.0;
+const vec3 RAY = vec3(3.2e-6, 8.5e-6, 38e-6), MIE3 = vec3(1.8e-6, 1.8e-6, 1.8e-6);
+const float MG = 0.76, LINT = 18.0;
+
+vec2 rsi(vec3 o, vec3 d, float r) {
+  float a = dot(d, d), b = 2.0 * dot(d, o), c = dot(o, o) - r * r, disc = b * b - 4.0 * a * c;
+  if (disc < 0.0) return vec2(-1.0);
+  float sq = sqrt(disc);
+  return vec2((-b - sq) / (2.0 * a), (-b + sq) / (2.0 * a));
+}
+
+void main() {
+  vec4 wn = u.invVP * vec4(ndc, -1, 1), wf = u.invVP * vec4(ndc, 1, 1);
+  vec3 near3 = wn.xyz / wn.w, far3 = wf.xyz / wf.w;
+  vec3 rd = normalize(far3 - near3);
+  vec3 org = u.cameraEcef.xyz;
+
+  vec2 at = rsi(org, rd, AR);
+  if (at.y < 0.0) { outColor = vec4(0, 0, 0, 1); return; }
+
+  vec2 er = rsi(org, rd, ER);
+  float tmax = at.y;
+  if (er.x > 0.0) tmax = min(tmax, er.x);
+  float tmin = max(at.x, 0.0);
+  if (tmin >= tmax) { outColor = vec4(0, 0, 0, 1); return; }
+
+  const int S = 16, L = 4;
+  float ss = (tmax - tmin) / float(S);
+  vec3 rayl = vec3(0), miel = vec3(0);
+  float oR = 0.0, oM = 0.0;
+
+  for (int i = 0; i < S; ++i) {
+    float t = tmin + (float(i) + 0.5) * ss;
+    vec3 sp = org + rd * t;
+    float h = length(sp) - ER;
+    float hr = exp(-h / 10000.0) * ss, hm = exp(-h / 3200.0) * ss;
+    oR += hr; oM += hm;
+
+    vec2 lh = rsi(sp, u.lightDir.xyz, AR);
+    if (lh.y > 0.0) {
+      float ls = lh.y / float(L);
+      float lR = 0.0, lM = 0.0;
+      bool bl = false;
+      for (int j = 0; j < L; ++j) {
+        vec3 lsp = sp + u.lightDir.xyz * ((float(j) + 0.5) * ls);
+        float lh2 = length(lsp) - ER;
+        if (lh2 < 0.0) { bl = true; break; }
+        lR += exp(-lh2 / 10000.0) * ls;
+        lM += exp(-lh2 / 3200.0) * ls;
+      }
+      if (!bl) {
+        vec3 tau = RAY * (oR + lR) + MIE3 * 1.1 * (oM + lM);
+        vec3 att = exp(-tau);
+        rayl += hr * att;
+        miel += hm * att;
+      }
+    }
+  }
+
+  float cosT = dot(rd, u.lightDir.xyz), cos2 = cosT * cosT;
+  float rPh = 0.75 * (1.0 + cos2);
+  float g2 = MG * MG;
+  float mPh = 1.5 * ((1.0 - g2) / (2.0 + g2)) * (1.0 + cos2) / pow(1.0 + g2 - 2.0 * MG * cosT, 1.5);
+  vec3 col = LINT * (rayl * RAY * rPh + miel * MIE3 * mPh);
+  col = 1.0 - exp(-col * 1.1);
+  col *= vec3(0.18, 0.45, 1.0);
+
+  vec3 nu = normalize(org);
+  float up = clamp(dot(rd, nu), 0.0, 1.0);
+  float camH = max(0.0, length(org) - ER);
+  float hStr = clamp(1.0 - camH / 35000.0, 0.0, 1.0);
+  col = mix(col, vec3(0.40, 0.62, 0.96), (1.0 - smoothstep(0.05, 0.45, up)) * 0.40 * hStr);
+
+  outColor = vec4(col, 1.0);
+}

package/android/src/main/cpp/vulkan/shaders/sky.vert

@@ -0,0 +1,9 @@
+#version 450
+
+layout(location = 0) out vec2 ndc;
+
+void main() {
+  vec2 ps[3] = vec2[](vec2(-1, -1), vec2(3, -1), vec2(-1, 3));
+  gl_Position = vec4(ps[gl_VertexIndex], 0, 1);
+  ndc = ps[gl_VertexIndex];
+}

package/android/src/main/cpp/vulkan/shaders/terrain.frag

@@ -0,0 +1,144 @@
+#version 450
+
+// Per-frame UBO (set 0): just the camera position in ECEF.
+// Vertex-stage MVP is now in push constants, so the UBO is fragment-only.
+layout(set = 0, binding = 0) uniform TerrainUBO {
+  vec4 cameraEcef;  // xyz = camera ECEF (float), w unused
+} u;
+
+// Push constants — 128 bytes split between vertex (bytes 0-63) and fragment
+// (bytes 64-127).  The leading mat4 mirrors the vertex-shader declaration so
+// both stages agree on the std430 layout; only the fragment-specific fields
+// after it are actually read here.
+layout(push_constant) uniform PC {
+  mat4  _mvp;               // bytes   0-63  (vertex only, ignored here)
+  uint  hasOverlay;         // byte   64
+  uint  isEllipsoidFallback;// byte   68
+  uint  isOnlyWater;        // byte   72
+  uint  hasWaterMask;       // byte   76
+  float wmWest;             // byte   80
+  float wmSouth;            // byte   84
+  float wmEast;             // byte   88
+  float wmNorth;            // byte   92
+  float rtcCenterX;         // byte   96
+  float rtcCenterY;         // byte  100
+  float rtcCenterZ;         // byte  104
+  float translationX;       // byte  108
+  float translationY;       // byte  112
+  float scaleX;             // byte  116
+  float scaleY;             // byte  120
+  float _pad;               // byte  124
+} pc;
+
+layout(set = 1, binding = 0) uniform sampler2D overlayTex;
+layout(set = 2, binding = 0) uniform sampler2D waterMaskTex;
+
+layout(location = 0) in vec3  localPos;
+layout(location = 1) in vec2  fragUV;
+layout(location = 2) in float fragAltitude;
+
+layout(location = 0) out vec4 outColor;
+
+vec3 hypsometricColor(float alt, float steep) {
+  vec3 cDeep    = vec3(0.03, 0.20, 0.46), cShallow = vec3(0.08, 0.44, 0.78);
+  vec3 cLow     = vec3(0.46, 0.54, 0.30), cFoot    = vec3(0.62, 0.55, 0.32);
+  vec3 cHigh    = vec3(0.48, 0.38, 0.28), cAlp     = vec3(0.52, 0.50, 0.48);
+  vec3 cSnow    = vec3(0.90, 0.92, 0.94);
+  if (alt < 0.0) return mix(cDeep, cShallow, smoothstep(-4500.0, -20.0, alt));
+  vec3 c = cLow;
+  c = mix(c, cFoot,  smoothstep( 120.0,  900.0, alt));
+  c = mix(c, cHigh,  smoothstep( 750.0, 2000.0, alt));
+  c = mix(c, cAlp,   smoothstep(1700.0, 3600.0, alt));
+  c = mix(c, cSnow,  smoothstep(3200.0, 5200.0, alt));
+  vec3  scree = vec3(0.38, 0.35, 0.32);
+  float rock  = clamp(steep * 1.08, 0.0, 1.0) * smoothstep(35.0, 140.0, alt);
+  return mix(c, scree, rock);
+}
+
+void main() {
+  // ── World position (RTC reconstruction) ────────────────────────────────────
+  // wp = tile-local pos + RTC centre (both float32 at ~6.4 Mm scale).
+  // ~0.75 m ULP — far better than eyeRelPos + cameraEcef at altitude.
+  vec3  rtcCentre = vec3(pc.rtcCenterX, pc.rtcCenterY, pc.rtcCenterZ);
+  vec3  wp        = localPos + rtcCentre;
+  float pxy       = sqrt(wp.x * wp.x + wp.y * wp.y);
+  float lon       = atan(wp.y, wp.x);
+
+  // Geodetic latitude (Bowring iteration, float32 — good to ~0.1 m for UV).
+  const float a_e = 6378137.0, b_e = 6356752.31424518;
+  const float ep2 = (a_e * a_e - b_e * b_e) / (b_e * b_e);
+  const float e2  = 1.0 - (b_e * b_e) / (a_e * a_e);
+  float theta_g   = atan(wp.z * a_e, pxy * b_e);
+  float sg        = sin(theta_g), cg = cos(theta_g);
+  float lat       = atan(wp.z + ep2 * b_e * sg * sg * sg,
+                         pxy  - e2  * a_e * cg * cg * cg);
+
+  // ── Water-mask UV from geographic lat/lon + tile bounds ───────────────────
+  float wmU   = (lon - pc.wmWest)  / max(pc.wmEast  - pc.wmWest,  1e-7);
+  float v_geo = (lat - pc.wmSouth) / max(pc.wmNorth - pc.wmSouth, 1e-7);
+  // Flip V: Cesium geographic convention (V=0 south) vs texture (V=0 north).
+  vec2  wmUV  = clamp(vec2(wmU, 1.0 - v_geo), 0.0, 1.0);
+
+  float waterVal = (pc.isOnlyWater != 0u) ? 1.0 : texture(waterMaskTex, wmUV).r;
+
+  // ── Imagery overlay path ──────────────────────────────────────────────────
+  if (pc.hasOverlay != 0u) {
+    vec2 texUV = fragUV * vec2(pc.scaleX, pc.scaleY)
+               + vec2(pc.translationX, pc.translationY);
+    texUV.y = 1.0 - texUV.y;
+    outColor = texture(overlayTex, texUV);
+    return;
+  }
+
+  // ── Hypsometric path ──────────────────────────────────────────────────────
+  vec3  dpdx_v = dFdx(localPos), dpdy_v = dFdy(localPos);
+  vec3  rawN   = cross(dpdx_v, dpdy_v);
+  float nLen   = length(rawN);
+  vec3  n      = (nLen > 1e-8) ? rawN / nLen : vec3(0.0, 0.0, 1.0);
+
+  // View direction in tile-local space.
+  // Camera-in-tile-space = cameraEcef − rtcCentre (float32, acceptable for lighting).
+  vec3 cameraTilespace = u.cameraEcef.xyz - rtcCentre;
+  vec3 vd = normalize(cameraTilespace - localPos);
+  if (dot(n, vd) < 0.0) n = -n;
+
+  vec3  gu   = normalize(wp);
+  vec3  sun  = normalize(gu + vec3(0.3, 0.2, 0.1));
+  float diff  = clamp(dot(n, sun), 0.0, 1.0);
+  float amb   = 0.18;
+  float rim   = clamp(1.0 - dot(n, vd), 0.0, 1.0) * 0.06;
+  float steep = 1.0 - clamp(abs(dot(n, gu)), 0.0, 1.0);
+
+  // Use vertex altitude directly — computed on the CPU in double (sub-mm).
+  // Avoids the ±50 m catastrophic cancellation of float32 pxy/cos(lat) − N.
+  float rawAlt    = fragAltitude;
+  vec3  oceanBlue = vec3(0.04, 0.26, 0.52);
+  float landAlt   = (pc.hasWaterMask != 0u) ? max(rawAlt, 0.0) : rawAlt;
+  vec3  landLit   = hypsometricColor(landAlt, steep) * (amb + diff * 0.72 + rim);
+  vec3  lit       = mix(landLit, oceanBlue, waterVal);
+
+  // 1 km lat/lon grid — fades when sub-pixel to suppress Moiré.
+  const float gridLat = 1000.0 / 6371000.0;
+  float cosLat  = max(cos(lat), 0.001);
+  float gridLon = gridLat / cosLat;
+  float wLat    = fwidth(lat) * 1.5, wLon = fwidth(lon) * 1.5;
+  float gridVis = clamp(min(gridLat / max(wLat, 1e-9),
+                            gridLon / max(wLon, 1e-9)), 0.0, 1.0);
+  float latCell = lat - gridLat * floor(lat / gridLat);
+  float lonCell = lon - gridLon * floor(lon / gridLon);
+  float dLat    = min(latCell, gridLat - latCell);
+  float dLon    = min(lonCell, gridLon - lonCell);
+  float gridA   = max(1.0 - smoothstep(0.0, wLat, dLat),
+                      1.0 - smoothstep(0.0, wLon, dLon)) * gridVis;
+  lit = mix(lit, vec3(0.15, 0.15, 0.15), gridA * 0.6);
+
+  // Coastline outline from water mask.
+  if (pc.isEllipsoidFallback == 0u) {
+    float dWater  = fwidth(waterVal);
+    float coastPx = abs(waterVal - 0.5) / max(dWater * 0.5, 0.01);
+    float coastA  = 1.0 - smoothstep(0.0, 1.5, coastPx);
+    lit = mix(lit, vec3(0.18, 0.14, 0.10), coastA * 0.7);
+  }
+
+  outColor = vec4(lit, 1.0);
+}

package/android/src/main/cpp/vulkan/shaders/terrain.vert

@@ -0,0 +1,25 @@
+#version 450
+
+// RTC vertex shader.
+// Vertex positions are tile-local (relative to the tile's RTC centre).
+// The per-tile MVP matrix is computed on the CPU entirely in double precision,
+// then cast to float32.  This eliminates the large camera↔tile-centre float32
+// subtraction that caused ±1.6 m vertex precision errors at altitude.
+layout(push_constant) uniform PC {
+  mat4 mvpMatrix;   // per-draw RTC MVP (bytes 0-63)
+} vpc;
+
+layout(location = 0) in vec3  inPosition;  // tile-local position (float)
+layout(location = 1) in vec2  inUV;
+layout(location = 2) in float inAltitude;  // ellipsoid height metres (double source)
+
+layout(location = 0) out vec3  localPos;
+layout(location = 1) out vec2  fragUV;
+layout(location = 2) out float fragAltitude;
+
+void main() {
+  gl_Position  = vpc.mvpMatrix * vec4(inPosition, 1.0);
+  localPos     = inPosition;
+  fragUV       = inUV;
+  fragAltitude = inAltitude;
+}

package/android/src/main/java/com/margelo/nitro/reactnativecesium/CesiumBridgeJNI.kt

@@ -0,0 +1,84 @@
+package com.margelo.nitro.reactnativecesium
+
+import android.view.Surface
+
+/**
+ * JNI bridge to the C++ CesiumBridgeAndroid. Each instance owns a native pointer
+ * managed via [nativeCreate] / [nativeDestroy].
+ */
+class CesiumBridgeJNI {
+  private var nativePtr: Long = nativeCreate()
+
+  fun init(surface: Surface, width: Int, height: Int, cacheDir: String, cacertPath: String) {
+    nativeInit(nativePtr, surface, width, height, cacheDir, cacertPath)
+  }
+
+  fun shutdown() = nativeShutdown(nativePtr)
+
+  fun destroy() {
+    nativeDestroy(nativePtr)
+    nativePtr = 0
+  }
+
+  fun resize(w: Int, h: Int) = nativeResize(nativePtr, w, h)
+  fun updateIonAccessToken(token: String, assetId: Long) = nativeUpdateIonAccessToken(nativePtr, token, assetId)
+  fun updateImageryAssetId(assetId: Long) = nativeUpdateImageryAssetId(nativePtr, assetId)
+  fun updateCamera(lat: Double, lon: Double, alt: Double, heading: Double, pitch: Double, roll: Double) =
+    nativeUpdateCamera(nativePtr, lat, lon, alt, heading, pitch, roll)
+  fun setVerticalFovDeg(deg: Double) = nativeSetVerticalFovDeg(nativePtr, deg)
+  fun setMaxSSE(v: Double) = nativeSetMaxSSE(nativePtr, v)
+  fun setMaxSimLoads(v: Int) = nativeSetMaxSimLoads(nativePtr, v)
+  fun setLoadDescLim(v: Int) = nativeSetLoadDescLim(nativePtr, v)
+  fun setMsaa(v: Int) = nativeSetMsaa(nativePtr, v)
+
+  fun markNeedsRender() = nativeMarkNeedsRender(nativePtr)
+  fun shouldRenderNextFrame(): Boolean = nativeShouldRenderNextFrame(nativePtr)
+  fun renderFrame(dt: Double) = nativeRenderFrame(nativePtr, dt)
+
+  fun getCameraLat(): Double = nativeGetCameraLat(nativePtr)
+  fun getCameraLon(): Double = nativeGetCameraLon(nativePtr)
+  fun getCameraAlt(): Double = nativeGetCameraAlt(nativePtr)
+  fun getCameraHeading(): Double = nativeGetCameraHeading(nativePtr)
+  fun getCameraPitch(): Double = nativeGetCameraPitch(nativePtr)
+  fun getCameraRoll(): Double = nativeGetCameraRoll(nativePtr)
+  fun getVerticalFovDeg(): Double = nativeGetVerticalFovDeg(nativePtr)
+
+  fun getMetricsFps(): Double = nativeGetMetricsFps(nativePtr)
+  fun getMetricsTilesRendered(): Int = nativeGetMetricsTilesRendered(nativePtr)
+  fun getMetricsTilesLoading(): Int = nativeGetMetricsTilesLoading(nativePtr)
+  fun getMetricsTilesVisited(): Int = nativeGetMetricsTilesVisited(nativePtr)
+  fun getMetricsIonTokenConfigured(): Boolean = nativeGetMetricsIonTokenConfigured(nativePtr)
+  fun getMetricsTilesetReady(): Boolean = nativeGetMetricsTilesetReady(nativePtr)
+  fun getMetricsCreditsPlainText(): String = nativeGetMetricsCreditsPlainText(nativePtr)
+
+  private external fun nativeCreate(): Long
+  private external fun nativeInit(ptr: Long, surface: Surface, w: Int, h: Int, cacheDir: String, cacertPath: String)
+  private external fun nativeShutdown(ptr: Long)
+  private external fun nativeDestroy(ptr: Long)
+  private external fun nativeResize(ptr: Long, w: Int, h: Int)
+  private external fun nativeUpdateIonAccessToken(ptr: Long, token: String, assetId: Long)
+  private external fun nativeUpdateImageryAssetId(ptr: Long, assetId: Long)
+  private external fun nativeUpdateCamera(ptr: Long, lat: Double, lon: Double, alt: Double, heading: Double, pitch: Double, roll: Double)
+  private external fun nativeSetVerticalFovDeg(ptr: Long, deg: Double)
+  private external fun nativeSetMaxSSE(ptr: Long, v: Double)
+  private external fun nativeSetMaxSimLoads(ptr: Long, v: Int)
+  private external fun nativeSetLoadDescLim(ptr: Long, v: Int)
+  private external fun nativeSetMsaa(ptr: Long, v: Int)
+  private external fun nativeMarkNeedsRender(ptr: Long)
+  private external fun nativeShouldRenderNextFrame(ptr: Long): Boolean
+  private external fun nativeRenderFrame(ptr: Long, dt: Double)
+  private external fun nativeGetCameraLat(ptr: Long): Double
+  private external fun nativeGetCameraLon(ptr: Long): Double
+  private external fun nativeGetCameraAlt(ptr: Long): Double
+  private external fun nativeGetCameraHeading(ptr: Long): Double
+  private external fun nativeGetCameraPitch(ptr: Long): Double
+  private external fun nativeGetCameraRoll(ptr: Long): Double
+  private external fun nativeGetVerticalFovDeg(ptr: Long): Double
+  private external fun nativeGetMetricsFps(ptr: Long): Double
+  private external fun nativeGetMetricsTilesRendered(ptr: Long): Int
+  private external fun nativeGetMetricsTilesLoading(ptr: Long): Int
+  private external fun nativeGetMetricsTilesVisited(ptr: Long): Int
+  private external fun nativeGetMetricsIonTokenConfigured(ptr: Long): Boolean
+  private external fun nativeGetMetricsTilesetReady(ptr: Long): Boolean
+  private external fun nativeGetMetricsCreditsPlainText(ptr: Long): String
+}