@kepler.gl/deckgl-layers 3.3.0-alpha.5 → 3.3.0-alpha.7

package/dist/esm/globe/globe-depth-disk-layer.js

@@ -0,0 +1,140 @@
+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 { COORDINATE_SYSTEM } from '@deck.gl/core';
+import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
+import { PlaneGeometry } from '@luma.gl/engine';
+import { Vector3 } from '@math.gl/core';
+import { editShader } from '../layer-utils/shader-utils';
+// luma.gl 9's PlaneGeometry ignores `radius`; pass explicit type/xlen/ylen so we
+// get a [-1, 1] quad (a `radius: 1` plane would only span [-0.5, 0.5]).
+var PLANE_GEOMETRY = new PlaneGeometry({
+  type: 'x,y',
+  xlen: 2,
+  ylen: 2
+});
+var DEPTH_DISK_PARAMETERS = {
+  // Depth writes only happen with depthTest enabled. The disk is opaque-black-ish
+  // and used purely to fill the depth buffer so far-side geometry (arcs/lines) is
+  // occluded by the planet.
+  depthTest: true,
+  cull: false
+};
+
+// Earth radius in meters. The disk geometry is a [-1, 1] plane; we scale it into
+// METERS in the vertex shader (like the atmosphere SphereGeometry, whose radius is
+// ~6.4e6 m) and let SimpleMeshLayer's stock projection map it onto the globe —
+// exactly the working path the atmosphere mesh layers use.
+var DEPTH_DISK_FULL_RADIUS = 6.371e6;
+
+// Globe common space uses GLOBE_RADIUS = 256 units (see deck.gl's project_globe_).
+// The disk orientation math is done in that 256-unit common space (matching
+// viewport.cameraPosition), then the resulting radius/shift ratios are converted to
+// meters for the shader, since the disk geometry is expressed in meters.
+export var GLOBE_COMMON_RADIUS = 256;
+
+/**
+ * Creates a view-oriented disk positioned along the direction from the globe's center to the camera.
+ * The disk is a cross-section of the globe between the front (visible) and back side, and it fills
+ * the depth buffer so anything on the far side of the globe (e.g. arcs/lines) is depth-culled and
+ * hidden behind the planet.
+ */
+export var GlobeDepthDiskLayer = /*#__PURE__*/function (_SimpleMeshLayer) {
+  function GlobeDepthDiskLayer() {
+    _classCallCheck(this, GlobeDepthDiskLayer);
+    return _callSuper(this, GlobeDepthDiskLayer, arguments);
+  }
+  _inherits(GlobeDepthDiskLayer, _SimpleMeshLayer);
+  return _createClass(GlobeDepthDiskLayer, [{
+    key: "getShaders",
+    value: function getShaders() {
+      var shaders = _superPropGet(GlobeDepthDiskLayer, "getShaders", this, 3)([]);
+
+      // Override the local `pos` computation: reorient the flat [-1,1] plane to face
+      // the camera, scale it to meters, and shift it toward the camera along the view
+      // axis so it sits at the globe's silhouette cross-section. The stock
+      // project_position_to_clipspace call is left untouched so the disk projects onto
+      // the globe through the exact same (working) path the atmosphere mesh layers use.
+      var vs = editShader(shaders.vs, 'globe depth disk vs', 'vec3 pos = (instanceModelMatrix * positions) * simpleMesh.sizeScale + instanceTranslation;', "mat3 u_matDepthDiskOrientation = mat3(\n         u_depthDiskOrientCol0,\n         u_depthDiskOrientCol1,\n         u_depthDiskOrientCol2\n       );\n       vec3 pos = (u_matDepthDiskOrientation * positions) * u_depthDiskRadius;\n       vDepthDiskPos = pos;\n       pos = pos + u_directionToCamera * u_depthDiskShift;\n      ");
+      var inject = {
+        'vs:#decl': "\n        uniform vec3 u_depthDiskOrientCol0;\n        uniform vec3 u_depthDiskOrientCol1;\n        uniform vec3 u_depthDiskOrientCol2;\n        uniform vec3 u_directionToCamera;\n        uniform float u_depthDiskShift;\n        uniform float u_depthDiskRadius;\n        out vec3 vDepthDiskPos;\n      ",
+        'fs:#decl': "\n        uniform float u_depthDiskRadius;\n        in vec3 vDepthDiskPos;\n      ",
+        'fs:#main-start': "\n        if (length(vDepthDiskPos) > u_depthDiskRadius) {\n          discard;\n        }\n      "
+      };
+      return _objectSpread(_objectSpread({}, shaders), {}, {
+        vs: vs,
+        inject: inject
+      });
+    }
+  }, {
+    key: "draw",
+    value: function draw(_ref) {
+      var uniforms = _ref.uniforms;
+      var normalizedRadius = GLOBE_COMMON_RADIUS;
+      var camPos = new Vector3(this.context.viewport.cameraPosition);
+      var camDir = camPos.clone().normalize();
+      var topDir = new Vector3(0, 0, 1);
+      var sideDir = camDir.clone().cross(topDir);
+      var sidePoint = sideDir.clone().scale(normalizedRadius);
+      var camToSide = sidePoint.clone().subtract(camPos).normalize();
+      var adjustedSidePoint = camToSide.cross(topDir).scale(-normalizedRadius);
+      var shiftToCamera = camDir.dot(adjustedSidePoint);
+      var adjustedDiskRadius = Math.sqrt(normalizedRadius * normalizedRadius - shiftToCamera * shiftToCamera);
+
+      // Camera-facing orientation: the plane's local X/Y axes map to world `right`/`up`
+      // (both perpendicular to the camera direction), and local Z maps to `forward`.
+      // Columns are handed to the shader as vec3s to avoid Matrix3 row/column ambiguity.
+      var forward = camDir.clone();
+      var right = topDir.clone().cross(forward).normalize();
+      var up = forward.clone().cross(right).normalize();
+      var model = this.state.model;
+      if (model) {
+        // Use the same uniform-delivery mechanism as the (working) atmosphere layers:
+        // raw `uniform` declarations + assignment to model.props.uniforms.
+        model.props.uniforms = _objectSpread(_objectSpread({}, model.props.uniforms), {}, {
+          // mat3(col0, col1, col2) in GLSL is column-major; mat3 * (x, y, 0) = x*right + y*up.
+          u_depthDiskOrientCol0: [right[0], right[1], right[2]],
+          u_depthDiskOrientCol1: [up[0], up[1], up[2]],
+          u_depthDiskOrientCol2: [forward[0], forward[1], forward[2]],
+          u_directionToCamera: [camDir[0], camDir[1], camDir[2]],
+          // Convert the common-space (256-unit) radius/shift to meters, since the disk
+          // geometry (and therefore `pos`) is expressed in meters.
+          u_depthDiskShift: shiftToCamera / normalizedRadius * DEPTH_DISK_FULL_RADIUS,
+          u_depthDiskRadius: adjustedDiskRadius / normalizedRadius * DEPTH_DISK_FULL_RADIUS
+        });
+      }
+      _superPropGet(GlobeDepthDiskLayer, "draw", this, 3)([{
+        uniforms: uniforms
+      }]);
+    }
+  }]);
+}(SimpleMeshLayer);
+_defineProperty(GlobeDepthDiskLayer, "layerName", 'GlobeDepthDiskLayer');
+export var getGlobeDepthDiskLayer = function getGlobeDepthDiskLayer(_ref2) {
+  var fillColor = _ref2.fillColor;
+  return new GlobeDepthDiskLayer({
+    id: 'globe-depth-disk-layer',
+    data: [[0, 0, 0]],
+    coordinateOrigin: [0, 0, 0],
+    coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+    getPosition: function getPosition(d) {
+      return d;
+    },
+    getColor: fillColor !== null && fillColor !== void 0 ? fillColor : [0, 0, 0],
+    mesh: PLANE_GEOMETRY,
+    parameters: DEPTH_DISK_PARAMETERS
+  });
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["COORDINATE_SYSTEM","SimpleMeshLayer","PlaneGeometry","Vector3","editShader","PLANE_GEOMETRY","type","xlen","ylen","DEPTH_DISK_PARAMETERS","depthTest","cull","DEPTH_DISK_FULL_RADIUS","GLOBE_COMMON_RADIUS","GlobeDepthDiskLayer","_SimpleMeshLayer","_classCallCheck","_callSuper","arguments","_inherits","_createClass","key","value","getShaders","shaders","_superPropGet","vs","inject","_objectSpread","draw","_ref","uniforms","normalizedRadius","camPos","context","viewport","cameraPosition","camDir","clone","normalize","topDir","sideDir","cross","sidePoint","scale","camToSide","subtract","adjustedSidePoint","shiftToCamera","dot","adjustedDiskRadius","Math","sqrt","forward","right","up","model","state","props","u_depthDiskOrientCol0","u_depthDiskOrientCol1","u_depthDiskOrientCol2","u_directionToCamera","u_depthDiskShift","u_depthDiskRadius","_defineProperty","getGlobeDepthDiskLayer","_ref2","fillColor","id","data","coordinateOrigin","coordinateSystem","CARTESIAN","getPosition","d","getColor","mesh","parameters"],"sources":["../../../src/globe/globe-depth-disk-layer.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {COORDINATE_SYSTEM} from '@deck.gl/core';\nimport {SimpleMeshLayer} from '@deck.gl/mesh-layers';\nimport {PlaneGeometry} from '@luma.gl/engine';\nimport {Vector3} from '@math.gl/core';\n\nimport {editShader} from '../layer-utils/shader-utils';\nimport type {RGBColor} from '@kepler.gl/types';\n\n// luma.gl 9's PlaneGeometry ignores `radius`; pass explicit type/xlen/ylen so we\n// get a [-1, 1] quad (a `radius: 1` plane would only span [-0.5, 0.5]).\nconst PLANE_GEOMETRY = new PlaneGeometry({\n  type: 'x,y',\n  xlen: 2,\n  ylen: 2\n} as any);\n\nconst DEPTH_DISK_PARAMETERS = {\n  // Depth writes only happen with depthTest enabled. The disk is opaque-black-ish\n  // and used purely to fill the depth buffer so far-side geometry (arcs/lines) is\n  // occluded by the planet.\n  depthTest: true,\n  cull: false\n};\n\n// Earth radius in meters. The disk geometry is a [-1, 1] plane; we scale it into\n// METERS in the vertex shader (like the atmosphere SphereGeometry, whose radius is\n// ~6.4e6 m) and let SimpleMeshLayer's stock projection map it onto the globe —\n// exactly the working path the atmosphere mesh layers use.\nconst DEPTH_DISK_FULL_RADIUS = 6.371e6;\n\n// Globe common space uses GLOBE_RADIUS = 256 units (see deck.gl's project_globe_).\n// The disk orientation math is done in that 256-unit common space (matching\n// viewport.cameraPosition), then the resulting radius/shift ratios are converted to\n// meters for the shader, since the disk geometry is expressed in meters.\nexport const GLOBE_COMMON_RADIUS = 256;\n\n/**\n * Creates a view-oriented disk positioned along the direction from the globe's center to the camera.\n * The disk is a cross-section of the globe between the front (visible) and back side, and it fills\n * the depth buffer so anything on the far side of the globe (e.g. arcs/lines) is depth-culled and\n * hidden behind the planet.\n */\nexport class GlobeDepthDiskLayer extends SimpleMeshLayer<any> {\n  static layerName = 'GlobeDepthDiskLayer';\n\n  getShaders(): any {\n    const shaders = super.getShaders();\n\n    // Override the local `pos` computation: reorient the flat [-1,1] plane to face\n    // the camera, scale it to meters, and shift it toward the camera along the view\n    // axis so it sits at the globe's silhouette cross-section. The stock\n    // project_position_to_clipspace call is left untouched so the disk projects onto\n    // the globe through the exact same (working) path the atmosphere mesh layers use.\n    const vs = editShader(\n      shaders.vs,\n      'globe depth disk vs',\n      'vec3 pos = (instanceModelMatrix * positions) * simpleMesh.sizeScale + instanceTranslation;',\n      `mat3 u_matDepthDiskOrientation = mat3(\n         u_depthDiskOrientCol0,\n         u_depthDiskOrientCol1,\n         u_depthDiskOrientCol2\n       );\n       vec3 pos = (u_matDepthDiskOrientation * positions) * u_depthDiskRadius;\n       vDepthDiskPos = pos;\n       pos = pos + u_directionToCamera * u_depthDiskShift;\n      `\n    );\n\n    const inject = {\n      'vs:#decl': `\n        uniform vec3 u_depthDiskOrientCol0;\n        uniform vec3 u_depthDiskOrientCol1;\n        uniform vec3 u_depthDiskOrientCol2;\n        uniform vec3 u_directionToCamera;\n        uniform float u_depthDiskShift;\n        uniform float u_depthDiskRadius;\n        out vec3 vDepthDiskPos;\n      `,\n      'fs:#decl': `\n        uniform float u_depthDiskRadius;\n        in vec3 vDepthDiskPos;\n      `,\n      'fs:#main-start': `\n        if (length(vDepthDiskPos) > u_depthDiskRadius) {\n          discard;\n        }\n      `\n    };\n\n    return {\n      ...shaders,\n      vs,\n      inject\n    };\n  }\n\n  draw({uniforms}: {uniforms: object}): void {\n    const normalizedRadius = GLOBE_COMMON_RADIUS;\n\n    const camPos = new Vector3((this.context.viewport as any).cameraPosition);\n    const camDir = camPos.clone().normalize();\n    const topDir = new Vector3(0, 0, 1);\n    const sideDir = camDir.clone().cross(topDir);\n    const sidePoint = sideDir.clone().scale(normalizedRadius);\n\n    const camToSide = sidePoint.clone().subtract(camPos).normalize();\n    const adjustedSidePoint = camToSide.cross(topDir).scale(-normalizedRadius);\n\n    const shiftToCamera = camDir.dot(adjustedSidePoint);\n    const adjustedDiskRadius = Math.sqrt(\n      normalizedRadius * normalizedRadius - shiftToCamera * shiftToCamera\n    );\n\n    // Camera-facing orientation: the plane's local X/Y axes map to world `right`/`up`\n    // (both perpendicular to the camera direction), and local Z maps to `forward`.\n    // Columns are handed to the shader as vec3s to avoid Matrix3 row/column ambiguity.\n    const forward = camDir.clone();\n    const right = topDir.clone().cross(forward).normalize();\n    const up = forward.clone().cross(right).normalize();\n\n    const model = this.state.model;\n    if (model) {\n      // Use the same uniform-delivery mechanism as the (working) atmosphere layers:\n      // raw `uniform` declarations + assignment to model.props.uniforms.\n      (model as any).props.uniforms = {\n        ...(model as any).props.uniforms,\n        // mat3(col0, col1, col2) in GLSL is column-major; mat3 * (x, y, 0) = x*right + y*up.\n        u_depthDiskOrientCol0: [right[0], right[1], right[2]],\n        u_depthDiskOrientCol1: [up[0], up[1], up[2]],\n        u_depthDiskOrientCol2: [forward[0], forward[1], forward[2]],\n        u_directionToCamera: [camDir[0], camDir[1], camDir[2]],\n        // Convert the common-space (256-unit) radius/shift to meters, since the disk\n        // geometry (and therefore `pos`) is expressed in meters.\n        u_depthDiskShift: (shiftToCamera / normalizedRadius) * DEPTH_DISK_FULL_RADIUS,\n        u_depthDiskRadius: (adjustedDiskRadius / normalizedRadius) * DEPTH_DISK_FULL_RADIUS\n      };\n    }\n    super.draw({uniforms});\n  }\n}\n\nexport const getGlobeDepthDiskLayer = ({fillColor}: {fillColor?: RGBColor}) => {\n  return new GlobeDepthDiskLayer({\n    id: 'globe-depth-disk-layer',\n    data: [[0, 0, 0]],\n    coordinateOrigin: [0, 0, 0],\n    coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,\n    getPosition: (d: number[]) => d,\n    getColor: (fillColor ?? [0, 0, 0]) as any,\n    mesh: PLANE_GEOMETRY,\n    parameters: DEPTH_DISK_PARAMETERS\n  } as any);\n};\n"],"mappings":"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","ignoreList":[]}