@kepler.gl/deckgl-layers 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/esm/layer-utils/globe-cell-utils.js

@@ -0,0 +1,167 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _get from "@babel/runtime/helpers/esm/get";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { WebMercatorViewport } from '@deck.gl/core';
+
+/**
+ * deck.gl's aggregation cell layers (GridCellLayer / HexagonCellLayer) position
+ * each cell in flat mercator "common space" (a 2D XY plane) and then draw it with
+ * `project_common_position_to_clipspace`, which only multiplies by the
+ * view-projection matrix. Under `_GlobeView` this leaves the cells on the flat XY
+ * plane that passes through the center of the globe instead of on its surface
+ * (the base ColumnLayer works on the globe because it feeds real lng/lat through
+ * `project_position` -> `project_globe_`; the aggregation cell shaders skip that).
+ *
+ * To fix this we remap the already-computed flat common-space vertex position back
+ * to lng/lat (inverse Web Mercator) and then onto the sphere with the same math
+ * `project_globe_` uses for geographic layers. Because we remap every vertex of the
+ * cell footprint (not just the centroid), the flat quad/hexagon naturally curves
+ * onto the surface. Elevation (extruded cells, stored in `geometry.position.z` in
+ * common units) is added along the radius so columns rise radially off the globe.
+ *
+ * The remap is gated by a `globeMode` uniform so 2D/3D mercator rendering is
+ * byte-for-byte unchanged.
+ *
+ * `WORLD_SCALE`, `PI`, `GLOBE_RADIUS` and `project.commonOrigin` are all provided
+ * by deck.gl's project shader module which these layers include.
+ */
+
+// deck.gl 9 / luma 9 sets custom uniforms via UBO-backed shader modules (there is
+// no Model.setUniforms). This minimal module exposes the globe-mode flag.
+var globeCellUniforms = {
+  name: 'globeCell',
+  vs: "layout(std140) uniform globeCellUniforms {\n  float globeMode;\n} globeCellProps;\n",
+  uniformTypes: {
+    globeMode: 'f32'
+  }
+};
+var GLOBE_CELL_DECL = /* glsl */"\n// Inverse of deck.gl project_mercator_: flat common XY -> lng/lat (degrees).\nvec2 kepler_commonToLngLat(vec2 commonXY) {\n  float lng = degrees(commonXY.x / WORLD_SCALE - PI);\n  float lat = degrees(2.0 * atan(exp(commonXY.y / WORLD_SCALE - PI)) - PI * 0.5);\n  return vec2(lng, lat);\n}\n\n// Same math as deck.gl project_globe_. elevationCommon is in common units already\n// (GLOBE_RADIUS space), matching how project_globe_ scales z off EARTH_RADIUS.\nvec3 kepler_lngLatToGlobe(vec2 lngLat, float elevationCommon) {\n  float lambda = radians(lngLat.x);\n  float phi = radians(lngLat.y);\n  float cosPhi = cos(phi);\n  float D = GLOBE_RADIUS + elevationCommon;\n  return vec3(\n    sin(lambda) * cosPhi,\n    -cos(lambda) * cosPhi,\n    sin(phi)\n  ) * D;\n}\n";
+
+/**
+ * Rewrites a grid/hexagon cell vertex shader so that, in globe mode, the final
+ * clip-space position is derived from the sphere surface instead of the flat XY
+ * plane. In 2D/3D mode the original path is kept unchanged.
+ */
+export function addGlobeCellProjection(vs, type) {
+  var decl = "".concat(GLOBE_CELL_DECL, "\nvoid main(void) {");
+  var withDecl = vs.includes('void main(void) {') ? vs.replace('void main(void) {', decl) : vs;
+  var target = 'gl_Position = project_common_position_to_clipspace(geometry.position);';
+  if (!withDecl.includes(target)) {
+    // Shader shape changed in a deck.gl update; leave the original so we don't crash.
+    // eslint-disable-next-line no-console
+    console.error("Cannot edit ".concat(type, " globe cell shader"));
+    return withDecl;
+  }
+  return withDecl.replace(target, "if (globeCellProps.globeMode > 0.5) {\n      vec2 lngLat = kepler_commonToLngLat(geometry.position.xy + project.commonOrigin.xy);\n      vec3 globePos = kepler_lngLatToGlobe(lngLat, geometry.position.z);\n      geometry.position = vec4(globePos, 1.0);\n    }\n    gl_Position = project_common_position_to_clipspace(geometry.position);");
+}
+
+/**
+ * deck.gl 9's Grid/Hexagon aggregation compute bin positions and the cell layer's
+ * "common space" from `this.context.viewport`. Under `_GlobeView` that common space
+ * is the globe's 3D-projected space (projectFlat is identity on lng/lat, positions
+ * bin off the sphere-projected XY), which both mis-bins data and — combined with the
+ * flat cell shader — drops cells onto the plane through the globe center.
+ *
+ * We sidestep this by running `_updateBinOptions` with a WebMercatorViewport that
+ * matches the current globe camera. That makes binning, `cellOriginCommon` /
+ * `cellSizeCommon` (or `radiusCommon` / `hexOriginCommon`) and the cell shader's
+ * flat position all live in genuine Web Mercator common space, which the cell shader
+ * remap (`addGlobeCellProjection`) then curves back onto the sphere. In 2D/3D mode
+ * this is a no-op.
+ *
+ * `callSuper` runs deck.gl's original `_updateBinOptions` while the viewport is
+ * temporarily swapped. The swap is synchronous and restored in `finally`.
+ */
+export function runBinOptionsWithMercatorViewport(layer, callSuper) {
+  var _layer$context;
+  var viewport = (_layer$context = layer.context) === null || _layer$context === void 0 ? void 0 : _layer$context.viewport;
+  var isGlobe = Boolean(viewport === null || viewport === void 0 ? void 0 : viewport.resolution);
+  if (!isGlobe) {
+    callSuper();
+    return;
+  }
+  var mercatorViewport = new WebMercatorViewport({
+    width: viewport.width,
+    height: viewport.height,
+    longitude: viewport.longitude,
+    latitude: viewport.latitude,
+    zoom: viewport.zoom
+  });
+  var originalViewport = layer.context.viewport;
+  layer.context.viewport = mercatorViewport;
+  try {
+    callSuper();
+  } finally {
+    layer.context.viewport = originalViewport;
+  }
+}
+
+/**
+ * Wraps a deck.gl aggregation cell layer class (GridCellLayer / HexagonCellLayer)
+ * with a subclass that injects the globe surface remap into its vertex shader.
+ *
+ * We create the subclass dynamically from whatever default class deck.gl provides
+ * to `getSubLayerClass` so we don't have to import the (non-public) cell layer
+ * classes directly. Results are cached per base class so deck.gl sees a stable
+ * layer class across renders (layers are recreated every frame) and shader
+ * compilation / sublayer diffing stays stable.
+ */
+var globeCellClassCache = new WeakMap();
+export function makeGlobeCellLayerClass(BaseCellLayer, type) {
+  var cached = globeCellClassCache.get(BaseCellLayer);
+  if (cached) {
+    return cached;
+  }
+  var GlobeCellLayer = /*#__PURE__*/function (_ref) {
+    function GlobeCellLayer() {
+      _classCallCheck(this, GlobeCellLayer);
+      return _callSuper(this, GlobeCellLayer, arguments);
+    }
+    _inherits(GlobeCellLayer, _ref);
+    return _createClass(GlobeCellLayer, [{
+      key: "getShaders",
+      value: function getShaders() {
+        var shaders = _superPropGet(GlobeCellLayer, "getShaders", this, 1)();
+        return _objectSpread(_objectSpread({}, shaders), {}, {
+          vs: addGlobeCellProjection(shaders.vs, type),
+          modules: [].concat(_toConsumableArray(shaders.modules || []), [globeCellUniforms])
+        });
+      }
+    }, {
+      key: "draw",
+      value: function draw(opts) {
+        var globeMode = this.context.viewport.resolution ? 1.0 : 0.0;
+        // GridCellLayer / HexagonCellLayer render through a single fillModel and set
+        // their own module props in draw(); set ours first so it merges (setProps is
+        // per-module). deck.gl 9 has no Model.setUniforms — uniforms go through
+        // shaderInputs UBO modules.
+        var model = this.state.fillModel;
+        if (model !== null && model !== void 0 && model.shaderInputs) {
+          model.shaderInputs.setProps({
+            globeCell: {
+              globeMode: globeMode
+            }
+          });
+        }
+        _superPropGet(GlobeCellLayer, "draw", this, 1)(opts);
+      }
+    }]);
+  }(BaseCellLayer);
+  GlobeCellLayer.layerName = "Globe".concat(type, "CellLayer");
+  globeCellClassCache.set(BaseCellLayer, GlobeCellLayer);
+  return GlobeCellLayer;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["WebMercatorViewport","globeCellUniforms","name","vs","uniformTypes","globeMode","GLOBE_CELL_DECL","addGlobeCellProjection","type","decl","concat","withDecl","includes","replace","target","console","error","runBinOptionsWithMercatorViewport","layer","callSuper","_layer$context","viewport","context","isGlobe","Boolean","resolution","mercatorViewport","width","height","longitude","latitude","zoom","originalViewport","globeCellClassCache","WeakMap","makeGlobeCellLayerClass","BaseCellLayer","cached","get","GlobeCellLayer","_ref","_classCallCheck","_callSuper","arguments","_inherits","_createClass","key","value","getShaders","shaders","_superPropGet","_objectSpread","modules","_toConsumableArray","draw","opts","model","state","fillModel","shaderInputs","setProps","globeCell","layerName","set"],"sources":["../../../src/layer-utils/globe-cell-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {WebMercatorViewport} from '@deck.gl/core';\n\n/**\n * deck.gl's aggregation cell layers (GridCellLayer / HexagonCellLayer) position\n * each cell in flat mercator \"common space\" (a 2D XY plane) and then draw it with\n * `project_common_position_to_clipspace`, which only multiplies by the\n * view-projection matrix. Under `_GlobeView` this leaves the cells on the flat XY\n * plane that passes through the center of the globe instead of on its surface\n * (the base ColumnLayer works on the globe because it feeds real lng/lat through\n * `project_position` -> `project_globe_`; the aggregation cell shaders skip that).\n *\n * To fix this we remap the already-computed flat common-space vertex position back\n * to lng/lat (inverse Web Mercator) and then onto the sphere with the same math\n * `project_globe_` uses for geographic layers. Because we remap every vertex of the\n * cell footprint (not just the centroid), the flat quad/hexagon naturally curves\n * onto the surface. Elevation (extruded cells, stored in `geometry.position.z` in\n * common units) is added along the radius so columns rise radially off the globe.\n *\n * The remap is gated by a `globeMode` uniform so 2D/3D mercator rendering is\n * byte-for-byte unchanged.\n *\n * `WORLD_SCALE`, `PI`, `GLOBE_RADIUS` and `project.commonOrigin` are all provided\n * by deck.gl's project shader module which these layers include.\n */\n\n// deck.gl 9 / luma 9 sets custom uniforms via UBO-backed shader modules (there is\n// no Model.setUniforms). This minimal module exposes the globe-mode flag.\nconst globeCellUniforms = {\n  name: 'globeCell',\n  vs: `layout(std140) uniform globeCellUniforms {\n  float globeMode;\n} globeCellProps;\n`,\n  uniformTypes: {\n    globeMode: 'f32'\n  }\n} as const;\n\nconst GLOBE_CELL_DECL = /* glsl */ `\n// Inverse of deck.gl project_mercator_: flat common XY -> lng/lat (degrees).\nvec2 kepler_commonToLngLat(vec2 commonXY) {\n  float lng = degrees(commonXY.x / WORLD_SCALE - PI);\n  float lat = degrees(2.0 * atan(exp(commonXY.y / WORLD_SCALE - PI)) - PI * 0.5);\n  return vec2(lng, lat);\n}\n\n// Same math as deck.gl project_globe_. elevationCommon is in common units already\n// (GLOBE_RADIUS space), matching how project_globe_ scales z off EARTH_RADIUS.\nvec3 kepler_lngLatToGlobe(vec2 lngLat, float elevationCommon) {\n  float lambda = radians(lngLat.x);\n  float phi = radians(lngLat.y);\n  float cosPhi = cos(phi);\n  float D = GLOBE_RADIUS + elevationCommon;\n  return vec3(\n    sin(lambda) * cosPhi,\n    -cos(lambda) * cosPhi,\n    sin(phi)\n  ) * D;\n}\n`;\n\n/**\n * Rewrites a grid/hexagon cell vertex shader so that, in globe mode, the final\n * clip-space position is derived from the sphere surface instead of the flat XY\n * plane. In 2D/3D mode the original path is kept unchanged.\n */\nexport function addGlobeCellProjection(vs: string, type: string): string {\n  const decl = `${GLOBE_CELL_DECL}\\nvoid main(void) {`;\n  const withDecl = vs.includes('void main(void) {') ? vs.replace('void main(void) {', decl) : vs;\n\n  const target = 'gl_Position = project_common_position_to_clipspace(geometry.position);';\n  if (!withDecl.includes(target)) {\n    // Shader shape changed in a deck.gl update; leave the original so we don't crash.\n    // eslint-disable-next-line no-console\n    console.error(`Cannot edit ${type} globe cell shader`);\n    return withDecl;\n  }\n\n  return withDecl.replace(\n    target,\n    `if (globeCellProps.globeMode > 0.5) {\n      vec2 lngLat = kepler_commonToLngLat(geometry.position.xy + project.commonOrigin.xy);\n      vec3 globePos = kepler_lngLatToGlobe(lngLat, geometry.position.z);\n      geometry.position = vec4(globePos, 1.0);\n    }\n    gl_Position = project_common_position_to_clipspace(geometry.position);`\n  );\n}\n\n/**\n * deck.gl 9's Grid/Hexagon aggregation compute bin positions and the cell layer's\n * \"common space\" from `this.context.viewport`. Under `_GlobeView` that common space\n * is the globe's 3D-projected space (projectFlat is identity on lng/lat, positions\n * bin off the sphere-projected XY), which both mis-bins data and — combined with the\n * flat cell shader — drops cells onto the plane through the globe center.\n *\n * We sidestep this by running `_updateBinOptions` with a WebMercatorViewport that\n * matches the current globe camera. That makes binning, `cellOriginCommon` /\n * `cellSizeCommon` (or `radiusCommon` / `hexOriginCommon`) and the cell shader's\n * flat position all live in genuine Web Mercator common space, which the cell shader\n * remap (`addGlobeCellProjection`) then curves back onto the sphere. In 2D/3D mode\n * this is a no-op.\n *\n * `callSuper` runs deck.gl's original `_updateBinOptions` while the viewport is\n * temporarily swapped. The swap is synchronous and restored in `finally`.\n */\nexport function runBinOptionsWithMercatorViewport(layer: any, callSuper: () => void): void {\n  const viewport = layer.context?.viewport;\n  const isGlobe = Boolean(viewport?.resolution);\n  if (!isGlobe) {\n    callSuper();\n    return;\n  }\n\n  const mercatorViewport = new WebMercatorViewport({\n    width: viewport.width,\n    height: viewport.height,\n    longitude: viewport.longitude,\n    latitude: viewport.latitude,\n    zoom: viewport.zoom\n  });\n\n  const originalViewport = layer.context.viewport;\n  layer.context.viewport = mercatorViewport;\n  try {\n    callSuper();\n  } finally {\n    layer.context.viewport = originalViewport;\n  }\n}\n\n/**\n * Wraps a deck.gl aggregation cell layer class (GridCellLayer / HexagonCellLayer)\n * with a subclass that injects the globe surface remap into its vertex shader.\n *\n * We create the subclass dynamically from whatever default class deck.gl provides\n * to `getSubLayerClass` so we don't have to import the (non-public) cell layer\n * classes directly. Results are cached per base class so deck.gl sees a stable\n * layer class across renders (layers are recreated every frame) and shader\n * compilation / sublayer diffing stays stable.\n */\nconst globeCellClassCache = new WeakMap<object, object>();\n\ntype LayerConstructor = {new (...args: any[]): any; layerName?: string};\n\nexport function makeGlobeCellLayerClass<T extends LayerConstructor>(\n  BaseCellLayer: T,\n  type: string\n): T {\n  const cached = globeCellClassCache.get(BaseCellLayer);\n  if (cached) {\n    return cached as T;\n  }\n\n  class GlobeCellLayer extends (BaseCellLayer as {new (...args: any[]): any}) {\n    getShaders() {\n      const shaders = (super.getShaders as () => any)();\n      return {\n        ...shaders,\n        vs: addGlobeCellProjection(shaders.vs, type),\n        modules: [...(shaders.modules || []), globeCellUniforms]\n      };\n    }\n\n    draw(opts: any) {\n      const globeMode = (this.context.viewport as any).resolution ? 1.0 : 0.0;\n      // GridCellLayer / HexagonCellLayer render through a single fillModel and set\n      // their own module props in draw(); set ours first so it merges (setProps is\n      // per-module). deck.gl 9 has no Model.setUniforms — uniforms go through\n      // shaderInputs UBO modules.\n      const model = (this.state as any).fillModel;\n      if (model?.shaderInputs) {\n        model.shaderInputs.setProps({globeCell: {globeMode}});\n      }\n      (super.draw as (o: any) => void)(opts);\n    }\n  }\n  (GlobeCellLayer as unknown as {layerName: string}).layerName = `Globe${type}CellLayer`;\n  globeCellClassCache.set(BaseCellLayer, GlobeCellLayer);\n  return GlobeCellLayer as unknown as T;\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/layer-utils/shader-utils.js

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { console as Console } from 'global/window';
+
+/*
+ * Amendment to default layer vertex shader
+ * @param {string} vs
+ * @param {string} type
+ * @param {string} originalText
+ * @param {string} testToReplace
+ * @return {string} output shader
+ *
+ */
+export function editShader(vs, type, originalText, testToReplace) {
+  if (!vs.includes(originalText)) {
+    // Here we call Console.error when we fail to edit deck.gl shader
+    // This should be caught by layer test
+    Console.error("Cannot edit ".concat(type, " layer shader"));
+    return vs;
+  }
+  return vs.replace(originalText, testToReplace);
+}
+export function insertBefore(vs, type, insertBeforeText, textToInsert) {
+  var at = vs.indexOf(insertBeforeText);
+  if (at < 0) {
+    Console.error("Cannot edit ".concat(type, " layer shader"));
+    return vs;
+  }
+  return vs.slice(0, at) + textToInsert + vs.slice(at);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/line-layer/line-layer.js

@@ -0,0 +1,91 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _get from "@babel/runtime/helpers/esm/get";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { LineLayer } from '@deck.gl/layers';
+import { editShader } from '../';
+var elevationScaleUniforms = {
+  name: 'elevationScale',
+  vs: "uniform elevationScaleUniforms {\n  float elevationScale;\n} elevationScaleProps;\n",
+  uniformTypes: {
+    elevationScale: 'f32'
+  }
+};
+var defaultProps = _objectSpread(_objectSpread({}, LineLayer.defaultProps), {}, {
+  getTargetColor: function getTargetColor(x) {
+    return x.color || [0, 0, 0, 255];
+  }
+});
+function addInstanceColorShader(vs) {
+  var targetColorVs = editShader(vs, 'line target color vs', 'in vec4 instanceColors;', 'in vec4 instanceColors; in vec4 instanceTargetColors;');
+  return editShader(targetColorVs, 'line color vs', 'vColor = vec4(instanceColors.rgb, instanceColors.a * layer.opacity);', "vec4 color = mix(instanceColors, instanceTargetColors, positions.x);" + "vColor = vec4(color.rgb, color.a * layer.opacity);");
+}
+function addElevationScale(vs) {
+  return editShader(vs, 'line elevation scale vs - multiply by elevation scale', "geometry.worldPosition = instanceSourcePositions;\ngeometry.worldPositionAlt = instanceTargetPositions;\nvec3 source_world = instanceSourcePositions;\nvec3 target_world = instanceTargetPositions;", "vec3 source_world = instanceSourcePositions;\nvec3 target_world = instanceTargetPositions;\nsource_world.z *= elevationScaleProps.elevationScale;\ntarget_world.z *= elevationScaleProps.elevationScale;\ngeometry.worldPosition = source_world;\ngeometry.worldPositionAlt = target_world;");
+}
+var EnhancedLineLayer = /*#__PURE__*/function (_LineLayer) {
+  function EnhancedLineLayer() {
+    _classCallCheck(this, EnhancedLineLayer);
+    return _callSuper(this, EnhancedLineLayer, arguments);
+  }
+  _inherits(EnhancedLineLayer, _LineLayer);
+  return _createClass(EnhancedLineLayer, [{
+    key: "getShaders",
+    value: function getShaders() {
+      var shaders = _superPropGet(EnhancedLineLayer, "getShaders", this, 3)([]);
+      var vs = addInstanceColorShader(shaders.vs);
+      vs = addElevationScale(vs);
+      return _objectSpread(_objectSpread({}, shaders), {}, {
+        vs: vs,
+        modules: [].concat(_toConsumableArray(shaders.modules || []), [elevationScaleUniforms])
+      });
+    }
+  }, {
+    key: "draw",
+    value: function draw(opts) {
+      var model = this.state.model;
+      if (model) {
+        var _this$props$elevation;
+        model.shaderInputs.setProps({
+          elevationScale: {
+            elevationScale: (_this$props$elevation = this.props.elevationScale) !== null && _this$props$elevation !== void 0 ? _this$props$elevation : 1
+          }
+        });
+      }
+      _superPropGet(EnhancedLineLayer, "draw", this, 3)([opts]);
+    }
+  }, {
+    key: "initializeState",
+    value: function initializeState() {
+      var _this$props$colorForm;
+      _superPropGet(EnhancedLineLayer, "initializeState", this, 3)([]);
+      var _ref = this.state,
+        attributeManager = _ref.attributeManager;
+      attributeManager.addInstanced({
+        instanceTargetColors: {
+          size: (_this$props$colorForm = this.props.colorFormat) === null || _this$props$colorForm === void 0 ? void 0 : _this$props$colorForm.length,
+          type: 'unorm8',
+          transition: true,
+          accessor: 'getTargetColor',
+          defaultValue: [0, 0, 0, 255]
+        }
+      });
+    }
+  }]);
+}(LineLayer);
+export { EnhancedLineLayer as default };
+EnhancedLineLayer.layerName = 'EnhancedLineLayer';
+EnhancedLineLayer.defaultProps = defaultProps;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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