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

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

@@ -0,0 +1,203 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addGlobeCellProjection = addGlobeCellProjection;
+exports.makeGlobeCellLayerClass = makeGlobeCellLayerClass;
+exports.runBinOptionsWithMercatorViewport = runBinOptionsWithMercatorViewport;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _core = require("@deck.gl/core");
+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) { (0, _defineProperty2["default"])(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 = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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 = (0, _get2["default"])((0, _getPrototypeOf2["default"])(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
+/**
+ * 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.
+ */
+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`.
+ */
+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 _core.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((0, _defineProperty2["default"])({}, moduleName, {
+      colorRange: colorTexture
+    }));
+  }
+}
+function makeGlobeCellLayerClass(BaseCellLayer, type) {
+  var cached = globeCellClassCache.get(BaseCellLayer);
+  if (cached) {
+    return cached;
+  }
+  var GlobeCellLayer = /*#__PURE__*/function (_ref) {
+    function GlobeCellLayer() {
+      (0, _classCallCheck2["default"])(this, GlobeCellLayer);
+      return _callSuper(this, GlobeCellLayer, arguments);
+    }
+    (0, _inherits2["default"])(GlobeCellLayer, _ref);
+    return (0, _createClass2["default"])(GlobeCellLayer, [{
+      key: "getShaders",
+      value: function getShaders() {
+        var shaders = _superPropGet(GlobeCellLayer, "getShaders", this, 3)([]);
+        return _objectSpread(_objectSpread({}, shaders), {}, {
+          vs: addGlobeCellProjection(shaders.vs, type),
+          modules: [].concat((0, _toConsumableArray2["default"])(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":["_core","require","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","_callSuper","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","Boolean","prototype","valueOf","call","_superPropGet","p","_get2","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","resolution","mercatorViewport","WebMercatorViewport","width","height","longitude","latitude","zoom","originalViewport","globeCellClassCache","WeakMap","bindColorRangeTexture","moduleName","_layer$state","_layer$state2","model","state","fillModel","colorTexture","shaderInputs","setProps","colorRange","makeGlobeCellLayerClass","BaseCellLayer","cached","get","GlobeCellLayer","_ref","_classCallCheck2","_inherits2","_createClass2","key","value","getShaders","shaders","modules","_toConsumableArray2","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/cjs/layer-utils/globe-cell-utils.spec.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _globeCellUtils = require("./globe-cell-utils");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+function makeFakeCellLayerClass() {
+  return /*#__PURE__*/function () {
+    function FakeCellLayer() {
+      (0, _classCallCheck2["default"])(this, FakeCellLayer);
+      (0, _defineProperty2["default"])(this, "state", {});
+      (0, _defineProperty2["default"])(this, "context", {
+        viewport: {}
+      });
+    }
+    return (0, _createClass2["default"])(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 = (0, _globeCellUtils.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 = (0, _globeCellUtils.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 = (0, _globeCellUtils.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/cjs/layer-utils/shader-utils.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.editShader = editShader;
+exports.insertBefore = insertBefore;
+var _window = require("global/window");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/*
+ * Amendment to default layer vertex shader
+ * @param {string} vs
+ * @param {string} type
+ * @param {string} originalText
+ * @param {string} testToReplace
+ * @return {string} output shader
+ *
+ */
+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
+    _window.console.error("Cannot edit ".concat(type, " layer shader"));
+    return vs;
+  }
+  return vs.replace(originalText, testToReplace);
+}
+function insertBefore(vs, type, insertBeforeText, textToInsert) {
+  var at = vs.indexOf(insertBeforeText);
+  if (at < 0) {
+    _window.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/cjs/line-layer/line-layer.js

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _layers = require("@deck.gl/layers");
+var _ = require("../");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(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 = (0, _get2["default"])((0, _getPrototypeOf2["default"])(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) { (0, _defineProperty2["default"])(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
+var elevationScaleUniforms = {
+  name: 'elevationScale',
+  vs: "uniform elevationScaleUniforms {\n  float elevationScale;\n} elevationScaleProps;\n",
+  uniformTypes: {
+    elevationScale: 'f32'
+  }
+};
+var defaultProps = _objectSpread(_objectSpread({}, _layers.LineLayer.defaultProps), {}, {
+  getTargetColor: function getTargetColor(x) {
+    return x.color || [0, 0, 0, 255];
+  }
+});
+function addInstanceColorShader(vs) {
+  var targetColorVs = (0, _.editShader)(vs, 'line target color vs', 'in vec4 instanceColors;', 'in vec4 instanceColors; in vec4 instanceTargetColors;');
+  return (0, _.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 (0, _.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 = exports["default"] = /*#__PURE__*/function (_LineLayer) {
+  function EnhancedLineLayer() {
+    (0, _classCallCheck2["default"])(this, EnhancedLineLayer);
+    return _callSuper(this, EnhancedLineLayer, arguments);
+  }
+  (0, _inherits2["default"])(EnhancedLineLayer, _LineLayer);
+  return (0, _createClass2["default"])(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((0, _toConsumableArray2["default"])(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]
+        }
+      });
+    }
+  }]);
+}(_layers.LineLayer);
+EnhancedLineLayer.layerName = 'EnhancedLineLayer';
+EnhancedLineLayer.defaultProps = defaultProps;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_layers","require","_","_callSuper","t","o","e","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","apply","Boolean","prototype","valueOf","call","_superPropGet","r","p","_get2","ownKeys","Object","keys","getOwnPropertySymbols","filter","getOwnPropertyDescriptor","enumerable","push","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","elevationScaleUniforms","name","vs","uniformTypes","elevationScale","defaultProps","LineLayer","getTargetColor","x","color","addInstanceColorShader","targetColorVs","editShader","addElevationScale","EnhancedLineLayer","exports","_LineLayer","_classCallCheck2","_inherits2","_createClass2","key","value","getShaders","shaders","modules","concat","_toConsumableArray2","draw","opts","model","state","_this$props$elevation","shaderInputs","setProps","props","initializeState","_this$props$colorForm","_ref","attributeManager","addInstanced","instanceTargetColors","size","colorFormat","type","transition","accessor","defaultValue","layerName"],"sources":["../../../src/line-layer/line-layer.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {LineLayer, LineLayerProps} from '@deck.gl/layers';\nimport type {Color, AttributeManager} from '@deck.gl/core';\nimport {editShader} from '../';\n\ntype RGBAColor = Color;\n\nconst elevationScaleUniforms = {\n  name: 'elevationScale',\n  vs: `uniform elevationScaleUniforms {\n  float elevationScale;\n} elevationScaleProps;\n`,\n  uniformTypes: {\n    elevationScale: 'f32'\n  }\n};\n\nconst defaultProps = {\n  ...LineLayer.defaultProps,\n  getTargetColor: x => x.color || [0, 0, 0, 255]\n};\n\nfunction addInstanceColorShader(vs) {\n  const targetColorVs = editShader(\n    vs,\n    'line target color vs',\n    'in vec4 instanceColors;',\n    'in vec4 instanceColors; in vec4 instanceTargetColors;'\n  );\n\n  return editShader(\n    targetColorVs,\n    'line color vs',\n    'vColor = vec4(instanceColors.rgb, instanceColors.a * layer.opacity);',\n    `vec4 color = mix(instanceColors, instanceTargetColors, positions.x);` +\n      `vColor = vec4(color.rgb, color.a * layer.opacity);`\n  );\n}\n\nfunction addElevationScale(vs) {\n  return editShader(\n    vs,\n    'line elevation scale vs - multiply by elevation scale',\n    `geometry.worldPosition = instanceSourcePositions;\ngeometry.worldPositionAlt = instanceTargetPositions;\nvec3 source_world = instanceSourcePositions;\nvec3 target_world = instanceTargetPositions;`,\n    `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;`\n  );\n}\n\nexport default class EnhancedLineLayer extends LineLayer<\n  any,\n  LineLayerProps<any> & {elevationScale: number; getTargetColor: RGBAColor}\n> {\n  getShaders() {\n    const shaders = super.getShaders();\n\n    let vs = addInstanceColorShader(shaders.vs);\n    vs = addElevationScale(vs);\n\n    return {\n      ...shaders,\n      vs,\n      modules: [...(shaders.modules || []), elevationScaleUniforms]\n    };\n  }\n\n  draw(opts) {\n    const model = this.state.model;\n    if (model) {\n      model.shaderInputs.setProps({\n        elevationScale: {\n          elevationScale: this.props.elevationScale ?? 1\n        }\n      });\n    }\n    super.draw(opts);\n  }\n\n  initializeState() {\n    super.initializeState();\n    const {attributeManager} = this.state as {attributeManager: AttributeManager};\n    attributeManager.addInstanced({\n      instanceTargetColors: {\n        size: this.props.colorFormat?.length,\n        type: 'unorm8',\n        transition: true,\n        accessor: 'getTargetColor',\n        defaultValue: [0, 0, 0, 255]\n      }\n    });\n  }\n}\n\nEnhancedLineLayer.layerName = 'EnhancedLineLayer';\nEnhancedLineLayer.defaultProps = defaultProps;\n"],"mappings":"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","ignoreList":[]}