@deck.gl/geo-layers 8.9.11 → 8.9.13

package/package.json

@@ -2,7 +2,7 @@
   "name": "@deck.gl/geo-layers",
   "description": "deck.gl layers supporting geospatial use cases and GIS formats",
   "license": "MIT",
-  "version": "8.9.11",
+  "version": "8.9.13",
   "publishConfig": {
     "access": "public"
   },
@@ -30,16 +30,16 @@
     "prepublishOnly": "npm run build-bundle && npm run build-bundle -- --env=dev"
   },
   "dependencies": {
-    "@loaders.gl/3d-tiles": "^3.3.3",
-    "@loaders.gl/gis": "^3.3.3",
-    "@loaders.gl/loader-utils": "^3.3.3",
-    "@loaders.gl/mvt": "^3.3.3",
-    "@loaders.gl/schema": "^3.3.3",
-    "@loaders.gl/terrain": "^3.3.3",
-    "@loaders.gl/tiles": "^3.3.3",
-    "@loaders.gl/wms": "^3.3.3",
-    "@luma.gl/constants": "^8.5.16",
-    "@luma.gl/experimental": "^8.5.16",
+    "@loaders.gl/3d-tiles": "^3.3.4",
+    "@loaders.gl/gis": "^3.3.4",
+    "@loaders.gl/loader-utils": "^3.3.4",
+    "@loaders.gl/mvt": "^3.3.4",
+    "@loaders.gl/schema": "^3.3.4",
+    "@loaders.gl/terrain": "^3.3.4",
+    "@loaders.gl/tiles": "^3.3.4",
+    "@loaders.gl/wms": "^3.3.4",
+    "@luma.gl/constants": "^8.5.20",
+    "@luma.gl/experimental": "^8.5.20",
     "@math.gl/core": "^3.6.2",
     "@math.gl/culling": "^3.6.2",
     "@math.gl/web-mercator": "^3.6.2",
@@ -55,5 +55,5 @@
     "@loaders.gl/core": "^3.3.0",
     "@luma.gl/core": "^8.0.0"
   },
-  "gitHead": "ec059b9b2bde01fecc8017ed39b9898d85794561"
+  "gitHead": "6e0fdd9f81c1156103df2701e6688cf0c2fa9320"
 }

package/typed/geo-cell-layer/GeoCellLayer.js

@@ -0,0 +1,49 @@
+import { CompositeLayer } from '@deck.gl/core';
+import { PolygonLayer } from '@deck.gl/layers';
+const defaultProps = {
+    ...PolygonLayer.defaultProps
+};
+export default class GeoCellLayer extends CompositeLayer {
+    /** Implement to generate props to create geometry. */
+    indexToBounds() {
+        return null;
+    }
+    renderLayers() {
+        // Rendering props underlying layer
+        const { elevationScale, extruded, wireframe, filled, stroked, lineWidthUnits, lineWidthScale, lineWidthMinPixels, lineWidthMaxPixels, lineJointRounded, lineMiterLimit, lineDashJustified, getElevation, getFillColor, getLineColor, getLineWidth } = this.props;
+        // Accessor props for underlying layers
+        const { updateTriggers, material, transitions } = this.props;
+        // Filled Polygon Layer
+        const CellLayer = this.getSubLayerClass('cell', PolygonLayer);
+        return new CellLayer({
+            filled,
+            wireframe,
+            extruded,
+            elevationScale,
+            stroked,
+            lineWidthUnits,
+            lineWidthScale,
+            lineWidthMinPixels,
+            lineWidthMaxPixels,
+            lineJointRounded,
+            lineMiterLimit,
+            lineDashJustified,
+            material,
+            transitions,
+            getElevation,
+            getFillColor,
+            getLineColor,
+            getLineWidth
+        }, this.getSubLayerProps({
+            id: 'cell',
+            updateTriggers: updateTriggers && {
+                getElevation: updateTriggers.getElevation,
+                getFillColor: updateTriggers.getFillColor,
+                getLineColor: updateTriggers.getLineColor,
+                getLineWidth: updateTriggers.getLineWidth
+            }
+        }), this.indexToBounds());
+    }
+}
+GeoCellLayer.layerName = 'GeoCellLayer';
+GeoCellLayer.defaultProps = defaultProps;

