add cartographicToCartesian method

example/cesium_native/get_cartesian_coordinates.dart

@@ -0,0 +1,24 @@
+import 'dart:io';
+import 'package:cesium_3d_tiles/cesium_3d_tiles.dart';
+
+///
+/// This example shows how to use the low-level Cesium Native bindings
+/// to load a tileset from Cesium Ion, update the view, and list renderable tiles.
+///
+void main(List<String> args) async {
+  double lat, long, height;
+  try {
+    lat = double.parse(args[0]);
+    long = double.parse(args[1]);
+    height = double.parse(args[1]);
+  } catch (err) {
+    print(
+        "Usage: dart --enable-experiment=native-assets get_cartesian_coordinates.dart <lat> <long> <height>");
+    exit(-1);
+  }
+
+  final position =
+      Cesium3DTileset.cartographicToCartesian(lat, long, height: height);
+
+  print("Cartesian Coordinates : $position");
+}

lib/src/cesium_3d_tiles/src/cesium_3d_tileset.dart

@@ -3,6 +3,7 @@ import 'dart:ffi';
 import 'dart:math';
 import 'dart:typed_data';
 import 'package:cesium_3d_tiles/src/cesium_native/cesium_native.dart';
+import 'package:logging/logging.dart';
 import 'cesium_3d_tile.dart';
 import 'transforms.dart';
 import 'package:vector_math/vector_math_64.dart';
