@carto/kepler.gl 0.0.69 → 0.0.70-alpha.hackathon-3dtiles.10

package/dist/utils/map-style-utils/mapbox-gl-style-editor.js

@@ -86,7 +86,8 @@ exports.editTopMapStyle = editTopMapStyle;
 var editBottomMapStyle = (0, _lodash["default"])(function (_ref4) {
   var id = _ref4.id,
       mapStyle = _ref4.mapStyle,
-      visibleLayerGroups = _ref4.visibleLayerGroups;
+      visibleLayerGroups = _ref4.visibleLayerGroups,
+      sketchValue = _ref4.sketchValue;
   var invisibleFilters = (mapStyle.layerGroups || []).filter(function (lg) {
     return !visibleLayerGroups[lg.slug];
   }).map(function (lg) {
@@ -100,7 +101,8 @@ var editBottomMapStyle = (0, _lodash["default"])(function (_ref4) {
     });
   });
   return _objectSpread(_objectSpread({}, mapStyle.style), {}, {
-    layers: filteredLayers
+    layers: filteredLayers,
+    sketchValue: sketchValue
   });
 }, resolver); // valid style url
 // mapbox://styles/uberdata/cjfyl03kp1tul2smf5v2tbdd4
@@ -209,4 +211,4 @@ function mergeLayerGroupVisibility(defaultLayerGroup, currentLayerGroup) {
     return _objectSpread(_objectSpread({}, accu), currentLayerGroup.hasOwnProperty(key) ? (0, _defineProperty2["default"])({}, key, currentLayerGroup[key]) : {});
   }, defaultLayerGroup);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/utils/map-style-utils/mapbox-gl-style-editor.js"],"names":["mapUrlRg","httpRg","getDefaultLayerGroupVisibility","layerGroups","reduce","accu","layer","slug","defaultVisibility","resolver","id","mapStyle","visibleLayerGroups","Object","keys","filter","d","sort","join","editTopMapStyle","visibleFilters","lg","map","filteredLayers","style","layers","some","match","editBottomMapStyle","invisibleFilters","every","isValidStyleUrl","url","Boolean","getStyleDownloadUrl","styleUrl","accessToken","mapboxApiUrl","startsWith","styleId","replace","DEFAULT_MAPBOX_API_URL","getStyleImageIcon","mapboxApiAccessToken","mapState","longitude","latitude","zoom","mapW","mapH","scaleMapStyleByResolution","mapboxStyle","scale","labelLayerGroup","DEFAULT_LAYER_GROUPS","find","labelLayerFilter","zoomOffset","Math","log2","copyStyle","forEach","maxzoom","max","minzoom","layout","Array","isArray","stops","stop","mergeLayerGroupVisibility","defaultLayerGroup","currentLayerGroup","key","hasOwnProperty"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport memoize from 'lodash.memoize';\nimport clondDeep from 'lodash.clonedeep';\nimport {DEFAULT_LAYER_GROUPS, DEFAULT_MAPBOX_API_URL} from 'constants/default-settings';\n\nconst mapUrlRg = /^mapbox:\\/\\/styles\\/[-a-z0-9]{2,256}\\/[-a-z0-9]{2,256}/;\nconst httpRg = /^(?=(http:|https:))/;\n\nexport function getDefaultLayerGroupVisibility({layerGroups = []}) {\n  return layerGroups.reduce(\n    (accu, layer) => ({\n      ...accu,\n      [layer.slug]: layer.defaultVisibility\n    }),\n    {}\n  );\n}\n\nconst resolver = ({id, mapStyle, visibleLayerGroups = {}}) =>\n  `${id}:${Object.keys(visibleLayerGroups)\n    .filter(d => visibleLayerGroups[d])\n    .sort()\n    .join('-')}`;\n\n/**\n * Edit preset map style to keep only visible layers\n *\n * @param {Object} mapStyle - preset map style\n * @param {Object} visibleLayerGroups - visible layers of top map\n * @returns {Object} top map style\n */\nexport const editTopMapStyle = memoize(({id, mapStyle, visibleLayerGroups}) => {\n  const visibleFilters = (mapStyle.layerGroups || [])\n    .filter(lg => visibleLayerGroups[lg.slug])\n    .map(lg => lg.filter);\n\n  // if top map\n  // keep only visible layers\n  const filteredLayers = mapStyle.style.layers.filter(layer =>\n    visibleFilters.some(match => match(layer))\n  );\n\n  return {\n    ...mapStyle.style,\n    layers: filteredLayers\n  };\n}, resolver);\n\n/**\n * Edit preset map style to filter out invisible layers\n *\n * @param {Object} mapStyle - preset map style\n * @param {Object} visibleLayerGroups - visible layers of bottom map\n * @returns {Object} bottom map style\n */\nexport const editBottomMapStyle = memoize(({id, mapStyle, visibleLayerGroups}) => {\n  const invisibleFilters = (mapStyle.layerGroups || [])\n    .filter(lg => !visibleLayerGroups[lg.slug])\n    .map(lg => lg.filter);\n\n  // if bottom map\n  // filter out invisible layers\n  const filteredLayers = mapStyle.style.layers.filter(layer =>\n    invisibleFilters.every(match => !match(layer))\n  );\n\n  return {\n    ...mapStyle.style,\n    layers: filteredLayers\n  };\n}, resolver);\n\n// valid style url\n// mapbox://styles/uberdata/cjfyl03kp1tul2smf5v2tbdd4\n// lowercase letters, numbers and dashes only.\nexport function isValidStyleUrl(url) {\n  return typeof url === 'string' && Boolean(url.match(mapUrlRg) || url.match(httpRg));\n}\n\nexport function getStyleDownloadUrl(styleUrl, accessToken, mapboxApiUrl) {\n  if (styleUrl.startsWith('http')) {\n    return styleUrl;\n  }\n\n  // mapbox://styles/jckr/cjhcl0lxv13di2rpfoytdbdyj\n  if (styleUrl.startsWith('mapbox://styles')) {\n    const styleId = styleUrl.replace('mapbox://styles/', '');\n\n    // https://api.mapbox.com/styles/v1/heshan0131/cjg1bfumo1cwm2rlrjxkinfgw?pluginName=Keplergl&access_token=<token>\n    return `${mapboxApiUrl ||\n      DEFAULT_MAPBOX_API_URL}/styles/v1/${styleId}?pluginName=Keplergl&access_token=${accessToken}`;\n  }\n\n  // style url not recognized\n  return null;\n}\n\n/**\n * Generate static map image from style Url to be used as icon\n * @param {Object} param\n * @param {string} param.styleUrl\n * @param {string} param.mapboxApiAccessToken\n * @param {string} param.mapboxApiUrl\n * @param {Object} param.mapState\n * @param {number} param.mapW\n * @param {number} param.mapH\n */\nexport function getStyleImageIcon({\n  styleUrl,\n  mapboxApiAccessToken,\n  mapboxApiUrl = DEFAULT_MAPBOX_API_URL,\n  mapState = {\n    longitude: -122.3391,\n    latitude: 37.7922,\n    zoom: 9\n  },\n  mapW = 400,\n  mapH = 300\n}) {\n  const styleId = styleUrl.replace('mapbox://styles/', '');\n\n  return (\n    `${mapboxApiUrl}/styles/v1/${styleId}/static/` +\n    `${mapState.longitude},${mapState.latitude},${mapState.zoom},0,0/` +\n    `${mapW}x${mapH}` +\n    `?access_token=${mapboxApiAccessToken}&logo=false&attribution=false`\n  );\n}\n\nexport function scaleMapStyleByResolution(mapboxStyle, scale) {\n  if (scale !== 1 && mapboxStyle) {\n    const labelLayerGroup = DEFAULT_LAYER_GROUPS.find(lg => lg.slug === 'label');\n    // @ts-ignore\n    const {filter: labelLayerFilter} = labelLayerGroup;\n    const zoomOffset = Math.log2(scale);\n\n    const copyStyle = clondDeep(mapboxStyle);\n    (copyStyle.layers || []).forEach(d => {\n      // edit minzoom and maxzoom\n      if (d.maxzoom) {\n        d.maxzoom = Math.max(d.maxzoom + zoomOffset, 1);\n      }\n\n      if (d.minzoom) {\n        d.minzoom = Math.max(d.minzoom + zoomOffset, 1);\n      }\n\n      // edit text size\n      if (labelLayerFilter(d)) {\n        if (d.layout && d.layout['text-size'] && Array.isArray(d.layout['text-size'].stops)) {\n          d.layout['text-size'].stops.forEach(stop => {\n            // zoom\n            stop[0] = Math.max(stop[0] + zoomOffset, 1);\n            // size\n            stop[1] *= scale;\n          });\n        }\n      }\n    });\n\n    return copyStyle;\n  }\n\n  return mapboxStyle;\n}\n\n/**\n * When switch to a new style, try to keep current layer group visibility\n * by merging default and current\n * @param {Object} defaultLayerGroup\n * @param {Object} currentLayerGroup\n * @return {Object} mergedLayerGroups\n */\nexport function mergeLayerGroupVisibility(defaultLayerGroup, currentLayerGroup) {\n  return Object.keys(defaultLayerGroup).reduce(\n    (accu, key) => ({\n      ...accu,\n      ...(currentLayerGroup.hasOwnProperty(key) ? {[key]: currentLayerGroup[key]} : {})\n    }),\n    defaultLayerGroup\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/utils/map-style-utils/mapbox-gl-style-editor.js"],"names":["mapUrlRg","httpRg","getDefaultLayerGroupVisibility","layerGroups","reduce","accu","layer","slug","defaultVisibility","resolver","id","mapStyle","visibleLayerGroups","Object","keys","filter","d","sort","join","editTopMapStyle","visibleFilters","lg","map","filteredLayers","style","layers","some","match","editBottomMapStyle","sketchValue","invisibleFilters","every","isValidStyleUrl","url","Boolean","getStyleDownloadUrl","styleUrl","accessToken","mapboxApiUrl","startsWith","styleId","replace","DEFAULT_MAPBOX_API_URL","getStyleImageIcon","mapboxApiAccessToken","mapState","longitude","latitude","zoom","mapW","mapH","scaleMapStyleByResolution","mapboxStyle","scale","labelLayerGroup","DEFAULT_LAYER_GROUPS","find","labelLayerFilter","zoomOffset","Math","log2","copyStyle","forEach","maxzoom","max","minzoom","layout","Array","isArray","stops","stop","mergeLayerGroupVisibility","defaultLayerGroup","currentLayerGroup","key","hasOwnProperty"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport memoize from 'lodash.memoize';\nimport clondDeep from 'lodash.clonedeep';\nimport {DEFAULT_LAYER_GROUPS, DEFAULT_MAPBOX_API_URL} from 'constants/default-settings';\n\nconst mapUrlRg = /^mapbox:\\/\\/styles\\/[-a-z0-9]{2,256}\\/[-a-z0-9]{2,256}/;\nconst httpRg = /^(?=(http:|https:))/;\n\nexport function getDefaultLayerGroupVisibility({layerGroups = []}) {\n  return layerGroups.reduce(\n    (accu, layer) => ({\n      ...accu,\n      [layer.slug]: layer.defaultVisibility\n    }),\n    {}\n  );\n}\n\nconst resolver = ({id, mapStyle, visibleLayerGroups = {}}) =>\n  `${id}:${Object.keys(visibleLayerGroups)\n    .filter(d => visibleLayerGroups[d])\n    .sort()\n    .join('-')}`;\n\n/**\n * Edit preset map style to keep only visible layers\n *\n * @param {Object} mapStyle - preset map style\n * @param {Object} visibleLayerGroups - visible layers of top map\n * @returns {Object} top map style\n */\nexport const editTopMapStyle = memoize(({id, mapStyle, visibleLayerGroups}) => {\n  const visibleFilters = (mapStyle.layerGroups || [])\n    .filter(lg => visibleLayerGroups[lg.slug])\n    .map(lg => lg.filter);\n\n  // if top map\n  // keep only visible layers\n  const filteredLayers = mapStyle.style.layers.filter(layer =>\n    visibleFilters.some(match => match(layer))\n  );\n\n  return {\n    ...mapStyle.style,\n    layers: filteredLayers\n  };\n}, resolver);\n\n/**\n * Edit preset map style to filter out invisible layers\n *\n * @param {Object} mapStyle - preset map style\n * @param {Object} visibleLayerGroups - visible layers of bottom map\n * @returns {Object} bottom map style\n */\nexport const editBottomMapStyle = memoize(({id, mapStyle, visibleLayerGroups, sketchValue}) => {\n  const invisibleFilters = (mapStyle.layerGroups || [])\n    .filter(lg => !visibleLayerGroups[lg.slug])\n    .map(lg => lg.filter);\n\n  // if bottom map\n  // filter out invisible layers\n  const filteredLayers = mapStyle.style.layers.filter(layer =>\n    invisibleFilters.every(match => !match(layer))\n  );\n\n  return {\n    ...mapStyle.style,\n    layers: filteredLayers,\n    sketchValue\n  };\n}, resolver);\n\n// valid style url\n// mapbox://styles/uberdata/cjfyl03kp1tul2smf5v2tbdd4\n// lowercase letters, numbers and dashes only.\nexport function isValidStyleUrl(url) {\n  return typeof url === 'string' && Boolean(url.match(mapUrlRg) || url.match(httpRg));\n}\n\nexport function getStyleDownloadUrl(styleUrl, accessToken, mapboxApiUrl) {\n  if (styleUrl.startsWith('http')) {\n    return styleUrl;\n  }\n\n  // mapbox://styles/jckr/cjhcl0lxv13di2rpfoytdbdyj\n  if (styleUrl.startsWith('mapbox://styles')) {\n    const styleId = styleUrl.replace('mapbox://styles/', '');\n\n    // https://api.mapbox.com/styles/v1/heshan0131/cjg1bfumo1cwm2rlrjxkinfgw?pluginName=Keplergl&access_token=<token>\n    return `${mapboxApiUrl ||\n      DEFAULT_MAPBOX_API_URL}/styles/v1/${styleId}?pluginName=Keplergl&access_token=${accessToken}`;\n  }\n\n  // style url not recognized\n  return null;\n}\n\n/**\n * Generate static map image from style Url to be used as icon\n * @param {Object} param\n * @param {string} param.styleUrl\n * @param {string} param.mapboxApiAccessToken\n * @param {string} param.mapboxApiUrl\n * @param {Object} param.mapState\n * @param {number} param.mapW\n * @param {number} param.mapH\n */\nexport function getStyleImageIcon({\n  styleUrl,\n  mapboxApiAccessToken,\n  mapboxApiUrl = DEFAULT_MAPBOX_API_URL,\n  mapState = {\n    longitude: -122.3391,\n    latitude: 37.7922,\n    zoom: 9\n  },\n  mapW = 400,\n  mapH = 300\n}) {\n  const styleId = styleUrl.replace('mapbox://styles/', '');\n\n  return (\n    `${mapboxApiUrl}/styles/v1/${styleId}/static/` +\n    `${mapState.longitude},${mapState.latitude},${mapState.zoom},0,0/` +\n    `${mapW}x${mapH}` +\n    `?access_token=${mapboxApiAccessToken}&logo=false&attribution=false`\n  );\n}\n\nexport function scaleMapStyleByResolution(mapboxStyle, scale) {\n  if (scale !== 1 && mapboxStyle) {\n    const labelLayerGroup = DEFAULT_LAYER_GROUPS.find(lg => lg.slug === 'label');\n    // @ts-ignore\n    const {filter: labelLayerFilter} = labelLayerGroup;\n    const zoomOffset = Math.log2(scale);\n\n    const copyStyle = clondDeep(mapboxStyle);\n    (copyStyle.layers || []).forEach(d => {\n      // edit minzoom and maxzoom\n      if (d.maxzoom) {\n        d.maxzoom = Math.max(d.maxzoom + zoomOffset, 1);\n      }\n\n      if (d.minzoom) {\n        d.minzoom = Math.max(d.minzoom + zoomOffset, 1);\n      }\n\n      // edit text size\n      if (labelLayerFilter(d)) {\n        if (d.layout && d.layout['text-size'] && Array.isArray(d.layout['text-size'].stops)) {\n          d.layout['text-size'].stops.forEach(stop => {\n            // zoom\n            stop[0] = Math.max(stop[0] + zoomOffset, 1);\n            // size\n            stop[1] *= scale;\n          });\n        }\n      }\n    });\n\n    return copyStyle;\n  }\n\n  return mapboxStyle;\n}\n\n/**\n * When switch to a new style, try to keep current layer group visibility\n * by merging default and current\n * @param {Object} defaultLayerGroup\n * @param {Object} currentLayerGroup\n * @return {Object} mergedLayerGroups\n */\nexport function mergeLayerGroupVisibility(defaultLayerGroup, currentLayerGroup) {\n  return Object.keys(defaultLayerGroup).reduce(\n    (accu, key) => ({\n      ...accu,\n      ...(currentLayerGroup.hasOwnProperty(key) ? {[key]: currentLayerGroup[key]} : {})\n    }),\n    defaultLayerGroup\n  );\n}\n"]}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@carto/kepler.gl",
   "author": "CARTO",
   "homepage": "https://github.com/CartoDB/carto-kepler#readme",
-  "version": "0.0.69",
+  "version": "0.0.70-alpha.hackathon-3dtiles.10",
   "description": "kepler.gl is a webgl based application to visualize large scale location data in the browser",
   "license": "MIT",
   "main": "dist/index.js",
@@ -59,7 +59,7 @@
     "web": "(yarn && yarn install:web && yarn start:web)",
     "deploy": "yarn install:web && (cd website && yarn build)",
     "clean": "rm -rf node_modules examples/**/node_modules website/node_modules",
-    "release:patch": "git add CHANGELOG.md && git commit -m 'updated CHANGELOG.md' && npm version patch && git push origin && git push origin --tags"
+    "release:patch": "git add CHANGELOG.md && git commit -m 'updated CHANGELOG.md' && npm version patch && git push origin && git push origin --tags"
   },
   "files": [
     "dist",
@@ -251,7 +251,6 @@
     "@loaders.gl/gltf": "^3.1.5",
     "@loaders.gl/json": "^3.1.5",
     "@loaders.gl/loader-utils": "^3.1.5",
-    "@loaders.gl/polyfills": "^3.1.5",
     "@luma.gl/constants": "^8.5.10",
     "@luma.gl/core": "^8.5.10",
     "react": ">=16.3",
@@ -278,4 +277,4 @@
   "volta": {
     "node": "12.19.0"
   }
-}
+}

package/src/actions/map-style-actions.d.ts

@@ -95,6 +95,14 @@ export function mapStyleChange(
   styleType: MapStyleChangeUpdaterAction['payload']
 ): Merge<MapStyleChangeUpdaterAction, {type: ActionTypes.MAP_STYLE_CHANGE}>;
 
+/** SET_TILES_3D_SKETCH_VALUE */
+export type SetTiles3dSketchValueActionUpdaterAction = {
+  payload: {inkStrength: number; hue: number; hueSaturation: number; dotScreen: boolean};
+};
+export function setTiles3dSketchValue(
+  sketchValue: SetTiles3dSketchValueActionUpdaterAction['payload']
+): Merge<SetTiles3dSketchValueActionUpdaterAction, {type: ActionTypes.SET_TILES_3D_SKETCH_VALUE}>;
+
 /** LOAD_CUSTOM_MAP_STYLE */
 export type LoadCustomMapStyleUpdaterAction = {
   payload: {

package/src/actions/map-style-actions.js

@@ -97,6 +97,22 @@ export const loadMapStyleErr = createAction(ActionTypes.LOAD_MAP_STYLE_ERR, erro
  */
 export const mapStyleChange = createAction(ActionTypes.MAP_STYLE_CHANGE, styleType => styleType);
 
+/**
+ * Set Tiles3D sketch value
+ * @memberof mapStyleActions
+ * @param sketchValue
+ * @param sketchValue.inkStrength - 0.01 - 1.0
+ * @param sketchValue.hue - 0.01 - 1.0
+ * @param sketchValue.hueSaturation - 0.01 - 1.0
+ * @param sketchValue.dotScreen - true | false
+ * @type {typeof import('./map-style-actions').setTiles3dSketchValue}
+ * @public
+ */
+export const setTiles3dSketchValue = createAction(
+  ActionTypes.SET_TILES_3D_SKETCH_VALUE,
+  sketchValue => sketchValue
+);
+
 /**
  * Callback when a custom map style object is received
  * @memberof mapStyleActions

package/src/components/map-container.js

@@ -24,7 +24,15 @@ import PropTypes from 'prop-types';
 import MapboxGLMap from 'react-map-gl';
 import DeckGL from '@deck.gl/react';
 import {createSelector} from 'reselect';
-import {OPERATION, Layer} from '@deck.gl/core';
+import {
+  OPERATION,
+  Layer,
+  AmbientLight,
+  LightingEffect,
+  PostProcessEffect,
+  _SunLight
+} from '@deck.gl/core';
+import {brightnessContrast, hueSaturation, ink, dotScreen, vibrance} from '@luma.gl/shadertools';
 import {SolidPolygonLayer} from '@deck.gl/layers';
 import {TileLayer} from '@deck.gl/geo-layers';
 import {errorNotification} from 'utils/notifications-utils';
@@ -54,6 +62,68 @@ import {
 import {observeDimensions, unobserveDimensions} from '../utils/observe-dimensions';
 import {LOCALE_CODES} from 'localization/locales';
 
+// 3D tiles
+import {_TerrainExtension as TerrainExtension} from '@deck.gl/extensions';
+import {Tile3DLayer} from '@deck.gl/geo-layers';
+
+const GOOGLE_MAPS_API_KEY = 'AIzaSyCpvQymc5wjSYIsxy3RV1widM3p3h78CAk';
+
+class CustomTile3DLayer extends Tile3DLayer {
+  static layerName = 'CustomTile3DLayer';
+
+  filterSubLayer({layer, viewport}) {
+    // Do not show tiles which are many layers too low in resolution (avoids artifacts)
+    const lodZoom = 22 - Math.log2(layer.props.tile.lodMetricValue);
+    return lodZoom > viewport?.zoom;
+  }
+}
+
+let h = 0;
+const tiles3d = new CustomTile3DLayer({
+  id: 'google-3d-tiles',
+  data: 'https://tile.googleapis.com/v1/3dtiles/root.json',
+  onTilesetLoad: tileset3d => {
+    tileset3d.options.maximumScreenSpaceError = 5;
+    tileset3d._onTileLoadError = () => {};
+    tileset3d.options.onTraversalComplete = selectedTiles => {
+      let minLod = Infinity;
+      for (const {lodMetricValue} of selectedTiles) {
+        if (lodMetricValue < minLod) minLod = lodMetricValue;
+      }
+      const filtered = selectedTiles.filter(t => t.lodMetricValue < 4 * minLod);
+
+      // Hacky way to obtain height above sea level to improve controls
+      if (filtered.length) {
+        h = filtered.map(t => t.boundingBox[0][2]).reduce((a, n) => a + n) / filtered.length;
+      }
+
+      return selectedTiles;
+    };
+  },
+  loadOptions: {
+    fetch: {headers: {'X-GOOG-API-KEY': GOOGLE_MAPS_API_KEY}}
+  },
+  // @ts-ignore
+  operation: 'terrain+draw' // Required to enable draping of other layers
+});
+const terrainExtension = new TerrainExtension();
+
+// Effects
+const ambientLight = new AmbientLight({color: [255, 255, 255], intensity: 1});
+const sunLight = new _SunLight({
+  timestamp: 1683869915777,
+  color: [255, 255, 255],
+  intensity: 1,
+  _shadow: true
+});
+const lightingEffect = new LightingEffect({
+  ambientLight,
+  sunLight
+});
+lightingEffect.shadowColor = [0, 0, 0, 0];
+
+const vibranceEffect = new PostProcessEffect(vibrance, {amount: 1});
+
 // Performance debugging
 import {createTracker, createLayerUpdateTracker, renderPerformanceStats} from './performance';
 const trackers = {};
@@ -130,6 +200,7 @@ export default function MapContainerFactory(MapPopover, MapControl, Editor) {
       mapState: PropTypes.object.isRequired,
       mapControls: PropTypes.object.isRequired,
       mapStyle: PropTypes.object.isRequired,
+      sketchValue: PropTypes.object,
       mapboxApiAccessToken: PropTypes.string.isRequired,
       mapboxApiUrl: PropTypes.string,
       visStateActions: PropTypes.object.isRequired,
@@ -339,6 +410,42 @@ export default function MapContainerFactory(MapPopover, MapControl, Editor) {
       return screenCoord && {x: screenCoord[0], y: screenCoord[1]};
     }
 
+    _getEffectsValues(mapStyle) {
+      const inkStrength = mapStyle.sketchValue?.inkStrength || 0.2;
+      const hue = mapStyle.sketchValue?.hue || 0;
+      const hueValueSaturation = mapStyle.sketchValue?.hueSaturation || 0.3;
+      const inkEffect = new PostProcessEffect(ink, {strength: inkStrength});
+      const hueSaturationEffect = new PostProcessEffect(hueSaturation, {
+        hue,
+        saturation: hueValueSaturation
+      });
+      const allEffects = [lightingEffect, hueSaturationEffect, vibranceEffect, inkEffect];
+
+      const dotScreenValue = mapStyle.sketchValue?.dotScreen || false;
+      if (dotScreenValue) {
+        const dotScreenEffect = new PostProcessEffect(dotScreen, {
+          centerX: 0,
+          centerY: 0,
+          angle: 0,
+          size: 1
+        });
+        const brightnessContrastEffect = new PostProcessEffect(brightnessContrast, {
+          contrast: 0.4,
+          brightness: 0.1
+        });
+        allEffects.push(dotScreenEffect);
+        allEffects.push(brightnessContrastEffect);
+      } else {
+        const brightnessContrastEffect = new PostProcessEffect(brightnessContrast, {
+          contrast: 0,
+          brightness: 0.2
+        });
+        allEffects.push(brightnessContrastEffect);
+      }
+
+      return allEffects;
+    }
+
     _renderDeckOverlay(layersForDeck) {
       const {
         mapState,
@@ -404,6 +511,19 @@ export default function MapContainerFactory(MapPopover, MapControl, Editor) {
         );
       }
 
+      let effects = [];
+      if (mapStyle.bottomMapStyle?.type === 'gmaps_3d') {
+        // Inject 3D tiles when map style is Voyager without layers
+        deckGlLayers = deckGlLayers
+          .filter(l => Boolean(l && l.clone))
+          .map(l => l.clone({extensions: [...l.props.extensions, terrainExtension]}));
+        deckGlLayers.push(tiles3d.clone());
+
+        if (mapStyle.styleType === 'google-3d-sketch') {
+          effects = this._getEffectsValues(mapStyle);
+        }
+      }
+
       // Limit renders
       const hasRendered = this._hasRendered;
       const resetHasRendered = () => (hasRendered.current = false);
@@ -412,22 +532,26 @@ export default function MapContainerFactory(MapPopover, MapControl, Editor) {
           controller={true}
           {...this.props.deckGlProps}
           viewState={mapState}
-          onViewStateChange={({viewState}) => {
+          onViewStateChange={({viewState, interactionState}) => {
             // Limit updates (prevents freezes when dev tools open)
             if (!hasRendered.current && viewState.width > 1 && viewState.height > 1) {
               hasRendered.current = true;
-              this._onViewportChange(viewState);
+              this._onViewportChange(viewState, interactionState);
             }
           }}
           id="default-deckgl-overlay"
           layers={deckGlLayers}
+          effects={effects}
           onBeforeRender={opts => {
             resetHasRendered();
             this._onBeforeRender(opts);
           }}
           onHover={visStateActions.onLayerHover}
           onClick={visStateActions.onLayerClick}
-          onError={this._onDeckError}
+          onError={e => {
+            debugger;
+            this._onDeckError(e);
+          }}
           ref={comp => {
             if (comp && comp.deck && comp.deck !== this._deck) {
               this._deck = comp.deck;
@@ -469,16 +593,20 @@ export default function MapContainerFactory(MapPopover, MapControl, Editor) {
       }
     }
 
-    _onViewportChange = viewState => {
+    _onViewportChange = (viewState, interactionState) => {
       trackers.viewportChangeCount?.increment();
+
       const {width, height, ...restViewState} = viewState;
       const {primary, isExport} = this.props;
       // react-map-gl sends 0,0 dimensions during initialization
       // after we have received proper dimensions from observeDimensions
       const next = {
         ...(width > 0 && height > 0 ? viewState : restViewState),
+
+        // Auto-update the camera height according to 3D tiles, except when transitioning
+        ...(interactionState && !interactionState.inTransition && {position: [0, 0, h]})
         // enabling transition in two maps may lead to endless update loops
-        transitionDuration: primary ? TRANSITION_DURATION : 0
+        // transitionDuration: primary ? TRANSITION_DURATION : 0 // Disable for 3D tiles transitions
       };
       if (typeof this.props.onViewStateChange === 'function') {
         this.props.onViewStateChange(next);
@@ -501,6 +629,7 @@ export default function MapContainerFactory(MapPopover, MapControl, Editor) {
         mapState,
         mapStyle,
         mapStateActions,
+        sketchValue,
         layers,
         MapComponent,
         datasets,
@@ -536,6 +665,8 @@ export default function MapContainerFactory(MapPopover, MapControl, Editor) {
       const isSplit = Boolean(mapState.isSplit);
       const mousePosition = this._mousePosition;
 
+      const needsBasemap = mapStyle.bottomMapStyle.type !== 'gmaps_3d';
+
       return (
         <>
           <MapControl
@@ -562,41 +693,49 @@ export default function MapContainerFactory(MapPopover, MapControl, Editor) {
             onSetLocale={uiStateActions.setLocale}
             onToggleEditorVisibility={visStateActions.toggleEditorVisibility}
           />
-          <MapComponent
-            {...mapProps}
-            key="bottom"
-            ref={this._setMapboxMap}
-            mapStyle={mapStyle.bottomMapStyle}
-            getCursor={this.props.hoverInfo ? () => 'pointer' : undefined}
-            onMouseMove={evt => {
-              // Sending mouse move updates via Redux is expensive. Store
-              // locally and rely on deck.gl to drive render updates
-              // See Builder: features/builder/ui/KeplerGl/MapContainer/MapContainer.tsx
-              mousePosition.current = {mousePosition: evt.point};
-            }}
-          >
-            {PERF_DEBUG && renderPerformanceStats()}
-            {this._renderDeckOverlay(layersForDeck)}
-            {this._renderMapboxOverlays()}
-            <Editor
-              index={index}
-              datasets={datasets}
-              editor={editor}
-              filters={this.polygonFilters(this.props)}
-              isEnabled={isEdit}
-              layers={layers}
-              layersToRender={layersToRender}
-              onDeleteFeature={visStateActions.deleteFeature}
-              onSelect={visStateActions.setSelectedFeature}
-              onUpdate={visStateActions.setFeatures}
-              onTogglePolygonFilter={visStateActions.setPolygonFilterLayer}
-              style={{
-                pointerEvents: isEdit ? 'all' : 'none',
-                position: 'absolute',
-                display: editor.visible ? 'block' : 'none'
+          {needsBasemap ? (
+            <MapComponent
+              {...mapProps}
+              key="bottom"
+              ref={this._setMapboxMap}
+              mapStyle={mapStyle.bottomMapStyle}
+              sketchValue={sketchValue}
+              getCursor={this.props.hoverInfo ? () => 'pointer' : undefined}
+              onMouseMove={evt => {
+                // Sending mouse move updates via Redux is expensive. Store
+                // locally and rely on deck.gl to drive render updates
+                // See Builder: features/builder/ui/KeplerGl/MapContainer/MapContainer.tsx
+                mousePosition.current = {mousePosition: evt.point};
               }}
-            />
-          </MapComponent>
+            >
+              {PERF_DEBUG && renderPerformanceStats()}
+              {this._renderDeckOverlay(layersForDeck)}
+              {this._renderMapboxOverlays()}
+              <Editor
+                index={index}
+                datasets={datasets}
+                editor={editor}
+                filters={this.polygonFilters(this.props)}
+                isEnabled={isEdit}
+                layers={layers}
+                layersToRender={layersToRender}
+                onDeleteFeature={visStateActions.deleteFeature}
+                onSelect={visStateActions.setSelectedFeature}
+                onUpdate={visStateActions.setFeatures}
+                onTogglePolygonFilter={visStateActions.setPolygonFilterLayer}
+                style={{
+                  pointerEvents: isEdit ? 'all' : 'none',
+                  position: 'absolute',
+                  display: editor.visible ? 'block' : 'none'
+                }}
+              />
+            </MapComponent>
+          ) : (
+            <>
+              {PERF_DEBUG && renderPerformanceStats()}
+              {this._renderDeckOverlay(layersForDeck)}
+            </>
+          )}
           {mapStyle.topMapStyle || hasGeocoderLayer ? (
             <div style={MAP_STYLE.top}>
               <MapComponent {...mapProps} key="top" mapStyle={mapStyle.topMapStyle}>

package/src/components/side-panel/map-manager.js

@@ -47,6 +47,7 @@ function MapManagerFactory(MapStyleSelector, LayerGroupSelector, ColorSelector)
 
     buildingColorSelector = props => props.mapStyle.threeDBuildingColor;
     setColorSelector = props => props.mapStyleActions.set3dBuildingColor;
+    setTiles3dSketchValue = props => props.mapStyleActions.setTiles3dSketchValue;
 
     _toggleSelecting = () => {
       this.setState({isSelecting: !this.state.isSelecting});

package/src/constants/action-types.d.ts

@@ -72,6 +72,7 @@ export type ActionType = {
   MAP_CONFIG_CHANGE: string;
   SET_DEFAULT_MAP_STYLE: string;
   MAP_STYLE_CHANGE: string;
+  SET_TILES_3D_SKETCH_VALUE: string;
   LOAD_MAP_STYLES: string;
   LOAD_MAP_STYLE_ERR: string;
   INPUT_MAP_STYLE: string;

package/src/constants/action-types.js

@@ -123,6 +123,7 @@ const ActionTypes = {
   MAP_CONFIG_CHANGE: `${ACTION_PREFIX}MAP_CONFIG_CHANGE`,
   SET_DEFAULT_MAP_STYLE: `${ACTION_PREFIX}SET_DEFAULT_MAP_STYLE`,
   MAP_STYLE_CHANGE: `${ACTION_PREFIX}MAP_STYLE_CHANGE`,
+  SET_TILES_3D_SKETCH_VALUE: `${ACTION_PREFIX}SET_TILES_3D_SKETCH_VALUE`,
   LOAD_MAP_STYLES: `${ACTION_PREFIX}LOAD_MAP_STYLES`,
   LOAD_MAP_STYLE_ERR: `${ACTION_PREFIX}LOAD_MAP_STYLE_ERR`,
   INPUT_MAP_STYLE: `${ACTION_PREFIX}INPUT_MAP_STYLE`,

package/src/processors/file-handler.js

@@ -18,7 +18,6 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-import '@loaders.gl/polyfills';
 import {parseInBatches} from '@loaders.gl/core';
 import {JSONLoader, _JSONPath} from '@loaders.gl/json';
 import {CSVLoader} from '@loaders.gl/csv';

package/src/reducers/map-style-updaters.d.ts

@@ -51,6 +51,7 @@ export type MapStyle = {
   inputStyle: InputStyle;
   threeDBuildingColor: RGBColor;
   custom3DBuildingColor: boolean;
+  sketchValue: {inkStrength: number; hue: number; hueSaturation: number; dotScreen: boolean};
 };
 
 export const INITIAL_MAP_STYLE: MapStyle;
@@ -64,6 +65,7 @@ export function loadMapStyleErrUpdater(state: MapStyle, action: MapStyleActions.
 export function mapStyleChangeUpdater(state: MapStyle, action: MapStyleActions.MapStyleChangeUpdaterAction): MapStyle;
 export function loadCustomMapStyleUpdater(state: MapStyle, action: MapStyleActions.LoadCustomMapStyleUpdaterAction): MapStyle;
 export function set3dBuildingColorUpdater(state: MapStyle, action: MapStyleActions.Set3dBuildingColorUpdaterAction): MapStyle;
+export function setTiles3dSketchValueUpdater(state: MapStyle, action: MapStyleActions.SetTiles3dSketchValueActionUpdaterAction): MapStyle;
 
 export function receiveMapConfigUpdater(state: MapStyle, action: {
   type?: ActionTypes.RECEIVE_MAP_CONFIG;

package/src/reducers/map-style-updaters.js

@@ -118,6 +118,7 @@ const mapStyleUpdaters = null;
  * @memberof mapStyleUpdaters
  * @constant
  * @property styleType - Default: `'dark'`
+ * @property sketchValue - Default: {inkStrength: 0.2; hue: 0; hueSaturation: 0.3; dotScreen: false};
  * @property visibleLayerGroups - Default: `{}`
  * @property topLayerGroups - Default: `{}`
  * @property mapStyles - mapping from style key to style object
@@ -138,9 +139,16 @@ export const INITIAL_MAP_STYLE = getDefaultState();
  * @param {Object} visibleLayerGroups - visible layers of bottom map
  * @param {Object} topLayerGroups - visible layers of top map
  * @param {Object} mapStyles - a dictionary of all map styles
+ * @param {Object} sketchValue - current sketch value
  * @returns {Object} bottomMapStyle | topMapStyle | isRaster
  */
-export function getMapStyles({styleType, visibleLayerGroups, topLayerGroups, mapStyles}) {
+export function getMapStyles({
+  styleType,
+  visibleLayerGroups,
+  topLayerGroups,
+  mapStyles,
+  sketchValue
+}) {
   const mapStyle = mapStyles[styleType];
 
   // style might not be loaded yet
@@ -155,7 +163,8 @@ export function getMapStyles({styleType, visibleLayerGroups, topLayerGroups, map
     : editBottomMapStyle({
         id: styleType,
         mapStyle,
-        visibleLayerGroups
+        visibleLayerGroups,
+        sketchValue
       });
 
   const hasTopLayer = editable && Object.values(topLayerGroups).some(v => v);
@@ -248,13 +257,32 @@ export const mapConfigChangeUpdater = (state, action) => ({
   })
 });
 
+/**
+ * Updates Tiles 3D Sketch value
+ * @memberof mapStyleUpdaters
+ * @type {typeof import('./map-style-updaters').setTiles3dSketchValueUpdater}
+ */
+export const setTiles3dSketchValueUpdater = (state, {payload: sketchValue}) => {
+  const newState = {
+    ...state,
+    sketchValue
+  };
+  return {
+    ...newState,
+    ...getMapStyles({
+      ...state,
+      sketchValue
+    })
+  };
+};
+
 /**
  * Change to another map style. The selected style should already been loaded into `mapStyle.mapStyles`
  * @memberof mapStyleUpdaters
  * @type {typeof import('./map-style-updaters').mapStyleChangeUpdater}
  * @public
  */
-export const mapStyleChangeUpdater = (state, {payload: styleType}) => {
+export const mapStyleChangeUpdater = (state, {payload: styleType, sketchValue}) => {
   if (!state.mapStyles[styleType]) {
     // we might not have received the style yet
     return state;
@@ -273,12 +301,14 @@ export const mapStyleChangeUpdater = (state, {payload: styleType}) => {
   return {
     ...state,
     styleType,
+    sketchValue,
     visibleLayerGroups,
     threeDBuildingColor,
     ...getMapStyles({
       ...state,
       visibleLayerGroups,
-      styleType
+      styleType,
+      sketchValue
     })
   };
 };
@@ -310,7 +340,6 @@ export const loadMapStylesUpdater = (state, action) => {
       ...addLayerGroups
     }
   };
-
   return newStyles[state.styleType]
     ? mapStyleChangeUpdater(newState, {payload: state.styleType})
     : newState;

package/src/reducers/map-style.js

@@ -31,6 +31,7 @@ const actionHandler = {
   [ActionTypes.INPUT_MAP_STYLE]: mapStyleUpdaters.inputMapStyleUpdater,
   [ActionTypes.MAP_CONFIG_CHANGE]: mapStyleUpdaters.mapConfigChangeUpdater,
   [ActionTypes.MAP_STYLE_CHANGE]: mapStyleUpdaters.mapStyleChangeUpdater,
+  [ActionTypes.SET_TILES_3D_SKETCH_VALUE]: mapStyleUpdaters.setTiles3dSketchValueUpdater,
   [ActionTypes.REQUEST_MAP_STYLES]: mapStyleUpdaters.requestMapStylesUpdater,
   [ActionTypes.LOAD_MAP_STYLES]: mapStyleUpdaters.loadMapStylesUpdater,
   [ActionTypes.LOAD_MAP_STYLE_ERR]: mapStyleUpdaters.loadMapStyleErrUpdater,

package/src/utils/map-style-utils/mapbox-gl-style-editor.js

@@ -72,7 +72,7 @@ export const editTopMapStyle = memoize(({id, mapStyle, visibleLayerGroups}) => {
  * @param {Object} visibleLayerGroups - visible layers of bottom map
  * @returns {Object} bottom map style
  */
-export const editBottomMapStyle = memoize(({id, mapStyle, visibleLayerGroups}) => {
+export const editBottomMapStyle = memoize(({id, mapStyle, visibleLayerGroups, sketchValue}) => {
   const invisibleFilters = (mapStyle.layerGroups || [])
     .filter(lg => !visibleLayerGroups[lg.slug])
     .map(lg => lg.filter);
@@ -85,7 +85,8 @@ export const editBottomMapStyle = memoize(({id, mapStyle, visibleLayerGroups}) =
 
   return {
     ...mapStyle.style,
-    layers: filteredLayers
+    layers: filteredLayers,
+    sketchValue
   };
 }, resolver);