react-native-cesium 1.0.1

package/cpp/engine/CesiumEngine.hpp

@@ -0,0 +1,90 @@
+#pragma once
+
+#include "../renderer/RenderTypes.hpp"
+#include "GlobeCamera.hpp"
+#include "ResourcePreparer.hpp"
+#include "TaskProcessor.hpp"
+#include "TileLifecycleManager.hpp"
+
+#include <CesiumAsync/AsyncSystem.h>
+#include <CesiumAsync/IAssetAccessor.h>
+
+#include <memory>
+#include <string>
+
+namespace Cesium3DTilesSelection {
+class Tileset;
+}
+
+namespace CesiumUtility {
+class CreditSystem;
+}
+
+namespace reactnativecesium {
+
+struct EngineConfig {
+  std::string ionAccessToken;
+  int64_t     ionAssetId = 1;
+  std::string cacheDatabasePath;
+  std::string tlsCaBundlePath;
+  double maximumScreenSpaceError      = 32.0;
+  int32_t maximumSimultaneousTileLoads = 12;
+  int32_t loadingDescendantLimit       = 20;
+};
+
+class CesiumEngine {
+public:
+  CesiumEngine();
+  ~CesiumEngine();
+
+  CesiumEngine(const CesiumEngine&)            = delete;
+  CesiumEngine& operator=(const CesiumEngine&) = delete;
+
+  void initialize(const EngineConfig& config);
+  void shutdown();
+  void updateConfig(const EngineConfig& config);
+
+  void updateFrame(double viewportWidth, double viewportHeight, FrameResult& result);
+
+  void setImageryAssetId(int64_t assetId);
+
+  GlobeCamera&       camera()       { return camera_; }
+  const GlobeCamera& camera() const { return camera_; }
+
+  ResourcePreparer* getResourcePreparer() const { return resourcePreparer_.get(); }
+
+private:
+  void createTileset(const std::string& token,
+                     int64_t            assetId,
+                     int64_t            imageryAssetId = 1);
+  void destroyTileset();
+
+  bool tilesetOptionsMatch(const EngineConfig& a, const EngineConfig& b) const;
+
+  // Builds a tessellated WGS84 ellipsoid mesh (inset ~20 m) used as a
+  // permanent background so flat terrain is always visible even when tiles
+  // are absent or not yet loaded.
+  void buildEllipsoidMesh();
+  void appendEllipsoidDraws(FrameResult& result) const;
+
+  EngineConfig config_;
+
+  std::shared_ptr<TaskProcessor>               taskProcessor_;
+  std::shared_ptr<CesiumAsync::IAssetAccessor> assetAccessor_;
+  CesiumAsync::AsyncSystem                     asyncSystem_;
+  std::shared_ptr<ResourcePreparer>            resourcePreparer_;
+  std::shared_ptr<CesiumUtility::CreditSystem> creditSystem_;
+
+  std::unique_ptr<Cesium3DTilesSelection::Tileset> tileset_;
+
+  int64_t currentImageryAssetId_ = 1;
+
+  GlobeCamera          camera_;
+  TileLifecycleManager lifecycle_;
+
+  // Pre-computed fallback ellipsoid geometry (ECEF, absolute).
+  std::vector<glm::dvec3> ellipsoidPositions_;
+  std::vector<uint32_t>   ellipsoidIndices_;
+};
+
+} // namespace reactnativecesium

package/cpp/engine/DeletionQueue.cpp

@@ -0,0 +1,28 @@
+#include "DeletionQueue.hpp"
+
+namespace reactnativecesium {
+
+void DeletionQueue::enqueue(TileGPUResources* resources, uint64_t currentFrame) {
+  if (!resources) return;
+  queue_.push_back({resources, currentFrame});
+}
+
+void DeletionQueue::processFrame(uint64_t currentFrame) {
+  int disposed = 0;
+  while (!queue_.empty() && disposed < MAX_DISPOSALS_PER_FRAME) {
+    auto& front = queue_.front();
+    if (currentFrame - front.enqueueFrame < MIN_FRAME_DELAY) break;
+    delete front.resources;
+    queue_.pop_front();
+    ++disposed;
+  }
+}
+
+void DeletionQueue::flush() {
+  while (!queue_.empty()) {
+    delete queue_.front().resources;
+    queue_.pop_front();
+  }
+}
+
+} // namespace reactnativecesium