package/typed/great-circle-layer/great-circle-layer.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import { ArcLayer } from '@deck.gl/layers';
+// This layer has been merged into the core ArcLayer
+// Keeping for backward-compatibility
+export default class GreatCircleLayer extends ArcLayer {
+}
+GreatCircleLayer.layerName = 'GreatCircleLayer';
+GreatCircleLayer.defaultProps = {
+    getHeight: { type: 'accessor', value: 0 },
+    greatCircle: true
+};

package/typed/h3-layers/h3-cluster-layer.js

@@ -0,0 +1,33 @@
+import { h3SetToMultiPolygon } from 'h3-js';
+import { createIterable } from '@deck.gl/core';
+import GeoCellLayer from '../geo-cell-layer/GeoCellLayer';
+const defaultProps = {
+    getHexagons: { type: 'accessor', value: d => d.hexagons }
+};
+export default class H3ClusterLayer extends GeoCellLayer {
+    updateState({ props, oldProps, changeFlags }) {
+        if (changeFlags.dataChanged ||
+            (changeFlags.updateTriggers && changeFlags.updateTriggers.getHexagons)) {
+            const { data, getHexagons } = props;
+            const polygons = [];
+            const { iterable, objectInfo } = createIterable(data);
+            for (const object of iterable) {
+                objectInfo.index++;
+                const hexagons = getHexagons(object, objectInfo);
+                const multiPolygon = h3SetToMultiPolygon(hexagons, true);
+                for (const polygon of multiPolygon) {
+                    polygons.push(this.getSubLayerRow({ polygon }, object, objectInfo.index));
+                }
+            }
+            this.setState({ polygons });
+        }
+    }
+    indexToBounds() {
+        return {
+            data: this.state.polygons,
+            getPolygon: d => d.polygon
+        };
+    }
+}
+H3ClusterLayer.defaultProps = defaultProps;
+H3ClusterLayer.layerName = 'H3ClusterLayer';

package/typed/h3-layers/h3-hexagon-layer.js

