HARP-14465: Store text/icon world coordinates in double precision.

POI and text positions, which use world coordinates (in contrast to tile coordinates used
by meshes), were being decoded into a single precision buffer, hence losing precision.

Signed-off-by: Andres Mandado <andres.mandado-almajano@here.com>

@here/harp-datasource-protocol/lib/DecodedTile.ts

@@ -267,16 +267,11 @@ export interface TextGeometry {
  * Structured clone compliant version of a `three.js` geometry object with points of interest (POIs)
  * to be rendered. It is composed of buffers with metadata for POI objects.
  */
-export interface PoiGeometry {
-    positions: BufferAttribute;
-    texts: number[];
+export interface PoiGeometry extends TextGeometry {
     /**
      * Names of the image texture or the name of the POI as indices into the array `stringCatalog`.
      */
     imageTextures?: number[];
-    technique?: number;
-    stringCatalog: Array<string | undefined>;
-    objInfos?: AttributeMap[];
     // Angle in degrees from north clockwise specifying the directions the icons can be shifted.
     offsetDirections?: number[];
 }

@here/harp-mapview/lib/geometry/TileGeometryCreator.ts

@@ -490,7 +490,7 @@ export class TileGeometryCreator {
                 }
 
                 const positions = new THREE.BufferAttribute(
-                    new Float32Array(text.positions.buffer),
+                    new Float64Array(text.positions.buffer),
                     text.positions.itemCount
                 );
 

@here/harp-mapview/lib/poi/PoiManager.ts

@@ -177,7 +177,7 @@ export class PoiManager {
             }
 
             const positions = new THREE.BufferAttribute(
-                new Float32Array(poiGeometry.positions.buffer),
+                new Float64Array(poiGeometry.positions.buffer),
                 poiGeometry.positions.itemCount
             );
 

@here/harp-vectortile-datasource/lib/VectorTileDataEmitter.ts

@@ -713,7 +713,7 @@ export class VectorTileDataEmitter {
                             positions: {
                                 name: "position",
                                 type: "float",
-                                buffer: new Float32Array(aLine).buffer,
+                                buffer: new Float64Array(aLine).buffer,
                                 itemCount: 3
                             },
                             texts: [0],
@@ -1706,43 +1706,34 @@ export class VectorTileDataEmitter {
             if (technique === undefined) {
                 return;
             }
-
-            const positionElements = new Float32Array(meshBuffers.positions);
-
-            if (meshBuffers.texts.length > 0 && isTextTechnique(technique)) {
-                this.m_textGeometries.push({
+            if (meshBuffers.texts.length > 0) {
+                const geometry: TextGeometry = {
                     positions: {
                         name: "position",
                         type: "float",
-                        buffer: positionElements.buffer as ArrayBuffer,
+                        buffer: new Float64Array(meshBuffers.positions).buffer,
                         itemCount: 3
                     },
                     texts: meshBuffers.texts,
                     technique: techniqueIdx,
                     stringCatalog: meshBuffers.stringCatalog,
                     objInfos: meshBuffers.objInfos
-                });
-                return;
-            }
+                };
 
-            if (meshBuffers.texts.length > 0 && isPoiTechnique(technique)) {
-                this.m_poiGeometries.push({
-                    positions: {
-                        name: "position",
-                        type: "float",
-                        buffer: positionElements.buffer as ArrayBuffer,
-                        itemCount: 3
-                    },
-                    texts: meshBuffers.texts,
-                    technique: techniqueIdx,
-                    stringCatalog: meshBuffers.stringCatalog,
-                    imageTextures: meshBuffers.imageTextures,
-                    objInfos: meshBuffers.objInfos,
-                    offsetDirections: meshBuffers.offsetDirections
-                });
+                if (isTextTechnique(technique)) {
+                    this.m_textGeometries.push(geometry);
+                } else {
+                    assert(isPoiTechnique(technique));
+                    const poiGeometry = geometry as PoiGeometry;
+                    poiGeometry.imageTextures = meshBuffers.imageTextures;
+                    poiGeometry.offsetDirections = meshBuffers.offsetDirections;
+                    this.m_poiGeometries.push(poiGeometry);
+                }
                 return;
             }
 
+            const positionElements = new Float32Array(meshBuffers.positions);
+
             if (meshBuffers.groups.length === 0) {
                 // create a default group containing all the vertices in the position attribute.
 

@here/harp-vectortile-datasource/test/OmvDecodedTileEmitterTest.ts

@@ -124,12 +124,17 @@ describe("OmvDecodedTileEmitter", function () {
         const tileKey = TileKey.fromRowColumnLevel(0, 0, level);
         const decodeInfo = new DecodeInfo("test", mercatorProjection, tileKey);
 
-        function getExpectedHeight(geoAltitude: number, worldCoords: Vector3Like) {
+        function getExpectedHeight(
+            geoAltitude: number,
+            worldCoords: Vector3Like,
+            toSinglePrecision = true
+        ) {
             const scaleFactor = expectScaledHeight
                 ? decodeInfo.targetProjection.getScaleFactor(worldCoords)
                 : 1.0;
+            const expectedHeight = geoAltitude * scaleFactor;
             // Force conversion to single precision as in decoder so that results match.
-            return new Float32Array([geoAltitude * scaleFactor])[0];
+            return toSinglePrecision ? new Float32Array([expectedHeight])[0] : expectedHeight;
         }
 
         it(`Point Height at level ${level} with constantHeight ${
@@ -174,13 +179,13 @@ describe("OmvDecodedTileEmitter", function () {
 
             assert.equal(textGeometries?.length, 1, "only one geometry created");
 
-            const buffer = new Float32Array(textGeometries![0].positions.buffer);
+            const buffer = new Float64Array(textGeometries![0].positions.buffer);
             assert.equal(buffer.length, 3, "one position (3 coordinates)");
 
             const actualHeight = buffer[2];
             assert.approximately(
                 actualHeight,
-                getExpectedHeight(geoCoords.altitude, worldCoords),
+                getExpectedHeight(geoCoords.altitude, worldCoords, false),
                 1e-6
             );
         });