@gisatcz/deckgl-geolib 1.10.1-dev.1 → 1.10.2-dev.0

package/dist/cjs/types/cogterrainlayer/CogTerrainLayer.d.ts

@@ -1,61 +1,83 @@
-import { CompositeLayer } from '@deck.gl/core';
-import { TileLayer, TerrainLayer } from '@deck.gl/geo-layers';
-import CogTiles from '../cogtiles/cogtiles.ts';
+import { Color, CompositeLayer, CompositeLayerProps, DefaultProps, Layer, LayersList, Material, TextureSource, UpdateParameters } from '@deck.gl/core';
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
+import type { MeshAttributes } from '@loaders.gl/schema';
+import { TileLayerProps, GeoBoundingBox, _TileLoadProps as TileLoadProps, _Tile2DHeader as Tile2DHeader, NonGeoBoundingBox } from '@deck.gl/geo-layers';
 import { GeoImageOptions } from '../geoimage/geoimage.ts';
-declare class CogTerrainLayer extends CompositeLayer<any> {
+import CogTiles from '../cogtiles/cogtiles.ts';
+export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
+export type TileBoundingBox = NonGeoBoundingBox | GeoBoundingBox;
+export type ZRange = [minZ: number, maxZ: number];
+export type URLTemplate = string | string[] | null;
+export declare const urlType: {
+    type: "object";
+    value: URLTemplate;
+    validate: (value: any, propType: any) => boolean;
+    equal: (value1: any, value2: any) => boolean;
+};
+type ElevationDecoder = {
+    rScaler: number;
+    gScaler: number;
+    bScaler: number;
+    offset: number;
+};
+type TerrainLoadProps = {
+    bounds: Bounds;
+    elevationData: string | null;
+    elevationDecoder: ElevationDecoder;
+    meshMaxError: number;
+    signal?: AbortSignal;
+};
+type MeshAndTexture = [MeshAttributes | null, TextureSource | null];
+/** All properties supported by TerrainLayer */
+export type TerrainLayerProps = _TerrainLayerProps & TileLayerProps<MeshAndTexture> & CompositeLayerProps;
+/** Props added by the TerrainLayer */
+type _TerrainLayerProps = {
+    /** Image url that encodes height data. * */
+    elevationData: URLTemplate;
+    /** Image url to use as texture. * */
+    texture?: URLTemplate;
+    /** Martini error tolerance in meters, smaller number -> more detailed mesh. * */
+    meshMaxError?: number;
+    /** Bounding box of the terrain image, [minX, minY, maxX, maxY] in world coordinates. * */
+    bounds?: Bounds | null;
+    /** Color to use if texture is unavailable. * */
+    color?: Color;
+    /** Object to decode height data, from (r, g, b) to height in meters. * */
+    elevationDecoder?: ElevationDecoder;
+    /** Whether to render the mesh in wireframe mode. * */
+    wireframe?: boolean;
+    /** Material props for lighting effect. * */
+    material?: Material;
+    /**
+     * @deprecated Use `loadOptions.terrain.workerUrl` instead
+     */
+    workerUrl?: string;
+};
+/** Render mesh surfaces from height map images. */
+export default class TerrainLayer<ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT & Required<_TerrainLayerProps & Required<TileLayerProps<MeshAndTexture>>>> {
+    static defaultProps: DefaultProps<TerrainLayerProps>;
     static layerName: string;
     terrainCogTiles: CogTiles;
-    bitmapCogTiles: CogTiles;
-    tileSize: number;
+    terrainUrl: string;
     minZoom: number;
     maxZoom: number;
-    bitmapUrl: string;
-    urlType: 'none' | 'tile' | 'cog';
-    id: string;
-    terrainUrl: string;
-    terrainOpacity: number;
-    terrainColor: Array<number>;
-    terrainSkirtHeight: number;
-    static displayName: string;
-    constructor(id: string, terrainUrl: string, terrainOptions: GeoImageOptions, bitmapUrl?: string, bitmapOptions?: GeoImageOptions);
-    initializeState(): Promise<void>;
-    shouldUpdateState(): boolean;
+    state: {
+        isTiled?: boolean;
+        terrain?: MeshAttributes;
+        zRange?: ZRange | null;
+    };
+    constructor(props: TerrainLayerProps & ExtraPropsT, terrainOptions: GeoImageOptions);
+    initializeState(context: any): Promise<void>;
     init(terrainUrl: string): Promise<void>;
-    renderLayers(): TileLayer<any, {
-        id: `${string}-${string}`;
-        zoomOffset: -1;
-        getTileData: (tileData: any) => Promise<string>;
-        minZoom: number;
-        maxZoom: number;
-        tileSize: number;
-        maxRequests: 6;
-        refinementStrategy: "best-available";
-        extent: [number, number, number, number];
-        renderSubLayers: (props: any) => TerrainLayer<{
-            id: `terrain-${any}-${any}-${any}`;
-            pickable: boolean;
-            elevationDecoder: {
-                rScaler: number;
-                gScaler: number;
-                bScaler: number;
-                offset: number;
-            };
-            elevationData: any;
-            texture: string;
-            opacity: number;
-            bounds: [any, any, any, any];
-            color: number[];
-            operation: "terrain+draw";
-            minZoom: number;
-            maxZoom: number;
-            loadOptions: {
-                terrain: {
-                    skirtHeight: number;
-                    tesselator: string;
-                };
-            };
-            meshMaxError: number;
-        }>;
-    }>[];
+    updateState({ props, oldProps }: UpdateParameters<this>): void;
+    loadTerrain({ elevationData, bounds, elevationDecoder, meshMaxError, signal, }: TerrainLoadProps): Promise<MeshAttributes> | null;
+    getTiledTerrainData(tile: TileLoadProps): Promise<MeshAndTexture>;
+    renderSubLayers(props: TileLayerProps<MeshAndTexture> & {
+        id: string;
+        data: MeshAndTexture;
+        tile: Tile2DHeader<MeshAndTexture>;
+    }): SimpleMeshLayer<any, {}>;
+    onViewportLoad(tiles?: Tile2DHeader<MeshAndTexture>[]): void;
+    renderLayers(): Layer | null | LayersList;
 }
-export default CogTerrainLayer;
+export {};