@@ -0,0 +1,251 @@
+import { h3ToGeoBoundary, h3GetResolution, h3ToGeo, geoToH3, h3IsPentagon, h3Distance, edgeLength, UNITS } from 'h3-js';
+import { lerp } from '@math.gl/core';
+import { CompositeLayer, createIterable } from '@deck.gl/core';
+import { ColumnLayer, PolygonLayer } from '@deck.gl/layers';
+// There is a cost to updating the instanced geometries when using highPrecision: false
+// This constant defines the distance between two hexagons that leads to "significant
+// distortion." Smaller value makes the column layer more sensitive to viewport change.
+const UPDATE_THRESHOLD_KM = 10;
+// normalize longitudes w.r.t center (refLng), when not provided first vertex
+export function normalizeLongitudes(vertices, refLng) {
+    refLng = refLng === undefined ? vertices[0][0] : refLng;
+    for (const pt of vertices) {
+        const deltaLng = pt[0] - refLng;
+        if (deltaLng > 180) {
+            pt[0] -= 360;
+        }
+        else if (deltaLng < -180) {
+            pt[0] += 360;
+        }
+    }
+}
+// scale polygon vertices w.r.t center (hexId)
+export function scalePolygon(hexId, vertices, factor) {
+    const [lat, lng] = h3ToGeo(hexId);
+    const actualCount = vertices.length;
+    // normalize with respect to center
+    normalizeLongitudes(vertices, lng);
+    // `h3ToGeoBoundary` returns same array object for first and last vertex (closed polygon),
+    // if so skip scaling the last vertex
+    const vertexCount = vertices[0] === vertices[actualCount - 1] ? actualCount - 1 : actualCount;
+    for (let i = 0; i < vertexCount; i++) {
+        vertices[i][0] = lerp(lng, vertices[i][0], factor);
+        vertices[i][1] = lerp(lat, vertices[i][1], factor);
+    }
+}
+function getHexagonCentroid(getHexagon, object, objectInfo) {
+    const hexagonId = getHexagon(object, objectInfo);
+    const [lat, lng] = h3ToGeo(hexagonId);
+    return [lng, lat];
+}
+function h3ToPolygon(hexId, coverage = 1, flatten) {
+    const vertices = h3ToGeoBoundary(hexId, true);
+    if (coverage !== 1) {
+        // scale and normalize vertices w.r.t to center
+        scalePolygon(hexId, vertices, coverage);
+    }
+    else {
+        // normalize w.r.t to start vertex
+        normalizeLongitudes(vertices);
+    }
+    if (flatten) {
+        const positions = new Float64Array(vertices.length * 2);
+        let i = 0;
+        for (const pt of vertices) {
+            positions[i++] = pt[0];
+            positions[i++] = pt[1];
+        }
+        return positions;
+    }
+    return vertices;
+}
+function mergeTriggers(getHexagon, coverage) {
+    let trigger;
+    if (getHexagon === undefined || getHexagon === null) {
+        trigger = coverage;
+    }
+    else if (typeof getHexagon === 'object') {
+        trigger = { ...getHexagon, coverage };
+    }
+    else {
+        trigger = { getHexagon, coverage };
+    }
+    return trigger;
+}
+const defaultProps = {
+    ...PolygonLayer.defaultProps,
+    highPrecision: 'auto',
+    coverage: { type: 'number', min: 0, max: 1, value: 1 },
+    centerHexagon: null,
+    getHexagon: { type: 'accessor', value: x => x.hexagon },
+    extruded: true
+};
+// not supported
+delete defaultProps.getLineDashArray;
+/**
+ * A subclass of HexagonLayer that uses H3 hexagonIds in data objects
+ * rather than centroid lat/longs. The shape of each hexagon is determined
+ * based on a single "center" hexagon, which can be selected by passing in
+ * a center lat/lon pair. If not provided, the map center will be used.
+ *
+ * Also sets the `hexagonId` field in the onHover/onClick callback's info
+ * objects. Since this is calculated using math, hexagonId will be present
+ * even when no corresponding hexagon is in the data set. You can check
+ * index !== -1 to see if picking matches an actual object.
+ */
+export default class H3HexagonLayer extends CompositeLayer {
+    shouldUpdateState({ changeFlags }) {
+        return this._shouldUseHighPrecision()
+            ? changeFlags.propsOrDataChanged
+            : changeFlags.somethingChanged;
+    }
+    updateState({ props, oldProps, changeFlags }) {
+        if (props.highPrecision !== true &&
+            (changeFlags.dataChanged ||
+                (changeFlags.updateTriggers && changeFlags.updateTriggers.getHexagon))) {
+            const dataProps = this._calculateH3DataProps(props);
+            this.setState(dataProps);
+        }
+        this._updateVertices(this.context.viewport);
+    }
+    _calculateH3DataProps(props) {
+        let resolution = -1;
+        let hasPentagon = false;
+        let hasMultipleRes = false;
+        const { iterable, objectInfo } = createIterable(props.data);
+        for (const object of iterable) {
+            objectInfo.index++;
+            const hexId = props.getHexagon(object, objectInfo);
+            // Take the resolution of the first hex
+            const hexResolution = h3GetResolution(hexId);
+            if (resolution < 0) {
+                resolution = hexResolution;
+                if (!props.highPrecision)
+                    break;
+            }
+            else if (resolution !== hexResolution) {
+                hasMultipleRes = true;
+                break;
+            }
+            if (h3IsPentagon(hexId)) {
+                hasPentagon = true;
+                break;
+            }
+        }
+        return {
+            resolution,
+            edgeLengthKM: resolution >= 0 ? edgeLength(resolution, UNITS.km) : 0,
+            hasMultipleRes,
+            hasPentagon
+        };
+    }
+    _shouldUseHighPrecision() {
+        if (this.props.highPrecision === 'auto') {
+            const { resolution, hasPentagon, hasMultipleRes } = this.state;
+            const { viewport } = this.context;
+            return (viewport.resolution || hasMultipleRes || hasPentagon || (resolution >= 0 && resolution <= 5));
+        }
+        return this.props.highPrecision;
+    }
+    _updateVertices(viewport) {
+        if (this._shouldUseHighPrecision()) {
+            return;
+        }
+        const { resolution, edgeLengthKM, centerHex } = this.state;
+        if (resolution < 0) {
+            return;
+        }
+        const hex = this.props.centerHexagon || geoToH3(viewport.latitude, viewport.longitude, resolution);
+        if (centerHex === hex) {
+            return;
+        }
+        if (centerHex) {
+            const distance = h3Distance(centerHex, hex);
+            // h3Distance returns a negative number if the distance could not be computed
+            // due to the two indexes very far apart or on opposite sides of a pentagon.
+            if (distance >= 0 && distance * edgeLengthKM < UPDATE_THRESHOLD_KM) {
+                return;
+            }
+        }
+        const { unitsPerMeter } = viewport.distanceScales;
+        let vertices = h3ToPolygon(hex);
+        const [centerLat, centerLng] = h3ToGeo(hex);
+        const [centerX, centerY] = viewport.projectFlat([centerLng, centerLat]);
+        vertices = vertices.map(p => {
+            const worldPosition = viewport.projectFlat(p);
+            return [
+                (worldPosition[0] - centerX) / unitsPerMeter[0],
+                (worldPosition[1] - centerY) / unitsPerMeter[1]
+            ];
+        });
+        this.setState({ centerHex: hex, vertices });
+    }
+    renderLayers() {
+        return this._shouldUseHighPrecision() ? this._renderPolygonLayer() : this._renderColumnLayer();
+    }
+    _getForwardProps() {
+        const { elevationScale, material, coverage, extruded, wireframe, stroked, filled, lineWidthUnits, lineWidthScale, lineWidthMinPixels, lineWidthMaxPixels, getFillColor, getElevation, getLineColor, getLineWidth, transitions, updateTriggers } = this.props;
+        return {
+            elevationScale,
+            extruded,
+            coverage,
+            wireframe,
+            stroked,
+            filled,
+            lineWidthUnits,
+            lineWidthScale,
+            lineWidthMinPixels,
+            lineWidthMaxPixels,
+            material,
+            getElevation,
+            getFillColor,
+            getLineColor,
+            getLineWidth,
+            transitions,
+            updateTriggers: {
+                getFillColor: updateTriggers.getFillColor,
+                getElevation: updateTriggers.getElevation,
+                getLineColor: updateTriggers.getLineColor,
+                getLineWidth: updateTriggers.getLineWidth
+            }
+        };
+    }
+    _renderPolygonLayer() {
+        const { data, getHexagon, updateTriggers, coverage } = this.props;
+        const SubLayerClass = this.getSubLayerClass('hexagon-cell-hifi', PolygonLayer);
+        const forwardProps = this._getForwardProps();
+        forwardProps.updateTriggers.getPolygon = mergeTriggers(updateTriggers.getHexagon, coverage);
+        return new SubLayerClass(forwardProps, this.getSubLayerProps({
+            id: 'hexagon-cell-hifi',
+            updateTriggers: forwardProps.updateTriggers
+        }), {
+            data,
+            _normalize: false,
+            _windingOrder: 'CCW',
+            positionFormat: 'XY',
+            getPolygon: (object, objectInfo) => {
+                const hexagonId = getHexagon(object, objectInfo);
+                return h3ToPolygon(hexagonId, coverage, true);
+            }
+        });
+    }
+    _renderColumnLayer() {
+        const { data, getHexagon, updateTriggers } = this.props;
+        const SubLayerClass = this.getSubLayerClass('hexagon-cell', ColumnLayer);
+        const forwardProps = this._getForwardProps();
+        forwardProps.updateTriggers.getPosition = updateTriggers.getHexagon;
+        return new SubLayerClass(forwardProps, this.getSubLayerProps({
+            id: 'hexagon-cell',
+            flatShading: true,
+            updateTriggers: forwardProps.updateTriggers
+        }), {
+            data,
+            diskResolution: 6,
+            radius: 1,
+            vertices: this.state.vertices,
+            getPosition: getHexagonCentroid.bind(null, getHexagon)
+        });
+    }
+}
+H3HexagonLayer.defaultProps = defaultProps;
+H3HexagonLayer.layerName = 'H3HexagonLayer';

