@deck.gl/core 9.3.0-alpha.6 → 9.3.0-beta.1

package/dist/dist.dev.js

@@ -27748,33 +27748,33 @@ float smoothedge(float edge, float x) {
     /**
      * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
      */
-    DEFAULT: -1,
+    DEFAULT: "default",
     /**
      * Positions are interpreted as [longitude, latitude, elevation]
      * longitude/latitude are in degrees, elevation is in meters.
      * Dimensions are in meters.
      */
-    LNGLAT: 1,
+    LNGLAT: "lnglat",
     /**
      * Positions are interpreted as [x, y, z] in meter offsets from the coordinate origin.
      * Dimensions are in meters.
      */
-    METER_OFFSETS: 2,
+    METER_OFFSETS: "meter-offsets",
     /**
      * Positions are interpreted as [deltaLng, deltaLat, elevation] from the coordinate origin.
      * deltaLng/deltaLat are in degrees, elevation is in meters.
      * Dimensions are in meters.
      */
-    LNGLAT_OFFSETS: 3,
+    LNGLAT_OFFSETS: "lnglat-offsets",
     /**
      * Positions and dimensions are in the common units of the viewport.
      */
-    CARTESIAN: 0
+    CARTESIAN: "cartesian"
   };
   Object.defineProperty(COORDINATE_SYSTEM, "IDENTITY", {
     get: () => {
       log_default.deprecated("COORDINATE_SYSTEM.IDENTITY", "COORDINATE_SYSTEM.CARTESIAN")();
-      return 0;
+      return COORDINATE_SYSTEM.CARTESIAN;
     }
   });
   var PROJECTION_MODE = {
@@ -27860,6 +27860,20 @@ float smoothedge(float edge, float x) {
   var IDENTITY_MATRIX2 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
   var DEFAULT_PIXELS_PER_UNIT2 = [0, 0, 0];
   var DEFAULT_COORDINATE_ORIGIN = [0, 0, 0];
+  var COORDINATE_SYSTEM_NUMBERS = {
+    default: -1,
+    cartesian: 0,
+    lnglat: 1,
+    "meter-offsets": 2,
+    "lnglat-offsets": 3
+  };
+  function getShaderCoordinateSystem(coordinateSystem) {
+    const shaderCoordinateSystem = COORDINATE_SYSTEM_NUMBERS[coordinateSystem];
+    if (shaderCoordinateSystem === void 0) {
+      throw new Error(`Invalid coordinateSystem: ${coordinateSystem}`);
+    }
+    return shaderCoordinateSystem;
+  }
   var getMemoizedViewportUniforms = memoize(calculateViewportUniforms);
   function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_COORDINATE_ORIGIN) {
     if (coordinateOrigin.length < 3) {
@@ -27868,7 +27882,7 @@ float smoothedge(float edge, float x) {
     let shaderCoordinateOrigin = coordinateOrigin;
     let geospatialOrigin;
     let offsetMode = true;
-    if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT_OFFSETS || coordinateSystem === COORDINATE_SYSTEM.METER_OFFSETS) {
+    if (coordinateSystem === "lnglat-offsets" || coordinateSystem === "meter-offsets") {
       geospatialOrigin = coordinateOrigin;
     } else {
       geospatialOrigin = viewport.isGeospatial ? (
@@ -27878,15 +27892,15 @@ float smoothedge(float edge, float x) {
     }
     switch (viewport.projectionMode) {
       case PROJECTION_MODE.WEB_MERCATOR:
-        if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {
+        if (coordinateSystem === "lnglat" || coordinateSystem === "cartesian") {
           geospatialOrigin = [0, 0, 0];
           offsetMode = false;
         }
         break;
       case PROJECTION_MODE.WEB_MERCATOR_AUTO_OFFSET:
-        if (coordinateSystem === COORDINATE_SYSTEM.LNGLAT) {
+        if (coordinateSystem === "lnglat") {
           shaderCoordinateOrigin = geospatialOrigin;
-        } else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {
+        } else if (coordinateSystem === "cartesian") {
           shaderCoordinateOrigin = [
             Math.fround(viewport.center[0]),
             Math.fround(viewport.center[1]),
@@ -27950,12 +27964,12 @@ float smoothedge(float edge, float x) {
     devicePixelRatio: devicePixelRatio2 = 1,
     modelMatrix = null,
     // Match Layer.defaultProps
-    coordinateSystem = COORDINATE_SYSTEM.DEFAULT,
+    coordinateSystem = "default",
     coordinateOrigin = DEFAULT_COORDINATE_ORIGIN,
     autoWrapLongitude = false
   }) {
-    if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
-      coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN;
+    if (coordinateSystem === "default") {
+      coordinateSystem = viewport.isGeospatial ? "lnglat" : "cartesian";
     }
     const uniforms = getMemoizedViewportUniforms({
       viewport,
@@ -27989,7 +28003,7 @@ float smoothedge(float edge, float x) {
     const focalDistance = vec4_exports.transformMat4([], [0, 0, -viewport.focalDistance, 1], viewport.projectionMatrix)[3] || 1;
     const uniforms = {
       // Projection mode values
-      coordinateSystem,
+      coordinateSystem: getShaderCoordinateSystem(coordinateSystem),
       projectionMode: viewport.projectionMode,
       coordinateOrigin: shaderCoordinateOrigin,
       commonOrigin: originCommon.slice(0, 3),
@@ -28016,19 +28030,19 @@ float smoothedge(float edge, float x) {
     if (geospatialOrigin) {
       const distanceScalesAtOrigin = viewport.getDistanceScales(geospatialOrigin);
       switch (coordinateSystem) {
-        case COORDINATE_SYSTEM.METER_OFFSETS:
+        case "meter-offsets":
           uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerMeter;
           uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerMeter2;
           break;
-        case COORDINATE_SYSTEM.LNGLAT:
-        case COORDINATE_SYSTEM.LNGLAT_OFFSETS:
+        case "lnglat":
+        case "lnglat-offsets":
           if (!viewport._pseudoMeters) {
             uniforms.commonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter;
           }
           uniforms.commonUnitsPerWorldUnit = distanceScalesAtOrigin.unitsPerDegree;
           uniforms.commonUnitsPerWorldUnit2 = distanceScalesAtOrigin.unitsPerDegree2;
           break;
-        case COORDINATE_SYSTEM.CARTESIAN:
+        case "cartesian":
           uniforms.commonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]];
           uniforms.commonUnitsPerWorldUnit2 = [0, 0, distanceScalesAtOrigin.unitsPerMeter2[2]];
           break;
@@ -28040,7 +28054,16 @@ float smoothedge(float edge, float x) {
   }
 
   // src/shaderlib/project/project.wgsl.ts
-  var COORDINATE_SYSTEM_WGSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => `const COORDINATE_SYSTEM_${key}: i32 = ${COORDINATE_SYSTEM[key]};`).join("");
+  var SHADER_COORDINATE_SYSTEMS = [
+    "default",
+    "lnglat",
+    "meter-offsets",
+    "lnglat-offsets",
+    "cartesian"
+  ];
+  var COORDINATE_SYSTEM_WGSL_CONSTANTS = SHADER_COORDINATE_SYSTEMS.map(
+    (coordinateSystem) => `const COORDINATE_SYSTEM_${coordinateSystem.toUpperCase().replaceAll("-", "_")}: i32 = ${getShaderCoordinateSystem(coordinateSystem)};`
+  ).join("");
   var PROJECTION_MODE_WGSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const PROJECTION_MODE_${key}: i32 = ${PROJECTION_MODE[key]};`).join("");
   var UNIT_WGSL_CONSTANTS = Object.keys(UNIT).map((key) => `const UNIT_${key.toUpperCase()}: i32 = ${UNIT[key]};`).join("");
   var projectWGSLHeader = (
@@ -28334,7 +28357,16 @@ fn project_pixel_size_vec2(pixels: vec2<f32>) -> vec2<f32> {
   );
 
   // src/shaderlib/project/project.glsl.ts
-  var COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM).map((key) => `const int COORDINATE_SYSTEM_${key} = ${COORDINATE_SYSTEM[key]};`).join("");
+  var SHADER_COORDINATE_SYSTEMS2 = [
+    "default",
+    "lnglat",
+    "meter-offsets",
+    "lnglat-offsets",
+    "cartesian"
+  ];
+  var COORDINATE_SYSTEM_GLSL_CONSTANTS = SHADER_COORDINATE_SYSTEMS2.map(
+    (coordinateSystem) => `const int COORDINATE_SYSTEM_${coordinateSystem.toUpperCase().replaceAll("-", "_")} = ${getShaderCoordinateSystem(coordinateSystem)};`
+  ).join("");
   var PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE).map((key) => `const int PROJECTION_MODE_${key} = ${PROJECTION_MODE[key]};`).join("");
   var UNIT_GLSL_CONSTANTS = Object.keys(UNIT).map((key) => `const int UNIT_${key.toUpperCase()} = ${UNIT[key]};`).join("");
   var projectGLSL = (
@@ -29242,7 +29274,7 @@ ${fragment}
     for (let i = 0; i < opts.shadowMatrices.length; i++) {
       const viewProjectionMatrix = viewProjectionMatrices[i];
       const viewProjectionMatrixCentered = viewProjectionMatrix.clone().translate(new Vector3(projectProps.viewport.center).negate());
-      if (projectUniforms.coordinateSystem === COORDINATE_SYSTEM.LNGLAT && projectUniforms.projectionMode === PROJECTION_MODE.WEB_MERCATOR) {
+      if (projectUniforms.coordinateSystem === getShaderCoordinateSystem("lnglat") && projectUniforms.projectionMode === PROJECTION_MODE.WEB_MERCATOR) {
         viewProjectionMatrices[i] = viewProjectionMatrixCentered;
         projectCenters[i] = center;
       } else {
@@ -29302,7 +29334,7 @@ ${fragment}
   isActive: f32,
   isAttribute: f32,
   isHighlightActive: f32,
-  useFloatColors: f32,
+  useByteColors: f32,
   highlightedObjectColor: vec3<f32>,
   highlightColor: vec4<f32>,
 };
@@ -29310,11 +29342,11 @@ ${fragment}
 @group(0) @binding(auto) var<uniform> picking: pickingUniforms;
 
 fn picking_normalizeColor(color: vec3<f32>) -> vec3<f32> {
-  return select(color / 255.0, color, picking.useFloatColors > 0.5);
+  return select(color, color / 255.0, picking.useByteColors > 0.5);
 }
 
 fn picking_normalizeColor4(color: vec4<f32>) -> vec4<f32> {
-  return select(color / 255.0, color, picking.useFloatColors > 0.5);
+  return select(color, color / 255.0, picking.useByteColors > 0.5);
 }
 
 fn picking_isColorZero(color: vec3<f32>) -> bool {
@@ -29329,7 +29361,7 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
   var picking_default = {
     ...picking,
     source: sourceWGSL,
-    defaultUniforms: { ...picking.defaultUniforms, useFloatColors: false },
+    defaultUniforms: { ...picking.defaultUniforms, useByteColors: true },
     inject: {
       "vs:DECKGL_FILTER_GL_POSITION": `
     // for picking depth values
@@ -30709,11 +30741,13 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
   function normalizeParameters(opts) {
     const { viewport, modelMatrix, coordinateOrigin } = opts;
     let { coordinateSystem, fromCoordinateSystem, fromCoordinateOrigin } = opts;
-    if (coordinateSystem === COORDINATE_SYSTEM.DEFAULT) {
-      coordinateSystem = viewport.isGeospatial ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN;
+    if (coordinateSystem === "default") {
+      coordinateSystem = viewport.isGeospatial ? "lnglat" : "cartesian";
     }
     if (fromCoordinateSystem === void 0) {
       fromCoordinateSystem = coordinateSystem;
+    } else if (fromCoordinateSystem === "default") {
+      fromCoordinateSystem = viewport.isGeospatial ? "lnglat" : "cartesian";
     }
     if (fromCoordinateOrigin === void 0) {
       fromCoordinateOrigin = coordinateOrigin;
@@ -30739,23 +30773,32 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
       [x, y, z] = vec4_exports.transformMat4([], [x, y, z, 1], modelMatrix);
     }
     switch (coordinateSystem) {
-      case COORDINATE_SYSTEM.LNGLAT:
+      case "default":
+        return getWorldPosition(position, {
+          viewport,
+          modelMatrix,
+          coordinateSystem: viewport.isGeospatial ? "lnglat" : "cartesian",
+          coordinateOrigin,
+          offsetMode
+        });
+      case "lnglat":
         return lngLatZToWorldPosition([x, y, z], viewport, offsetMode);
-      case COORDINATE_SYSTEM.LNGLAT_OFFSETS:
+      case "lnglat-offsets":
         return lngLatZToWorldPosition(
           [x + coordinateOrigin[0], y + coordinateOrigin[1], z + (coordinateOrigin[2] || 0)],
           viewport,
           offsetMode
         );
-      case COORDINATE_SYSTEM.METER_OFFSETS:
+      case "meter-offsets":
         return lngLatZToWorldPosition(
           addMetersToLngLat(coordinateOrigin, [x, y, z]),
           viewport,
           offsetMode
         );
-      case COORDINATE_SYSTEM.CARTESIAN:
-      default:
+      case "cartesian":
         return viewport.isGeospatial ? [x + coordinateOrigin[0], y + coordinateOrigin[1], z + coordinateOrigin[2]] : viewport.projectPosition([x, y, z]);
+      default:
+        throw new Error(`Invalid coordinateSystem: ${coordinateSystem}`);
     }
   }
   function projectPosition(position, params) {
@@ -37204,10 +37247,14 @@ void main() {
         }
         if (!this.value) {
         } else if (this.constant || !this.buffer || this.buffer.byteLength < this.value.byteLength + this.byteOffset) {
-          this.setData({
-            value: this.value,
-            constant: this.constant
-          });
+          if (this.constant) {
+            this.setConstantValue(context, this.value);
+          } else {
+            this.setData({
+              value: this.value,
+              constant: this.constant
+            });
+          }
           this.constant = false;
         } else {
           for (const [startRow, endRow] of updateRanges) {
@@ -37227,17 +37274,13 @@ void main() {
     // Use generic value
     // Returns true if successful
     setConstantValue(context, value) {
-      const isWebGPU = this.device.type === "webgpu";
-      if (isWebGPU || value === void 0 || typeof value === "function") {
-        if (isWebGPU && typeof value !== "function") {
-          const normalisedValue = this._normalizeValue(value, [], 0);
-          if (!this._areValuesEqual(normalisedValue, this.value)) {
-            this.setNeedsUpdate("WebGPU constant updated");
-          }
-        }
+      if (value === void 0 || typeof value === "function") {
         return false;
       }
       const transformedValue = this.settings.transform && context ? this.settings.transform.call(context, value) : value;
+      if (this.device.type === "webgpu") {
+        return this.setConstantBufferValue(transformedValue, this.numInstances);
+      }
       const hasChanged = this.setData({ constant: true, value: transformedValue });
       if (hasChanged) {
         this.setNeedsRedraw();
@@ -37245,6 +37288,41 @@ void main() {
       this.clearNeedsUpdate();
       return true;
     }
+    setConstantBufferValue(value, numInstances) {
+      const ArrayType = this.settings.defaultType;
+      const constantValue = this._normalizeValue(value, new ArrayType(this.size), 0);
+      if (this._hasConstantBufferValue(constantValue, numInstances)) {
+        this.constant = false;
+        this.clearNeedsUpdate();
+        return false;
+      }
+      const repeatedValue = new ArrayType(Math.max(numInstances, 1) * this.size);
+      for (let i = 0; i < repeatedValue.length; i += this.size) {
+        repeatedValue.set(constantValue, i);
+      }
+      const hasChanged = this.setData({ value: repeatedValue });
+      this.constant = false;
+      this.clearNeedsUpdate();
+      if (hasChanged) {
+        this.setNeedsRedraw();
+      }
+      return hasChanged;
+    }
+    _hasConstantBufferValue(value, numInstances) {
+      const currentValue = this.value;
+      const expectedLength = Math.max(numInstances, 1) * this.size;
+      if (!ArrayBuffer.isView(currentValue) || currentValue.length !== expectedLength || currentValue.length % this.size !== 0) {
+        return false;
+      }
+      for (let i = 0; i < currentValue.length; i += this.size) {
+        for (let j = 0; j < this.size; j++) {
+          if (currentValue[i + j] !== value[j]) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
     // Use external buffer
     // Returns true if successful
     // eslint-disable-next-line max-statements
@@ -37353,18 +37431,10 @@ void main() {
       props,
       numInstances
     }) {
-      if (attribute.constant) {
-        if (this.context.device.type !== "webgpu") {
-          return;
-        }
-      }
       const { settings, state, value, size, startIndices } = attribute;
       const { accessor, transform } = settings;
-      let accessorFunc = state.binaryAccessor || // @ts-ignore
+      const accessorFunc = state.binaryAccessor || // @ts-ignore
       (typeof accessor === "function" ? accessor : props[accessor]);
-      if (typeof accessorFunc !== "function" && typeof accessor === "string") {
-        accessorFunc = () => props[accessor];
-      }
       assert9(typeof accessorFunc === "function", `accessor "${accessor}" is not a function`);
       let i = attribute.getVertexOffset(startRow);
       const { iterable, objectInfo } = createIterable(data, startRow, endRow);
@@ -39520,7 +39590,7 @@ void main(void) {
     onDragStart: { type: "function", value: null, optional: true },
     onDrag: { type: "function", value: null, optional: true },
     onDragEnd: { type: "function", value: null, optional: true },
-    coordinateSystem: COORDINATE_SYSTEM.DEFAULT,
+    coordinateSystem: "default",
     coordinateOrigin: { type: "array", value: [0, 0, 0], compare: true },
     modelMatrix: { type: "array", value: null, compare: true, optional: true },
     wrapLongitude: false,
@@ -39664,7 +39734,7 @@ void main(void) {
     }
     use64bitPositions() {
       const { coordinateSystem } = this.props;
-      return coordinateSystem === COORDINATE_SYSTEM.DEFAULT || coordinateSystem === COORDINATE_SYSTEM.LNGLAT || coordinateSystem === COORDINATE_SYSTEM.CARTESIAN;
+      return coordinateSystem === "default" || coordinateSystem === "lnglat" || coordinateSystem === "cartesian";
     }
     // Event handling
     onHover(info, pickingEvent) {
@@ -40044,7 +40114,6 @@ void main(void) {
     /* (Internal) Called by layer manager when a new layer is found */
     _initialize() {
       assert9(!this.internalState);
-      assert9(Number.isFinite(this.props.coordinateSystem));
       debug(TRACE_INITIALIZE, this);
       const attributeManager = this._getAttributeManager();
       if (attributeManager) {