package/cpp/engine/DeletionQueue.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "../renderer/RenderTypes.hpp"
+
+#include <cstdint>
+#include <deque>
+
+namespace reactnativecesium {
+
+// CPU-only resource deletion with a frame delay (avoids deleting in-flight data).
+class DeletionQueue {
+public:
+  static constexpr uint64_t MIN_FRAME_DELAY       = 3;
+  static constexpr int      MAX_DISPOSALS_PER_FRAME = 8;
+
+  void enqueue(TileGPUResources* resources, uint64_t currentFrame);
+  void processFrame(uint64_t currentFrame);
+  void flush();
+
+private:
+  struct Entry {
+    TileGPUResources* resources;
+    uint64_t          enqueueFrame;
+  };
+  std::deque<Entry> queue_;
+};
+
+} // namespace reactnativecesium

package/cpp/engine/GlobeCamera.cpp

@@ -0,0 +1,181 @@
+#include "GlobeCamera.hpp"
+
+#include <CesiumGeospatial/GlobeTransforms.h>
+
+#include <glm/gtc/matrix_transform.hpp>
+
+#include <algorithm>
+#include <cmath>
+
+namespace reactnativecesium {
+
+static constexpr double kNearPlane = 1.0;
+static constexpr double kFarPlane  = 50000000.0;
+static constexpr double kMinVfov   = 20.0;
+static constexpr double kMaxVfov   = 100.0;
+
+GlobeCamera::GlobeCamera() { recompute(); }
+
+void GlobeCamera::setParams(const CameraParams& p) {
+  std::lock_guard<std::mutex> lk(mutex_);
+  params_ = p;
+  dirty_  = true;
+}
+
+CameraParams GlobeCamera::getParams() const {
+  std::lock_guard<std::mutex> lk(mutex_);
+  return params_;
+}
+
+void GlobeCamera::setVerticalFovDegrees(double degrees) {
+  std::lock_guard<std::mutex> lk(mutex_);
+  verticalFovDeg_ = std::clamp(degrees, kMinVfov, kMaxVfov);
+}
+
+double GlobeCamera::getVerticalFovDegrees() const {
+  std::lock_guard<std::mutex> lk(mutex_);
+  return verticalFovDeg_;
+}
+
+void GlobeCamera::recompute() const {
+  if (!dirty_) return;
+  dirty_ = false;
+
+  const auto& ellipsoid = CesiumGeospatial::Ellipsoid::WGS84;
+  CesiumGeospatial::Cartographic carto(glm::radians(params_.longitude),
+                                       glm::radians(params_.latitude),
+                                       params_.altitude);
+  ecefPosition_ = ellipsoid.cartographicToCartesian(carto);
+
+  glm::dmat4 enuToECEF =
+      CesiumGeospatial::GlobeTransforms::eastNorthUpToFixedFrame(
+          ecefPosition_, ellipsoid);
+
+  glm::dvec3 east  = glm::normalize(glm::dvec3(enuToECEF[0]));
+  glm::dvec3 north = glm::normalize(glm::dvec3(enuToECEF[1]));
+  glm::dvec3 upENU = glm::normalize(glm::dvec3(enuToECEF[2]));
+
+  double hdgRad   = glm::radians(params_.heading);
+  double pitchRad = glm::radians(params_.pitch);
+  double rollRad  = glm::radians(params_.roll);
+
+  // 1. Heading: forward and right in the horizontal plane.
+  glm::dvec3 fwdH  = north * std::cos(hdgRad) + east * std::sin(hdgRad);
+  glm::dvec3 right = glm::normalize(glm::cross(fwdH, upENU));
+
+  // 2. Pitch: rotate fwdH and upENU around the fixed right axis.
+  //    Works for any pitch (full 360° loop) — no cross(fwd, upENU) singularity.
+  glm::dvec3 fwd   = fwdH * std::cos(pitchRad) + upENU * std::sin(pitchRad);
+  glm::dvec3 camUp = -fwdH * std::sin(pitchRad) + upENU * std::cos(pitchRad);
+
+  // 3. Roll: rotate right and camUp around fwd.
+  if (std::abs(rollRad) > 1e-6) {
+    glm::dvec3 rolledRight = right * std::cos(rollRad) + camUp * std::sin(rollRad);
+    camUp = glm::normalize(glm::cross(rolledRight, fwd));
+    right = glm::normalize(rolledRight);
+  }
+
+  direction_ = fwd;
+  up_        = camUp;
+}
+
+glm::dvec3 GlobeCamera::getECEFPosition() const {
+  std::lock_guard<std::mutex> lk(mutex_);
+  recompute();
+  return ecefPosition_;
+}
+
+void GlobeCamera::computeHeadingPitchToward(double targetLatDeg,
+                                              double targetLonDeg,
+                                              double targetAltMeters,
+                                              double& outHeadingDeg,
+                                              double& outPitchDeg) const {
+  std::lock_guard<std::mutex> lk(mutex_);
+  recompute();
+
+  const auto& ellipsoid = CesiumGeospatial::Ellipsoid::WGS84;
+  CesiumGeospatial::Cartographic targetCarto(
+      glm::radians(targetLonDeg),
+      glm::radians(targetLatDeg),
+      targetAltMeters);
+  glm::dvec3 targetEcef = ellipsoid.cartographicToCartesian(targetCarto);
+  glm::dvec3 dirEcef    = glm::normalize(targetEcef - ecefPosition_);
+
+  glm::dmat4 enuToECEF =
+      CesiumGeospatial::GlobeTransforms::eastNorthUpToFixedFrame(
+          ecefPosition_, ellipsoid);
+  glm::dvec3 east  = glm::normalize(glm::dvec3(enuToECEF[0]));
+  glm::dvec3 north = glm::normalize(glm::dvec3(enuToECEF[1]));
+  glm::dvec3 upENU = glm::normalize(glm::dvec3(enuToECEF[2]));
+
+  const double dEast  = glm::dot(dirEcef, east);
+  const double dNorth = glm::dot(dirEcef, north);
+  const double dUp    = glm::dot(dirEcef, upENU);
+  const double horiz  = std::sqrt(dEast * dEast + dNorth * dNorth);
+
+  outHeadingDeg = glm::degrees(std::atan2(dEast, dNorth));
+  outPitchDeg   = glm::degrees(std::atan2(dUp, horiz));
+}
+
+Cesium3DTilesSelection::ViewState
+GlobeCamera::computeViewState(double w, double h) const {
+  std::lock_guard<std::mutex> lk(mutex_);
+  recompute();
+
+  double aspect = w / std::max(h, 1.0);
+  double vfov   = glm::radians(verticalFovDeg_);
+  double hfov   = 2.0 * std::atan(std::tan(vfov * 0.5) * aspect);
+
+  return Cesium3DTilesSelection::ViewState(
+      ecefPosition_, direction_, up_,
+      glm::dvec2(w, h), hfov, vfov);
+}
+
+glm::mat4 GlobeCamera::computeVPMatrix(double w, double h) const {
+  std::lock_guard<std::mutex> lk(mutex_);
+  recompute();
+
+  glm::dmat4 fullView = glm::lookAt(ecefPosition_, ecefPosition_ + direction_, up_);
+  glm::mat4 viewRot   = glm::mat4(glm::dmat4(
+      fullView[0], fullView[1], fullView[2], glm::dvec4(0.0, 0.0, 0.0, 1.0)));
+
+  double aspect   = w / std::max(h, 1.0);
+  double vfov     = glm::radians(verticalFovDeg_);
+  double tanHalfV = std::tan(vfov * 0.5);
+  double tanHalfH = tanHalfV * aspect;
+
+  float f = static_cast<float>(kNearPlane);
+  glm::mat4 proj(0.0f);
+  proj[0][0] = static_cast<float>(1.0 / tanHalfH);
+  proj[1][1] = static_cast<float>(1.0 / tanHalfV);
+  proj[2][3] = -1.0f;
+  proj[3][2] = f;
+
+  return proj * viewRot;
+}
+
+glm::dmat4 GlobeCamera::computeVPMatrixDouble(double w, double h) const {
+  std::lock_guard<std::mutex> lk(mutex_);
+  recompute();
+
+  // Rotation-only view (camera-at-origin, ECEF-oriented) — same structure as
+  // computeVPMatrix but all operations stay in double.
+  glm::dmat4 fullView = glm::lookAt(ecefPosition_, ecefPosition_ + direction_, up_);
+  glm::dmat4 viewRot(
+      fullView[0], fullView[1], fullView[2], glm::dvec4(0.0, 0.0, 0.0, 1.0));
+
+  double aspect   = w / std::max(h, 1.0);
+  double vfov     = glm::radians(verticalFovDeg_);
+  double tanHalfV = std::tan(vfov * 0.5);
+  double tanHalfH = tanHalfV * aspect;
+
+  glm::dmat4 proj(0.0);
+  proj[0][0] = 1.0 / tanHalfH;
+  proj[1][1] = 1.0 / tanHalfV;
+  proj[2][3] = -1.0;
+  proj[3][2] = kNearPlane;
+
+  return proj * viewRot;
+}
+
+} // namespace reactnativecesium