package/typed/imagery-layer/imagery-layer.d.ts

@@ -0,0 +1,53 @@
+import { Layer, CompositeLayer, CompositeLayerProps, UpdateParameters, DefaultProps, Viewport } from '@deck.gl/core/typed';
+import type { ImageSourceMetadata, ImageType, ImageServiceType } from '@loaders.gl/wms';
+import { ImageSource } from '@loaders.gl/wms';
+/** All props supported by the TileLayer */
+export declare type ImageryLayerProps = CompositeLayerProps<any> & _ImageryLayerProps;
+/** Props added by the TileLayer */
+declare type _ImageryLayerProps = {
+    serviceType?: ImageServiceType | 'auto';
+    layers?: string[];
+    srs?: 'EPSG:4326' | 'EPSG:3857' | 'auto';
+    onMetadataLoadStart?: () => void;
+    onMetadataLoadComplete?: (metadata: ImageSourceMetadata) => void;
+    onMetadataLoadError?: (error: Error) => void;
+    onImageLoadStart?: (requestId: unknown) => void;
+    onImageLoadComplete?: (requestId: unknown) => void;
+    onImageLoadError?: (requestId: unknown, error: Error) => void;
+};
+/**
+ * The layer is used in Hex Tile layer in order to properly discard invisible elements during animation
+ */
+export declare class ImageryLayer<ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT & Required<_ImageryLayerProps>> {
+    static layerName: string;
+    static defaultProps: DefaultProps;
+    state: {
+        imageSource: ImageSource;
+        image: ImageType;
+        srs: 'EPSG:4326' | 'EPSG:3857';
+        bounds: [number, number, number, number];
+        width: number;
+        height: number;
+        lastLoadedId: number;
+        _nextRequestId: number;
+        _timeoutId: any;
+    };
+    /** Lets deck.gl know that we want viewport change events */
+    shouldUpdateState(): boolean;
+    initializeState(): void;
+    updateState({ changeFlags, props, oldProps }: UpdateParameters<this>): void;
+    finalizeState(): void;
+    renderLayers(): Layer;
+    getFeatureInfoText(x: number, y: number): Promise<string | null>;
+    _createImageSource(props: ImageryLayerProps): ImageSource;
+    /** Run a getMetadata on the image service */
+    _loadMetadata(): Promise<void>;
+    /** Load an image */
+    loadImage(viewport: Viewport, reason: string): Promise<void>;
+    /** Global counter for issuing unique request ids */
+    private getRequestId;
+    /** Runs an action in the future, cancels it if the new action is issued before it executes */
+    private debounce;
+}
+export {};
+//# sourceMappingURL=imagery-layer.d.ts.map

