@deck.gl/geo-layers 8.9.4 → 8.9.5

package/typed/index.js

@@ -1,33 +0,0 @@
-// 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

@@ -1,55 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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.js

@@ -1,110 +0,0 @@
-import { GLTFMaterialParser } from '@luma.gl/experimental';
-import { Model, pbr } from '@luma.gl/core';
-import GL from '@luma.gl/constants';
-import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
-import vs from './mesh-layer-vertex.glsl';
-import fs from './mesh-layer-fragment.glsl';
-function validateGeometryAttributes(attributes) {
-    const hasColorAttribute = attributes.COLOR_0 || attributes.colors;
-    if (!hasColorAttribute) {
-        attributes.colors = { constant: true, value: new Float32Array([1, 1, 1]) };
-    }
-}
-const defaultProps = {
-    // PBR material object. _lighting must be pbr for this to work
-    pbrMaterial: { type: 'object', value: null },
-    featureIds: { type: 'array', value: null, optional: true }
-};
-export default class _MeshLayer extends SimpleMeshLayer {
-    getShaders() {
-        const shaders = super.getShaders();
-        const modules = shaders.modules;
-        modules.push(pbr);
-        return { ...shaders, vs, fs };
-    }
-    initializeState() {
-        const { featureIds } = this.props;
-        super.initializeState();
-        if (featureIds) {
-            this.state.attributeManager.add({
-                featureIdsPickingColors: {
-                    type: GL.UNSIGNED_BYTE,
-                    size: 3,
-                    noAlloc: true,
-                    update: this.calculateFeatureIdsPickingColors
-                }
-            });
-        }
-    }
-    updateState({ props, oldProps, changeFlags }) {
-        super.updateState({ props, oldProps, changeFlags });
-        if (props.pbrMaterial !== oldProps.pbrMaterial) {
-            this.updatePbrMaterialUniforms(props.pbrMaterial);
-        }
-    }
-    draw(opts) {
-        const { featureIds } = this.props;
-        if (!this.state.model) {
-            return;
-        }
-        this.state.model.setUniforms({
-            // Needed for PBR (TODO: find better way to get it)
-            u_Camera: this.state.model.getUniforms().project_uCameraPosition,
-            u_pickFeatureIds: Boolean(featureIds)
-        });
-        super.draw(opts);
-    }
-    getModel(mesh) {
-        const { id, pbrMaterial } = this.props;
-        const materialParser = this.parseMaterial(pbrMaterial, mesh);
-        const shaders = this.getShaders();
-        validateGeometryAttributes(mesh.attributes);
-        const model = new Model(this.context.gl, {
-            ...this.getShaders(),
-            id,
-            geometry: mesh,
-            defines: {
-                ...shaders.defines,
-                ...materialParser?.defines,
-                HAS_UV_REGIONS: mesh.attributes.uvRegions
-            },
-            parameters: materialParser?.parameters,
-            isInstanced: true
-        });
-        return model;
-    }
-    updatePbrMaterialUniforms(pbrMaterial) {
-        const { model } = this.state;
-        if (model) {
-            const { mesh } = this.props;
-            const materialParser = this.parseMaterial(pbrMaterial, mesh);
-            model.setUniforms(materialParser.uniforms);
-        }
-    }
-    parseMaterial(pbrMaterial, mesh) {
-        const unlit = Boolean(pbrMaterial.pbrMetallicRoughness && pbrMaterial.pbrMetallicRoughness.baseColorTexture);
-        const materialParser = new GLTFMaterialParser(this.context.gl, {
-            attributes: { NORMAL: mesh.attributes.normals, TEXCOORD_0: mesh.attributes.texCoords },
-            material: { unlit, ...pbrMaterial },
-            pbrDebug: false,
-            imageBasedLightingEnvironment: null,
-            lights: true,
-            useTangents: false
-        });
-        return materialParser;
-    }
-    calculateFeatureIdsPickingColors(attribute) {
-        const { featureIds } = this.props;
-        const value = new Uint8ClampedArray(featureIds.length * attribute.size);
-        const pickingColor = [];
-        for (let index = 0; index < featureIds.length; index++) {
-            this.encodePickingColor(featureIds[index], pickingColor);
-            value[index * 3] = pickingColor[0];
-            value[index * 3 + 1] = pickingColor[1];
-            value[index * 3 + 2] = pickingColor[2];
-        }
-        attribute.value = value;
-    }
-}
-_MeshLayer.layerName = '_MeshLayer';
-_MeshLayer.defaultProps = defaultProps;

package/typed/mvt-layer/coordinate-transform.js

