Migrate TileMesh-related modules to typescript

packages/Main/src/Converter/convertToTile.js → packages/Main/src/Converter/convertToTile.ts

@@ -1,15 +1,32 @@
 import * as THREE from 'three';
 import TileMesh from 'Core/TileMesh';
 import { LayeredMaterial } from 'Renderer/LayeredMaterial';
-import { newTileGeometry } from 'Core/Prefab/TileBuilder';
+import { newTileGeometry, TileBuilder, TileBuilderParams } from 'Core/Prefab/TileBuilder';
 import ReferLayerProperties from 'Layer/ReferencingLayerProperties';
 import { geoidLayerIsVisible } from 'Layer/GeoidLayer';
 
+import type { Extent } from '@itowns/geographic';
+import type { LayeredMaterialParameters } from 'Renderer/LayeredMaterial';
+
 const dimensions = new THREE.Vector2();
 
-function setTileFromTiledLayer(tile, tileLayer) {
+// A simplified interface for TiledGeometryLayer.
+// It is used to avoid a dependency on the full TiledGeometryLayer type.
+interface TileLayerLike {
+    diffuse: THREE.Color;
+    showOutline: boolean;
+    isGlobeLayer: boolean;
+    segments: number;
+    disableSkirt: boolean;
+    hideSkirt: boolean;
+    tileMatrixSets: string[];
+    materialOptions: LayeredMaterialParameters;
+    builder: TileBuilder<TileBuilderParams>;
+}
+
+function setTileFromTiledLayer(tile: TileMesh, tileLayer: TileLayerLike) {
     if (tileLayer.diffuse) {
-        tile.material.diffuse = tileLayer.diffuse;
+        tile.material.setUniform('diffuse', tileLayer.diffuse);
     }
 
     if (__DEBUG__) {
@@ -32,7 +49,7 @@ function setTileFromTiledLayer(tile, tileLayer) {
 }
 
 export default {
-    convert(requester, extent, layer) {
+    convert(requester: TileMesh, extent: Extent, layer: TileLayerLike) {
         const builder = layer.builder;
         const parent = requester;
         const level = (parent !== undefined) ? (parent.level + 1) : 0;

packages/Main/src/Core/Prefab/Planar/PlanarTileBuilder.ts

@@ -17,7 +17,6 @@ type Transform = {
 
 /** Specialized parameters for the [PlanarTileBuilder]. */
 export interface PlanarTileBuilderParams extends TileBuilderParams {
-    crs: string;
     uvCount?: number;
     nbRow: number;
 }

packages/Main/src/Core/Prefab/TileBuilder.ts

@@ -29,31 +29,33 @@ export type ShareableExtent = {
     position: THREE.Vector3;
 };
 
-export interface TileBuilderParams {
+export interface TileBuilderPrepareParams {
     /** Whether to build the skirt. */
     disableSkirt: boolean;
     /** Whether to render the skirt. */
     hideSkirt: boolean;
     /** Number of segments (edge loops) inside tiles. */
     segments: number;
-    // TODO: Move this out of the interface
     /** Buffer for projected points. */
-    coordinates: Coordinates;
     extent: Extent;
     level: number;
+}
+
+export interface TileBuilderParams extends TileBuilderPrepareParams {
     center: THREE.Vector3;
+    coordinates: Coordinates;
 }
 
-export interface TileBuilder<SpecializedParams extends TileBuilderParams> {
+export interface TileBuilder<SpecializedParams extends TileBuilderParams = TileBuilderParams> {
     crs: string;
 
     /** Convert builder-agnostic params to specialized ones. */
-    prepare(params: TileBuilderParams): SpecializedParams;
+    prepare(params: TileBuilderPrepareParams): SpecializedParams;
     /**
      * Computes final offset of the second texture set.
      * Only relevant in the case of more than one texture sets.
      */
-    computeExtraOffset?: (params: SpecializedParams) => number;
+    computeExtraOffset?(params: SpecializedParams): number;
     /** Get the center of the current tile as a 3D vector. */
     center(extent: Extent): THREE.Vector3;
     /** Converts an x/y tile-space position to its equivalent in 3D space. */
@@ -73,8 +75,8 @@ export interface TileBuilder<SpecializedParams extends TileBuilderParams> {
 }
 
 export function newTileGeometry(
-    builder: TileBuilder<TileBuilderParams>,
-    params: TileBuilderParams,
+    builder: TileBuilder,
+    params: TileBuilderPrepareParams,
 ) {
     const { shareableExtent, quaternion, position } =
         builder.computeShareableExtent(params.extent);
@@ -94,7 +96,7 @@ export function newTileGeometry(
         cacheTile.set(key, promiseGeometry);
 
         params.extent = shareableExtent;
-        params.center = builder.center(params.extent).clone();
+        const center = builder.center(params.extent).clone();
         // Read previously cached values (index and uv.wgs84 only
         // depend on the # of triangles)
         let cachedBuffers = cacheBuffer.get(bufferKey);
@@ -103,7 +105,7 @@ export function newTileGeometry(
         try {
             buffers = computeBuffers(
                 builder,
-                params,
+                { ...params, center },
                 cachedBuffers !== undefined
                     ? {
                         index: cachedBuffers.index.array as

packages/Main/src/Core/Prefab/computeBufferTileGeometry.ts

@@ -1,5 +1,5 @@
-import type { TileBuilder, TileBuilderParams } from 'Core/Prefab/TileBuilder';
 import * as THREE from 'three';
+import type { TileBuilder, TileBuilderPrepareParams } from 'Core/Prefab/TileBuilder';
 
 export function getBufferIndexSize(segments: number, noSkirt: boolean): number {
     const triangles = (segments) * (segments) * 2
@@ -48,7 +48,7 @@ type BufferCache = {
 function allocateIndexBuffer(
     nVertex: number,
     nSeg: number,
-    params: TileBuilderParams,
+    params: { disableSkirt: boolean },
     cache?: BufferCache['index'],
 ): { index: IndexArray, skirt: IndexArray } {
     const indexBufferSize = getBufferIndexSize(nSeg, params.disableSkirt);
@@ -66,7 +66,7 @@ function allocateIndexBuffer(
         tileLen
         // Skirt
         + (params.disableSkirt ? 0 : skirtLen)
-    ) * indexConstructor!.BYTES_PER_ELEMENT);
+    ) * indexConstructor.BYTES_PER_ELEMENT);
 
     const index = new indexConstructor(indexBuffer);
     const skirt = !params.disableSkirt
@@ -82,8 +82,8 @@ function allocateIndexBuffer(
 function allocateBuffers(
     nVertex: number,
     nSeg: number,
-    builder: TileBuilder<TileBuilderParams>,
-    params: TileBuilderParams,
+    builder: TileBuilder,
+    params: { disableSkirt: boolean },
     cache?: BufferCache,
 ): BuffersAndSkirt {
     const {
@@ -133,11 +133,15 @@ function initComputeUv1(value: number): (uv: Float32Array, id: number) => void {
 type ComputeUvs =
     [typeof computeUv0 | (() => void), ReturnType<typeof initComputeUv1>?];
 
+interface ComputeBuffersParams extends TileBuilderPrepareParams {
+    center: THREE.Vector3;
+}
+
 /** Compute buffers describing a tile according to a builder and its params. */
 // TODO: Split this even further into subfunctions
 export function computeBuffers(
-    builder: TileBuilder<TileBuilderParams>,
-    params: TileBuilderParams,
+    builder: TileBuilder,
+    params: ComputeBuffersParams,
     cache?: BufferCache,
 ): Buffers {
     //     n seg, n+1 vert    + <- skirt, n verts per side
@@ -171,36 +175,36 @@ export function computeBuffers(
     const computeUvs: ComputeUvs =
         [cache === undefined ? computeUv0 : () => { }];
 
-    params = builder.prepare(params);
+    const preparedParams = builder.prepare(params);
 
     for (let y = 0; y <= nSeg; y++) {
         const v = y / nSeg;
 
-        params.coordinates.y = builder.vProject(v, params.extent);
+        preparedParams.coordinates.y = builder.vProject(v, params.extent);
 
         if (builder.computeExtraOffset !== undefined) {
             computeUvs[1] = initComputeUv1(
-                builder.computeExtraOffset(params) as number,
+                builder.computeExtraOffset(preparedParams) as number,
             );
         }
 
         for (let x = 0; x <= nSeg; x++) {
             const u = x / nSeg;
             const id_m3 = (y * nVertex + x) * 3;
 
-            params.coordinates.x = builder.uProject(u, params.extent);
+            preparedParams.coordinates.x = builder.uProject(u, preparedParams.extent);
 
-            const vertex = builder.vertexPosition(params.coordinates);
+            const vertex = builder.vertexPosition(preparedParams.coordinates);
             const normal = builder.vertexNormal();
 
             // move geometry to center world
-            vertex.sub(params.center);
+            vertex.sub(preparedParams.center);
 
             // align normal to z axis
             // HACK: this check style is not great
-            if ('quatNormalToZ' in params) {
+            if ('quatNormalToZ' in preparedParams) {
                 const quat =
-                    params.quatNormalToZ as THREE.Quaternion;
+                    preparedParams.quatNormalToZ as THREE.Quaternion;
                 vertex.applyQuaternion(quat);
                 normal.applyQuaternion(quat);
             }
@@ -217,7 +221,7 @@ export function computeBuffers(
     }
 
     // Fill skirt index buffer
-    if (cache === undefined && !params.disableSkirt) {
+    if (cache === undefined && !preparedParams.disableSkirt) {
         for (let x = 0; x < nVertex; x++) {
             //   -------->
             //   0---1---2

packages/Main/src/Core/TileGeometry.ts

@@ -9,13 +9,14 @@ import { LRUCache } from 'lru-cache';
 
 import OBB from 'Renderer/OBB';
 
-type PartialTileBuilderParams =
-    Pick<TileBuilderParams, 'extent' | 'level'>
-    & Partial<TileBuilderParams>;
+type PartialParams<
+    Params extends TileBuilderParams,
+    Keys extends keyof Params = 'extent' | 'level'
+> = Pick<Params, Keys> & Partial<Params>;
 
 function defaultBuffers(
-    builder: TileBuilder<TileBuilderParams>,
-    params: PartialTileBuilderParams,
+    builder: TileBuilder,
+    params: PartialParams<TileBuilderParams>,
 ): GpuBufferAttributes {
     const fullParams = {
         disableSkirt: false,
@@ -70,8 +71,8 @@ export class TileGeometry extends THREE.BufferGeometry {
     } | null;
 
     public constructor(
-        builder: TileBuilder<TileBuilderParams>,
-        params: TileBuilderParams,
+        builder: TileBuilder,
+        params: PartialParams<TileBuilderParams, 'extent' | 'level' | 'segments'>,
         bufferAttributes: GpuBufferAttributes = defaultBuffers(builder, params),
     ) {
         super();
@@ -88,9 +89,7 @@ export class TileGeometry extends THREE.BufferGeometry {
 
         this.computeBoundingBox();
         this.OBB = null;
-        if (params.hideSkirt) {
-            this.hideSkirt = params.hideSkirt;
-        }
+        this.hideSkirt = params.hideSkirt ?? false;
 
         this._refCount = null;
     }
@@ -111,7 +110,7 @@ export class TileGeometry extends THREE.BufferGeometry {
      * @param keys - The [south, level, epsg] key of this geometry.
      */
     public initRefCount(
-        cacheTile: LRUCache<string, Promise<TileGeometry>>,
+        cacheTile: LRUCache<string, Promise<this>>,
         key: string,
     ): void {
         if (this._refCount !== null) {