package/cpp/engine/GlobeCamera.hpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <CesiumGeospatial/Cartographic.h>
+#include <CesiumGeospatial/Ellipsoid.h>
+#include <Cesium3DTilesSelection/ViewState.h>
+
+#include <glm/glm.hpp>
+#include <mutex>
+
+namespace reactnativecesium {
+
+struct CameraParams {
+  double latitude  = 46.10;
+  double longitude = 7.80;
+  double altitude  = 5500.0;
+  double heading   = 220.0;
+  double pitch     = -10.0;
+  double roll      = 0.0;
+};
+
+class GlobeCamera {
+public:
+  GlobeCamera();
+
+  void setParams(const CameraParams& params);
+  CameraParams getParams() const;
+
+  void setVerticalFovDegrees(double degrees);
+  double getVerticalFovDegrees() const;
+
+  /// Bearing / tilt to look from the current camera position toward |target*| (degrees).
+  void computeHeadingPitchToward(double targetLatDeg,
+                                 double targetLonDeg,
+                                 double targetAltMeters,
+                                 double& outHeadingDeg,
+                                 double& outPitchDeg) const;
+
+  Cesium3DTilesSelection::ViewState
+  computeViewState(double viewportWidth, double viewportHeight) const;
+
+  glm::dvec3 getECEFPosition() const;
+
+  glm::mat4  computeVPMatrix(double viewportWidth, double viewportHeight) const;
+
+  // Double-precision rotation-only VP matrix (same projection, no translation).
+  // Used by CesiumEngine to build per-tile MVP = vpDouble * translate(rtcCenter-camera)
+  // entirely in double before casting the result to float32 for the GPU.
+  glm::dmat4 computeVPMatrixDouble(double viewportWidth, double viewportHeight) const;
+
+private:
+  void recompute() const;
+
+  mutable std::mutex mutex_;
+  CameraParams params_;
+
+  double verticalFovDeg_ = 60.0;
+
+  mutable bool       dirty_        = true;
+  mutable glm::dvec3 ecefPosition_{0.0};
+  mutable glm::dvec3 direction_{0.0, 1.0, 0.0};
+  mutable glm::dvec3 up_{0.0, 0.0, 1.0};
+};
+
+} // namespace reactnativecesium

