@kepler.gl/deckgl-layers 3.3.0-alpha.1 → 3.3.0-alpha.11

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

@@ -0,0 +1,197 @@
+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 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();
+/**
+ * deck.gl's GridCellLayer / HexagonCellLayer bind the `colorRange` palette
+ * texture only when the `colorRange` *prop* changes. ColumnLayer (the parent)
+ * destroys and recreates `fillModel` whenever `extensionsChanged` fires —
+ * which happens when Light & Shadow registers the shadow shader module.
+ * The new model starts with empty bindings, the colorRange check is a no-op,
+ * and luma.gl skips the draw: "Binding colorRange not found in …-cells-fill-cached".
+ * Recreating the Kepler layer "fixes" it because initialize/update then sees a
+ * colorRange change against empty oldProps and binds the texture again.
+ *
+ * Re-bind the existing texture onto whatever fillModel is current. Harmless
+ * when the parent already bound it; required after a model rebuild.
+ */
+function bindColorRangeTexture(layer, moduleName) {
+  var _layer$state, _layer$state2;
+  var model = (_layer$state = layer.state) === null || _layer$state === void 0 ? void 0 : _layer$state.fillModel;
+  var colorTexture = (_layer$state2 = layer.state) === null || _layer$state2 === void 0 ? void 0 : _layer$state2.colorTexture;
+  if (model !== null && model !== void 0 && model.shaderInputs && colorTexture) {
+    model.shaderInputs.setProps(_defineProperty({}, moduleName, {
+      colorRange: colorTexture
+    }));
+  }
+}
+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, 3)([]);
+        return _objectSpread(_objectSpread({}, shaders), {}, {
+          vs: addGlobeCellProjection(shaders.vs, type),
+          modules: [].concat(_toConsumableArray(shaders.modules || []), [globeCellUniforms])
+        });
+      }
+    }, {
+      key: "updateState",
+      value: function updateState(params) {
+        _superPropGet(GlobeCellLayer, "updateState", this, 3)([params]);
+        bindColorRangeTexture(this, type);
+      }
+    }, {
+      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
+            }
+          });
+        }
+        bindColorRangeTexture(this, type);
+        _superPropGet(GlobeCellLayer, "draw", this, 3)([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","bindColorRangeTexture","moduleName","_layer$state","_layer$state2","model","state","fillModel","colorTexture","shaderInputs","setProps","_defineProperty","colorRange","makeGlobeCellLayerClass","BaseCellLayer","cached","get","GlobeCellLayer","_ref","_classCallCheck","_callSuper","arguments","_inherits","_createClass","key","value","getShaders","shaders","_superPropGet","_objectSpread","modules","_toConsumableArray","updateState","params","draw","opts","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\n/**\n * deck.gl's GridCellLayer / HexagonCellLayer bind the `colorRange` palette\n * texture only when the `colorRange` *prop* changes. ColumnLayer (the parent)\n * destroys and recreates `fillModel` whenever `extensionsChanged` fires —\n * which happens when Light & Shadow registers the shadow shader module.\n * The new model starts with empty bindings, the colorRange check is a no-op,\n * and luma.gl skips the draw: \"Binding colorRange not found in …-cells-fill-cached\".\n * Recreating the Kepler layer \"fixes\" it because initialize/update then sees a\n * colorRange change against empty oldProps and binds the texture again.\n *\n * Re-bind the existing texture onto whatever fillModel is current. Harmless\n * when the parent already bound it; required after a model rebuild.\n */\nfunction bindColorRangeTexture(layer: any, moduleName: string): void {\n  const model = layer.state?.fillModel;\n  const colorTexture = layer.state?.colorTexture;\n  if (model?.shaderInputs && colorTexture) {\n    model.shaderInputs.setProps({[moduleName]: {colorRange: colorTexture}});\n  }\n}\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();\n      return {\n        ...shaders,\n        vs: addGlobeCellProjection(shaders.vs, type),\n        modules: [...(shaders.modules || []), globeCellUniforms]\n      };\n    }\n\n    updateState(params: any) {\n      super.updateState(params);\n      bindColorRangeTexture(this, type);\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      bindColorRangeTexture(this, type);\n      super.draw(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/globe-cell-utils.spec.js

@@ -0,0 +1,115 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { makeGlobeCellLayerClass } from './globe-cell-utils';
+function makeFakeCellLayerClass() {
+  return /*#__PURE__*/function () {
+    function FakeCellLayer() {
+      _classCallCheck(this, FakeCellLayer);
+      _defineProperty(this, "state", {});
+      _defineProperty(this, "context", {
+        viewport: {}
+      });
+    }
+    return _createClass(FakeCellLayer, [{
+      key: "getShaders",
+      value: function getShaders() {
+        return {
+          vs: 'void main(void) { gl_Position = project_common_position_to_clipspace(geometry.position); }',
+          modules: []
+        };
+      }
+
+      // deck.gl ColumnLayer recreates fillModel on extensionsChanged and does not
+      // copy over the colorRange texture binding. GridCellLayer / HexagonCellLayer
+      // only bind that texture when the colorRange *prop* changes.
+    }, {
+      key: "updateState",
+      value: function updateState(_params) {
+        this.state.fillModel = {
+          shaderInputs: {
+            setProps: jest.fn()
+          }
+        };
+      }
+    }, {
+      key: "draw",
+      value: function draw(_opts) {
+        // no-op stub so GlobeCellLayer.draw can call super.draw()
+      }
+    }]);
+  }();
+}
+describe('globe-cell-utils colorRange rebind', function () {
+  test('rebinds colorRange onto a rebuilt fillModel (grid)', function () {
+    var _layer$state$fillMode;
+    var GlobeGridCell = makeGlobeCellLayerClass(makeFakeCellLayerClass(), 'grid');
+    var layer = new GlobeGridCell();
+    layer.state.colorTexture = {
+      id: 'color-range-tex'
+    };
+    layer.updateState({
+      changeFlags: {
+        extensionsChanged: true
+      },
+      props: {
+        colorRange: ['#fff']
+      },
+      oldProps: {
+        colorRange: ['#fff']
+      }
+    });
+    expect((_layer$state$fillMode = layer.state.fillModel) === null || _layer$state$fillMode === void 0 ? void 0 : _layer$state$fillMode.shaderInputs.setProps).toHaveBeenCalledWith({
+      grid: {
+        colorRange: layer.state.colorTexture
+      }
+    });
+  });
+  test('rebinds colorRange onto a rebuilt fillModel (hexagon)', function () {
+    var _layer$state$fillMode2;
+    var GlobeHexCell = makeGlobeCellLayerClass(makeFakeCellLayerClass(), 'hexagon');
+    var layer = new GlobeHexCell();
+    layer.state.colorTexture = {
+      id: 'color-range-tex'
+    };
+    layer.updateState({
+      changeFlags: {
+        extensionsChanged: true
+      },
+      props: {
+        colorRange: ['#fff']
+      },
+      oldProps: {
+        colorRange: ['#fff']
+      }
+    });
+    expect((_layer$state$fillMode2 = layer.state.fillModel) === null || _layer$state$fillMode2 === void 0 ? void 0 : _layer$state$fillMode2.shaderInputs.setProps).toHaveBeenCalledWith({
+      hexagon: {
+        colorRange: layer.state.colorTexture
+      }
+    });
+  });
+  test('draw also rebinds colorRange so the first frame after rebuild is valid', function () {
+    var GlobeGridCell = makeGlobeCellLayerClass(makeFakeCellLayerClass(), 'grid');
+    var layer = new GlobeGridCell();
+    var setProps = jest.fn();
+    layer.state.colorTexture = {
+      id: 'color-range-tex'
+    };
+    layer.state.fillModel = {
+      shaderInputs: {
+        setProps: setProps
+      }
+    };
+    layer.draw({});
+    expect(setProps).toHaveBeenCalledWith({
+      grid: {
+        colorRange: layer.state.colorTexture
+      }
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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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