package/typed/imagery-layer/imagery-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imagery-layer.d.ts","sourceRoot":"","sources":["../../src/imagery-layer/imagery-layer.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,EACL,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,YAAY,EACZ,QAAQ,EAGT,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAC,mBAAmB,EAAE,SAAS,EAAE,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AACtF,OAAO,EAAC,WAAW,EAAoB,MAAM,iBAAiB,CAAC;AAG/D,2CAA2C;AAC3C,oBAAY,iBAAiB,GAAG,mBAAmB,CAAC,GAAG,CAAC,GAAG,kBAAkB,CAAC;AAE9E,mCAAmC;AACnC,aAAK,kBAAkB,GAAG;IACxB,WAAW,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAAC;IACxC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,GAAG,CAAC,EAAE,WAAW,GAAG,WAAW,GAAG,MAAM,CAAC;IACzC,mBAAmB,CAAC,EAAE,MAAM,IAAI,CAAC;IACjC,sBAAsB,CAAC,EAAE,CAAC,QAAQ,EAAE,mBAAmB,KAAK,IAAI,CAAC;IACjE,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC7C,gBAAgB,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IAChD,mBAAmB,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,CAAC;IACnD,gBAAgB,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAC/D,CAAC;AAwBF;;GAEG;AACH,qBAAa,YAAY,CAAC,WAAW,SAAS,EAAE,GAAG,EAAE,CAAE,SAAQ,cAAc,CAC3E,WAAW,GAAG,QAAQ,CAAC,kBAAkB,CAAC,CAC3C;IACC,MAAM,CAAC,SAAS,SAAkB;IAClC,MAAM,CAAC,YAAY,EAAE,YAAY,CAAgB;IAEjD,KAAK,EAAG;QACN,WAAW,EAAE,WAAW,CAAC;QACzB,KAAK,EAAE,SAAS,CAAC;QACjB,GAAG,EAAE,WAAW,GAAG,WAAW,CAAC;QAC/B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QACzC,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,EAAE,MAAM,CAAC;QAErB,cAAc,EAAE,MAAM,CAAC;QACvB,UAAU,EAAE,GAAG,CAAC;KACjB,CAAC;IAEF,4DAA4D;IACnD,iBAAiB,IAAI,OAAO;IAI5B,eAAe,IAAI,IAAI;IAMvB,WAAW,CAAC,EAAC,WAAW,EAAE,KAAK,EAAE,QAAQ,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IAgBzE,aAAa,IAAI,IAAI;IAIrB,YAAY,IAAI,KAAK;IAiBxB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAsBtE,kBAAkB,CAAC,KAAK,EAAE,iBAAiB,GAAG,WAAW;IAgBzD,6CAA6C;IACvC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAepC,oBAAoB;IACd,SAAS,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA+ClE,oDAAoD;IACpD,OAAO,CAAC,YAAY;IAIpB,8FAA8F;IAC9F,OAAO,CAAC,QAAQ;CAIjB"}