@@ -1,41 +0,0 @@
-import { lerp } from '@math.gl/core';
-const availableTransformations = {
-    Point,
-    MultiPoint,
-    LineString,
-    MultiLineString,
-    Polygon,
-    MultiPolygon
-};
-function Point([pointX, pointY], [nw, se], viewport) {
-    const x = lerp(nw[0], se[0], pointX);
-    const y = lerp(nw[1], se[1], pointY);
-    return viewport.unprojectFlat([x, y]);
-}
-function getPoints(geometry, bbox, viewport) {
-    return geometry.map(g => Point(g, bbox, viewport));
-}
-function MultiPoint(multiPoint, bbox, viewport) {
-    return getPoints(multiPoint, bbox, viewport);
-}
-function LineString(line, bbox, viewport) {
-    return getPoints(line, bbox, viewport);
-}
-function MultiLineString(multiLineString, bbox, viewport) {
-    return multiLineString.map(lineString => LineString(lineString, bbox, viewport));
-}
-function Polygon(polygon, bbox, viewport) {
-    return polygon.map(polygonRing => getPoints(polygonRing, bbox, viewport));
-}
-function MultiPolygon(multiPolygon, bbox, viewport) {
-    return multiPolygon.map(polygon => Polygon(polygon, bbox, viewport));
-}
-export function transform(geometry, bbox, viewport) {
-    const nw = viewport.projectFlat([bbox.west, bbox.north]);
-    const se = viewport.projectFlat([bbox.east, bbox.south]);
-    const projectedBbox = [nw, se];
-    return {
-        ...geometry,
-        coordinates: availableTransformations[geometry.type](geometry.coordinates, projectedBbox, viewport)
-    };
-}

package/typed/mvt-layer/find-index-binary.js

@@ -1,96 +0,0 @@
-const GEOM_TYPES = ['points', 'lines', 'polygons'];
-/**
- * Return the index of feature (numericProps or featureIds) for given feature id
- * Example: findIndexBinary(data, 'id', 33) will return the index in the array of numericProps
- * of the feature 33.
- * @param {Object} data - The data in binary format
- * @param {String} uniqueIdProperty - Name of the unique id property
- * @param {Number|String} featureId - feature id to find
- * @param {String} layerName - the layer to search in
- */
-export default function findIndexBinary(data, uniqueIdProperty, featureId, layerName) {
-    for (const gt of GEOM_TYPES) {
-        const index = data[gt] && findIndexByType(data[gt], uniqueIdProperty, featureId, layerName);
-        if (index >= 0) {
-            return index;
-        }
-    }
-    return -1;
-}
-function findIndexByType(geomData, uniqueIdProperty, featureId, layerName) {
-    const featureIds = geomData.featureIds.value;
-    if (!featureIds.length) {
-        return -1;
-    }
-    let startFeatureIndex = 0;
-    let endFeatureIndex = featureIds[featureIds.length - 1] + 1;
-    if (layerName) {
-        const layerRange = getLayerRange(geomData, layerName);
-        if (layerRange) {
-            startFeatureIndex = layerRange[0];
-            endFeatureIndex = layerRange[1] + 1;
-        }
-        else {
-            return -1;
-        }
-    }
-    // Look for the uniqueIdProperty
-    let featureIndex = -1;
-    if (uniqueIdProperty in geomData.numericProps) {
-        const vertexIndex = geomData.numericProps[uniqueIdProperty].value.findIndex((x, i) => x === featureId && featureIds[i] >= startFeatureIndex && featureIds[i] < endFeatureIndex);
-        return vertexIndex >= 0 ? geomData.globalFeatureIds.value[vertexIndex] : -1;
-    }
-    else if (uniqueIdProperty) {
-        featureIndex = findIndex(geomData.properties, elem => elem[uniqueIdProperty] === featureId, startFeatureIndex, endFeatureIndex);
-    }
-    else if (geomData.fields) {
-        featureIndex = findIndex(geomData.fields, (elem) => elem.id === featureId, startFeatureIndex, endFeatureIndex);
-    }
-    return featureIndex >= 0 ? getGlobalFeatureId(geomData, featureIndex) : -1;
-}
-// Returns [firstFeatureIndex, lastFeatureIndex]
-// MVTLoader parses tiles layer-by-layer, so each layer is a continuous range
-function getLayerRange(geomData, layerName) {
-    if (!geomData.__layers) {
-        // Cache a map from properties.layerName to index ranges
-        const layerNames = {};
-        const { properties } = geomData;
-        for (let i = 0; i < properties.length; i++) {
-            const { layerName: key } = properties[i];
-            if (!key) {
-                // ignore
-            }
-            else if (layerNames[key]) {
-                layerNames[key][1] = i;
-            }
-            else {
-                layerNames[key] = [i, i];
-            }
-        }
-        geomData.__layers = layerNames;
-    }
-    return geomData.__layers[layerName];
-}
-// Returns global feature id
-function getGlobalFeatureId(geomData, featureIndex) {
-    if (!geomData.__ids) {
-        // Cache a map from featureId to globalFeatureId
-        const result = [];
-        const featureIds = geomData.featureIds.value;
-        const globalFeatureIds = geomData.globalFeatureIds.value;
-        for (let i = 0; i < featureIds.length; i++) {
-            result[featureIds[i]] = globalFeatureIds[i];
-        }
-        geomData.__ids = result;
-    }
-    return geomData.__ids[featureIndex];
-}
-// Like array.findIndex, but only search within a range
-function findIndex(array, predicate, startIndex, endIndex) {
-    for (let i = startIndex; i < endIndex; i++) {
-        if (predicate(array[i], i)) {
-            return i;
-        }
-    }
-    return -1;
-}