package/cpp/engine/GltfToMesh.cpp

@@ -0,0 +1,154 @@
+#include "GltfToMesh.hpp"
+
+#include <CesiumGltf/AccessorView.h>
+#include <CesiumGltf/AccessorUtility.h>
+#include <CesiumGltf/VertexAttributeSemantics.h>
+#include <CesiumGltfContent/GltfUtilities.h>
+
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/quaternion.hpp>
+
+#include <cmath>
+#include <cstring>
+
+namespace reactnativecesium {
+
+// Double-precision Bowring iterative geodetic height.
+// Both subtracted terms are ~6.4e6 m, but in double (52-bit mantissa) the
+// catastrophic cancellation leaves ~1 nm residual — effectively exact.
+static double ellipsoidHeightDouble(const glm::dvec3& p) {
+  constexpr double a   = 6378137.0;
+  constexpr double b   = 6356752.31424518;
+  constexpr double e2  = 1.0 - (b * b) / (a * a);
+  constexpr double ep2 = (a * a - b * b) / (b * b);
+
+  const double pxy = std::sqrt(p.x * p.x + p.y * p.y);
+  if (pxy < 1e-10) return std::abs(p.z) - b;
+
+  const double theta = std::atan2(p.z * a, pxy * b);
+  const double st = std::sin(theta), ct = std::cos(theta);
+  const double lat = std::atan2(p.z + ep2 * b * st * st * st,
+                                pxy - e2  * a * ct * ct * ct);
+  const double sinLat = std::sin(lat);
+  const double N = a / std::sqrt(1.0 - e2 * sinLat * sinLat);
+  return pxy / std::cos(lat) - N;
+}
+
+std::vector<TilePrimitive>
+GltfToMesh::convert(const CesiumGltf::Model& model,
+                    const glm::dmat4& tileTransform) {
+  std::vector<TilePrimitive> results;
+
+  // Apply CESIUM_RTC and glTF Y-up adjustment.
+  glm::dmat4 rootTransform = tileTransform;
+  rootTransform = CesiumGltfContent::GltfUtilities::applyRtcCenter(model, rootTransform);
+  rootTransform = CesiumGltfContent::GltfUtilities::applyGltfUpAxisTransform(model, rootTransform);
+
+  model.forEachPrimitiveInScene(
+      -1,
+      [&results, &rootTransform](
+          const CesiumGltf::Model& gltf,
+          const CesiumGltf::Node& /*node*/,
+          const CesiumGltf::Mesh& /*mesh*/,
+          const CesiumGltf::MeshPrimitive& primitive,
+          const glm::dmat4& nodeTransform) {
+
+        switch (primitive.mode) {
+        case CesiumGltf::MeshPrimitive::Mode::TRIANGLES:
+        case CesiumGltf::MeshPrimitive::Mode::TRIANGLE_STRIP:
+        case CesiumGltf::MeshPrimitive::Mode::TRIANGLE_FAN:
+          break;
+        default:
+          return;
+        }
+
+        const CesiumGltf::PositionAccessorType posAccessor =
+            CesiumGltf::getPositionAccessorView(gltf, primitive);
+        if (posAccessor.status() != CesiumGltf::AccessorViewStatus::Valid ||
+            posAccessor.size() <= 0)
+          return;
+
+        const glm::dmat4 worldTransform = rootTransform * nodeTransform;
+        const int64_t    vertexCount    = posAccessor.size();
+
+        // RTC centre = translation column of the world transform.
+        // After applyRtcCenter this is the tile's ECEF centre embedded by
+        // Cesium Native (the RTC_CENTER GLTF extension value).
+        const glm::dvec3 rtcCenter(worldTransform[3]);
+
+        TilePrimitive prim;
+        prim.rtcCenter = rtcCenter;
+        prim.localPositions.reserve(static_cast<size_t>(vertexCount));
+        prim.altitudes.reserve(static_cast<size_t>(vertexCount));
+
+        for (int64_t i = 0; i < vertexCount; ++i) {
+          const auto&      p    = posAccessor[i];
+          const glm::dvec3 gltfLocal(p.value[0], p.value[1], p.value[2]);
+          // Absolute ECEF in double precision.
+          const glm::dvec3 ecef(worldTransform * glm::dvec4(gltfLocal, 1.0));
+          // Tile-local position (small float, retains full float32 precision
+          // because it is relative to the nearby tile centre, not the origin).
+          prim.localPositions.push_back(glm::vec3(ecef - rtcCenter));
+          // Altitude computed in double — sub-millimetre accuracy.
+          prim.altitudes.push_back(static_cast<float>(ellipsoidHeightDouble(ecef)));
+        }
+
+        // Overlay UV coordinates (_CESIUMOVERLAY_0).
+        const auto uvIt = primitive.attributes.find("_CESIUMOVERLAY_0");
+        if (uvIt != primitive.attributes.end() && uvIt->second >= 0) {
+          CesiumGltf::AccessorView<CesiumGltf::AccessorTypes::VEC2<float>> uvView(gltf, uvIt->second);
+          if (uvView.status() == CesiumGltf::AccessorViewStatus::Valid &&
+              uvView.size() == vertexCount) {
+            prim.uvs.reserve(static_cast<size_t>(vertexCount));
+            for (int64_t i = 0; i < vertexCount; ++i) {
+              prim.uvs.push_back(glm::vec2(uvView[i].value[0], uvView[i].value[1]));
+            }
+          }
+        }
+
+        // Expand index buffer → flat uint32 triangle list.
+        const CesiumGltf::IndexAccessorType idxAccessor =
+            CesiumGltf::getIndexAccessorView(gltf, primitive);
+
+        const int64_t srcIdxCount =
+            (primitive.indices >= 0)
+                ? std::visit(CesiumGltf::CountFromAccessor{}, idxAccessor)
+                : vertexCount;
+
+        int64_t faceCount = 0;
+        switch (primitive.mode) {
+        case CesiumGltf::MeshPrimitive::Mode::TRIANGLES:
+          faceCount = srcIdxCount / 3;
+          break;
+        case CesiumGltf::MeshPrimitive::Mode::TRIANGLE_STRIP:
+        case CesiumGltf::MeshPrimitive::Mode::TRIANGLE_FAN:
+          faceCount = std::max<int64_t>(0, srcIdxCount - 2);
+          break;
+        default:
+          break;
+        }
+
+        prim.indices.reserve(static_cast<size_t>(faceCount * 3));
+        for (int64_t fi = 0; fi < faceCount; ++fi) {
+          const std::array<int64_t, 3> face = std::visit(
+              CesiumGltf::IndicesForFaceFromAccessor{
+                  fi, vertexCount, primitive.mode},
+              idxAccessor);
+          if (face[0] < 0 || face[1] < 0 || face[2] < 0 ||
+              face[0] >= vertexCount || face[1] >= vertexCount ||
+              face[2] >= vertexCount)
+            continue;
+          prim.indices.push_back(static_cast<uint32_t>(face[0]));
+          prim.indices.push_back(static_cast<uint32_t>(face[1]));
+          prim.indices.push_back(static_cast<uint32_t>(face[2]));
+        }
+
+        if (!prim.indices.empty()) {
+          results.push_back(std::move(prim));
+        }
+      });
+
+  return results;
+}
+
+} // namespace reactnativecesium

package/cpp/engine/GltfToMesh.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "../renderer/RenderTypes.hpp"
+
+#include <CesiumGltf/Model.h>
+#include <glm/glm.hpp>
+
+#include <vector>
+
+namespace reactnativecesium {
+
+class GltfToMesh {
+public:
+  // Convert a glTF model + tile world transform into a list of primitives.
+  // All vertex positions are transformed to absolute ECEF in double precision.
+  static std::vector<TilePrimitive>
+  convert(const CesiumGltf::Model& model, const glm::dmat4& tileTransform);
+};
+
+} // namespace reactnativecesium