package/typed/index.js

@@ -0,0 +1,33 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+/* eslint-disable max-len */
+export { default as GreatCircleLayer } from './great-circle-layer/great-circle-layer';
+export { default as S2Layer } from './s2-layer/s2-layer';
+export { default as QuadkeyLayer } from './quadkey-layer/quadkey-layer';
+export { default as TileLayer } from './tile-layer/tile-layer';
+export { default as TripsLayer } from './trips-layer/trips-layer';
+export { default as H3ClusterLayer } from './h3-layers/h3-cluster-layer';
+export { default as H3HexagonLayer } from './h3-layers/h3-hexagon-layer';
+export { default as Tile3DLayer } from './tile-3d-layer/tile-3d-layer';
+export { default as TerrainLayer } from './terrain-layer/terrain-layer';
+export { default as MVTLayer } from './mvt-layer/mvt-layer';
+export { getURLFromTemplate as _getURLFromTemplate } from './tile-layer/utils';
+export { default as _Tileset2D } from './tile-layer/tileset-2d';
+export { default as _Tile2DHeader } from './tile-layer/tile-2d-header';

package/typed/mesh-layer/mesh-layer-fragment.glsl.js

@@ -0,0 +1,55 @@
+export default `#version 300 es
+#define SHADER_NAME simple-mesh-layer-fs
+
+precision highp float;
+
+uniform bool hasTexture;
+uniform sampler2D sampler;
+uniform bool flatShading;
+uniform float opacity;
+
+in vec2 vTexCoord;
+in vec3 cameraPosition;
+in vec3 normals_commonspace;
+in vec4 position_commonspace;
+in vec4 vColor;
+
+out vec4 fragColor;
+
+void main(void) {
+  
+#ifdef MODULE_PBR
+
+  fragColor = vColor * pbr_filterColor(vec4(0));
+  geometry.uv = pbr_vUV;
+  fragColor.a *= opacity;
+
+#else
+
+  geometry.uv = vTexCoord;
+
+  vec3 normal;
+  if (flatShading) {
+
+// NOTE(Tarek): This is necessary because
+// headless.gl reports the extension as
+// available but does not support it in
+// the shader.
+#ifdef DERIVATIVES_AVAILABLE
+    normal = normalize(cross(dFdx(position_commonspace.xyz), dFdy(position_commonspace.xyz)));
+#else
+    normal = vec3(0.0, 0.0, 1.0);
+#endif
+  } else {
+    normal = normals_commonspace;
+  }
+
+  vec4 color = hasTexture ? texture(sampler, vTexCoord) : vColor;
+  vec3 lightColor = lighting_getLightColor(color.rgb, cameraPosition, position_commonspace.xyz, normal);
+  fragColor = vec4(lightColor, color.a * opacity);
+
+#endif
+
+  DECKGL_FILTER_COLOR(fragColor, geometry);
+}
+`;

