@deck.gl/geo-layers 8.8.0-alpha.4 → 8.8.0-beta.1

package/typed/h3-layers/h3-hexagon-layer.d.ts

@@ -0,0 +1,107 @@
+export function normalizeLongitudes(vertices: any, refLng: any): void;
+export function scalePolygon(hexId: any, vertices: any, factor: any): void;
+/**
+ * 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.
+ */
+declare class H3HexagonLayer extends CompositeLayer<any> {
+    constructor(...propObjects: Partial<any>[]);
+    _calculateH3DataProps(props: any): {
+        resolution: number;
+        edgeLengthKM: number;
+        hasMultipleRes: boolean;
+        hasPentagon: boolean;
+    };
+    _shouldUseHighPrecision(): any;
+    _updateVertices(viewport: any): void;
+    _getForwardProps(): {
+        elevationScale: any;
+        extruded: any;
+        coverage: any;
+        wireframe: any;
+        stroked: any;
+        filled: any;
+        lineWidthUnits: any;
+        lineWidthScale: any;
+        lineWidthMinPixels: any;
+        lineWidthMaxPixels: any;
+        material: any;
+        getElevation: any;
+        getFillColor: any;
+        getLineColor: any;
+        getLineWidth: any;
+        transitions: any;
+        updateTriggers: {
+            getFillColor: any;
+            getElevation: any;
+            getLineColor: any;
+            getLineWidth: any;
+        };
+    };
+    _renderPolygonLayer(): PolygonLayer<any, {}>;
+    _renderColumnLayer(): ColumnLayer<any, {}>;
+}
+declare namespace H3HexagonLayer {
+    export { defaultProps };
+    export const layerName: string;
+}
+export default H3HexagonLayer;
+import { CompositeLayer } from '@deck.gl/core/typed';
+import { PolygonLayer } from '@deck.gl/layers/typed';
+import { ColumnLayer } from '@deck.gl/layers/typed';
+declare const defaultProps: {
+    highPrecision: string;
+    coverage: {
+        type: string;
+        min: number;
+        max: number;
+        value: number;
+    };
+    centerHexagon: null;
+    getHexagon: {
+        type: string;
+        value: (x: any) => any;
+    };
+    extruded: boolean;
+    stroked: boolean;
+    filled: boolean;
+    elevationScale: number;
+    wireframe: boolean;
+    _normalize: boolean;
+    _windingOrder: string;
+    lineWidthUnits: string;
+    lineWidthScale: number;
+    lineWidthMinPixels: number;
+    lineWidthMaxPixels: number;
+    lineJointRounded: boolean;
+    lineMiterLimit: number;
+    getPolygon: {
+        type: string;
+        value: (f: any) => any;
+    };
+    getFillColor: {
+        type: string;
+        value: number[];
+    };
+    getLineColor: {
+        type: string;
+        value: number[];
+    };
+    getLineWidth: {
+        type: string;
+        value: number;
+    };
+    getElevation: {
+        type: string;
+        value: number;
+    };
+    material: boolean;
+};
+//# sourceMappingURL=h3-hexagon-layer.d.ts.map

package/typed/h3-layers/h3-hexagon-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"h3-hexagon-layer.d.ts","sourceRoot":"","sources":["../../src/h3-layers/h3-hexagon-layer.js"],"names":[],"mappings":"AAoBA,sEAUC;AAGD,2EAcC;AAwDD;;;;;;;;;;GAUG;AACH;IAjGoB,4CAEmB;IAmHrC;;;;;MA8BC;IAED,+BAUC;IAED,qCAqCC;IAMD;;;;;;;;;;;;;;;;;;;;;;;MA6CC;IAED,6CAyBC;IAED,2CAsBC;CACF;;;;;;;;;AAnOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOE"}

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/index.d.ts

@@ -0,0 +1,19 @@
+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';
+export type { TileLayerProps } from './tile-layer/tile-layer';
+export type { GeoBoundingBox } from './tile-layer/types';
+export type { QuadkeyLayerProps } from './quadkey-layer/quadkey-layer';
+export type { TileLoadProps as _TileLoadProps } from './tile-layer/types';
+export type { MVTLayerProps } from './mvt-layer/mvt-layer';
+//# sourceMappingURL=index.d.ts.map

package/typed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,OAAO,IAAI,gBAAgB,EAAC,MAAM,yCAAyC,CAAC;AACpF,OAAO,EAAC,OAAO,IAAI,OAAO,EAAC,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAC,OAAO,IAAI,WAAW,EAAC,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,QAAQ,EAAC,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAC,kBAAkB,IAAI,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EAAC,OAAO,IAAI,aAAa,EAAC,MAAM,6BAA6B,CAAC;AAGrE,YAAY,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC5D,YAAY,EAAC,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvD,YAAY,EAAC,iBAAiB,EAAC,MAAM,+BAA+B,CAAC;AACrE,YAAY,EAAC,aAAa,IAAI,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACxE,YAAY,EAAC,aAAa,EAAC,MAAM,uBAAuB,CAAC"}

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.d.ts

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

package/typed/mesh-layer/mesh-layer-fragment.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-layer-fragment.glsl.d.ts","sourceRoot":"","sources":["../../src/mesh-layer/mesh-layer-fragment.glsl.js"],"names":[],"mappings":""}

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.d.ts

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

package/typed/mesh-layer/mesh-layer-vertex.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-layer-vertex.glsl.d.ts","sourceRoot":"","sources":["../../src/mesh-layer/mesh-layer-vertex.glsl.js"],"names":[],"mappings":""}

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);
+}
+`;

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

@@ -0,0 +1,27 @@
+declare class _MeshLayer extends SimpleMeshLayer<any, any> {
+    constructor(...propObjects: Partial<any>[]);
+    updatePbrMaterialUniforms(pbrMaterial: any): void;
+    parseMaterial(pbrMaterial: any, mesh: any): GLTFMaterialParser;
+    calculateFeatureIdsPickingColors(attribute: any): void;
+}
+declare namespace _MeshLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default _MeshLayer;
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers/typed';
+import { GLTFMaterialParser } from "@luma.gl/experimental";
+declare namespace defaultProps {
+    namespace pbrMaterial {
+        const type: string;
+        const value: null;
+    }
+    namespace featureIds {
+        const type_1: string;
+        export { type_1 as type };
+        const value_1: null;
+        export { value_1 as value };
+        export const optional: boolean;
+    }
+}
+//# sourceMappingURL=mesh-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-layer.d.ts","sourceRoot":"","sources":["../../src/mesh-layer/mesh-layer.js"],"names":[],"mappings":"AAqBA;IALyC,4CACb;IAsE1B,kDAOC;IAED,+DAaC;IAED,uDAcC;CACF"}