@@ -33,6 +34,8 @@ enum RenderLayer {
 /// A high-level interface for a Cesium 3D Tiles tileset.
 ///
 class Cesium3DTileset {
+
+  final _logger = Logger("Cesium3DTileset");
   ///
   /// A name used for debugging.
   ///
@@ -97,12 +100,13 @@ class Cesium3DTileset {
   }
 
   ///
-  ///
+  /// Returns the distance from [point] to the nearest point on the WGS84
+  /// ellipsoid.
   ///
   double? getDistanceToSurface({Vector3? point}) {
     if (point != null) {
-      final cartographicPosition =
-          CesiumNative.instance.getCartographicPositionForPoint((gltfToEcef * point!));
+      final cartographicPosition = CesiumNative.instance
+          .getCartographicPositionForPoint((gltfToEcef * point));
       return cartographicPosition.height;
     }
     if (rootTile == null) {
@@ -114,7 +118,8 @@ class Cesium3DTileset {
   }
 
   ///
-  ///
+  /// Returns the distance from the camera to the nearest point on the bounding
+  /// volume of the WGS84 ellipsoid.
   ///
   double? getDistanceToBoundingVolume() {
     if (rootTile == null) {
@@ -124,6 +129,18 @@ class Cesium3DTileset {
         .squaredDistanceToBoundingVolume(_view, rootTile!));
   }
 
+  ///
+  /// Returns the position (in glTF/Cartesian coordinates) of the given
+  /// cartographic position.
+  /// 
+  static Vector3 cartographicToCartesian(double latitude, double longitude,
+      {double height = 0}) {
+    final cartesian = CesiumNative.instance.getCartesianPositionForCartographic(
+        latitude, longitude,
+        height: height);
+    return ecefToGltf * cartesian;
+  }
+
   ///
   ///
   ///
@@ -208,8 +225,8 @@ class Cesium3DTileset {
   Future<Uint8List?> loadGltf(CesiumTile tile) async {
     if (!_models.containsKey(tile)) {
       var model = CesiumNative.instance.getModel(tile);
-      if (model == null) {
-        print("Failed to load");
+      if (model == null) {        
+        _logger.severe("Failed to load");
         return null;
       }
       var serialized = await CesiumNative.instance.serializeGltfData(model);

lib/src/cesium_native/src/cesium_native.dart

@@ -9,6 +9,7 @@ import 'package:cesium_3d_tiles/src/cesium_native/src/cesium_native.g.dart'
 import 'package:cesium_3d_tiles/src/cesium_native/src/cesium_bounding_volume.dart';
 import 'package:cesium_3d_tiles/src/cesium_native/src/cesium_view.dart';
 import 'package:ffi/ffi.dart';
+import 'package:logging/logging.dart';
 import 'package:vector_math/vector_math_64.dart';
 
 import 'cesium_tile_selection_state.dart';
@@ -53,6 +54,7 @@ enum CesiumTileLoadState {
 }
 
 class CesiumNative {
+  final _logger = Logger("CesiumNative");
   // error message
   static late Pointer<Char> _errorMessage;
 
@@ -184,10 +186,10 @@ class CesiumNative {
     start = DateTime.now();
     g.CesiumTileset_updateViewAsync(
         tileset._ptr, viewStruct, delta, callback.nativeFunction);
-    var elapsed = DateTime.now().millisecondsSinceEpoch - start.millisecondsSinceEpoch;
-    if(elapsed > 50) {
-    print(
-        "CesiumTileset_updateViewAsync completed in ${elapsed}ms");
+    var elapsed =
+        DateTime.now().millisecondsSinceEpoch - start.millisecondsSinceEpoch;
+    if (elapsed > 50) {
+      _logger.warning("CesiumTileset_updateViewAsync completed in ${elapsed}ms");
     }
     int waited = 0;
     await Future.delayed(Duration.zero);
@@ -200,7 +202,7 @@ class CesiumNative {
       throw Exception("Unknown error updating tileset view");
     }
     if (waited > 0) {
-      print("Waited for $waited ms to complete");
+      _logger.warning("Waited for $waited ms to complete");
     }
     tileset._lastUpdate = now;
     return numTiles;
@@ -218,10 +220,21 @@ class CesiumNative {
   ///
   ///
   CartographicPosition getCartographicPositionForPoint(Vector3 point) {
-    final pos = g.CesiumTileset_cartesianToCartographic(point.x, point.y, point.z);
+    final pos =
+        g.CesiumTileset_cartesianToCartographic(point.x, point.y, point.z);
     return CartographicPosition(pos.latitude, pos.longitude, pos.height);
   }
 
+  ///
+  ///
+  ///
+  Vector3 getCartesianPositionForCartographic(double latitude, double longitude,
+      {double height = 0}) {
+    final pos =
+        g.CesiumTileset_cartographicToCartesian(latitude, longitude, height);
+    return Vector3(pos.x, pos.y, pos.z);
+  }
+
   ///
   ///
   ///
@@ -371,7 +384,7 @@ class CesiumNative {
   CesiumGltfModel? getModel(CesiumTile tile) {
     var model = g.CesiumTile_getModel(tile);
     if (model == nullptr) {
-      print(
+      _logger.warning(
           "Failed to retrieve model. Check that this tile actually has render content.");
       return null;
     }

lib/src/cesium_native/src/cesium_native.g.dart

@@ -97,6 +97,13 @@ external CesiumCartographic CesiumTileset_cartesianToCartographic(
   double z,
 );
 
+@ffi.Native<double3 Function(ffi.Double, ffi.Double, ffi.Double)>()
+external double3 CesiumTileset_cartographicToCartesian(
+  double latitude,
+  double longitude,
+  double height,
+);
+
 @ffi.Native<ffi.Int32 Function(ffi.Pointer<CesiumTileset>)>()
 external int CesiumTileset_getTilesKicked(
   ffi.Pointer<CesiumTileset> tileset,

native/include/CesiumTilesetCApi.h

@@ -179,12 +179,16 @@ API_EXPORT int CesiumTileset_updateView(CesiumTileset* tileset, const CesiumView
 // Asynchronously update the view and get the number of tiles to render
 API_EXPORT void CesiumTileset_updateViewAsync(CesiumTileset* tileset, const CesiumViewState viewState, float deltaTime, void(*callback)(int));
 
-// Gets the cartographic position of the camera in its current orientation.
+// Gets the cartographic position of the camera in its current orientation (with respect to WGS84).
 API_EXPORT CesiumCartographic CesiumTileset_getPositionCartographic(CesiumViewState viewState);
 
-// Gets the cartographic position of the given point.
+// Gets the cartographic position of the given point (with respect to WGS84).
 API_EXPORT CesiumCartographic CesiumTileset_cartesianToCartographic(double x, double y, double z);
 
+// Gets the Cartesian coordinates of the given latitude/longitude (on the WGS84 ellipsoid).
+// Latitude/longitude are in radians, height is in metres.
+API_EXPORT double3 CesiumTileset_cartographicToCartesian(double latitude, double longitude, double height);
+
 // Return the number of tiles kicked on the last update. This will remain valid until the next call to CesiumTileset_updateView.
 API_EXPORT int32_t CesiumTileset_getTilesKicked(CesiumTileset* tileset);
 

native/src/CesiumTilesetCApi.cpp

@@ -364,6 +364,18 @@ API_EXPORT CesiumCartographic CesiumTileset_cartesianToCartographic(double x, do
     return returnValue;
 }
 
+API_EXPORT double3 CesiumTileset_cartographicToCartesian(double latitude, double longitude, double height) {
+    CesiumGeospatial::Cartographic cartographic { longitude, latitude, height };
+
+    auto ellipsoid = CesiumGeospatial::Ellipsoid::WGS84;
+
+    glm::dvec3 point = ellipsoid.cartographicToCartesian(cartographic);
+
+    double3 returnValue { point.x, point.y, point.z };
+
+    return returnValue;
+}
+
 
 int CesiumTileset_getTilesKicked(CesiumTileset* tileset) {
     return static_cast<int>(tileset->lastUpdateResult.tilesKicked);