package/typed/mesh-layer/mesh-layer-vertex.glsl.js

@@ -0,0 +1,80 @@
+export default `#version 300 es
+#define SHADER_NAME simple-mesh-layer-vs
+
+// Scale the model
+uniform float sizeScale;
+uniform bool composeModelMatrix;
+uniform bool u_pickFeatureIds;
+
+// Primitive attributes
+in vec3 positions;
+in vec3 normals;
+in vec3 colors;
+in vec2 texCoords;
+in vec4 uvRegions;
+in vec3 featureIdsPickingColors;
+
+// Instance attributes
+in vec4 instanceColors;
+in vec3 instancePickingColors;
+in mat3 instanceModelMatrix;
+
+// Outputs to fragment shader
+out vec2 vTexCoord;
+out vec3 cameraPosition;
+out vec3 normals_commonspace;
+out vec4 position_commonspace;
+out vec4 vColor;
+
+vec2 applyUVRegion(vec2 uv) {
+  #ifdef HAS_UV_REGIONS
+    // https://github.com/Esri/i3s-spec/blob/master/docs/1.7/geometryUVRegion.cmn.md
+    return fract(uv) * (uvRegions.zw - uvRegions.xy) + uvRegions.xy;
+  #else
+    return uv;
+  #endif
+}
+
+void main(void) {
+  vec2 uv = applyUVRegion(texCoords);
+  geometry.uv = uv;
+
+  if (u_pickFeatureIds) {
+    geometry.pickingColor = featureIdsPickingColors;
+  } else {
+    geometry.pickingColor = instancePickingColors;
+  }
+
+  vTexCoord = uv;
+  cameraPosition = project_uCameraPosition;
+  vColor = vec4(colors * instanceColors.rgb, instanceColors.a);
+
+  vec3 pos = (instanceModelMatrix * positions) * sizeScale;
+  vec3 projectedPosition = project_position(positions);
+  position_commonspace = vec4(projectedPosition, 1.0);
+  gl_Position = project_common_position_to_clipspace(position_commonspace);
+
+  geometry.position = position_commonspace;
+  normals_commonspace = project_normal(instanceModelMatrix * normals);
+  geometry.normal = normals_commonspace;
+
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  #ifdef MODULE_PBR
+    // set PBR data
+    pbr_vPosition = geometry.position.xyz;
+    #ifdef HAS_NORMALS
+      pbr_vNormal = geometry.normal;
+    #endif
+
+    #ifdef HAS_UV
+      pbr_vUV = uv;
+    #else
+      pbr_vUV = vec2(0., 0.);
+    #endif
+    geometry.uv = pbr_vUV;
+  #endif
+
+  DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;