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

package/dist/index.cjs

@@ -230,7 +230,7 @@ var json_loader_default = {
 
 // dist/lib/init.js
 function checkVersion() {
-  const version = true ? "9.3.0-alpha.6" : globalThis.DECK_VERSION || "untranspiled source";
+  const version = true ? "9.3.0-beta.2" : globalThis.DECK_VERSION || "untranspiled source";
   const existingVersion = globalThis.deck && globalThis.deck.VERSION;
   if (existingVersion && existingVersion !== version) {
     throw new Error(`deck.gl - multiple versions detected: ${existingVersion} vs ${version}`);
@@ -399,33 +399,33 @@ var COORDINATE_SYSTEM = {
   /**
    * `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 = {
@@ -511,6 +511,20 @@ var VECTOR_TO_POINT_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0];
 var IDENTITY_MATRIX = [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) {
@@ -519,7 +533,7 @@ function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_
   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 ? (
@@ -529,15 +543,15 @@ function getOffsetOrigin(viewport, coordinateSystem, coordinateOrigin = DEFAULT_
   }
   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]),
@@ -597,12 +611,12 @@ function getUniformsFromViewport({
   devicePixelRatio = 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,
@@ -624,7 +638,7 @@ function calculateViewportUniforms({ viewport, devicePixelRatio, coordinateSyste
   const focalDistance = import_core2.vec4.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),
@@ -651,19 +665,19 @@ function calculateViewportUniforms({ viewport, devicePixelRatio, coordinateSyste
   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;
@@ -675,7 +689,14 @@ function calculateViewportUniforms({ viewport, devicePixelRatio, coordinateSyste
 }
 
 // dist/shaderlib/project/project.wgsl.js
-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 = (
@@ -969,7 +990,14 @@ fn project_pixel_size_vec2(pixels: vec2<f32>) -> vec2<f32> {
 );
 
 // dist/shaderlib/project/project.glsl.js
-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 = (
@@ -1465,7 +1493,7 @@ function createShadowUniforms(opts) {
   for (let i = 0; i < opts.shadowMatrices.length; i++) {
     const viewProjectionMatrix = viewProjectionMatrices[i];
     const viewProjectionMatrixCentered = viewProjectionMatrix.clone().translate(new import_core3.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 {
@@ -1526,7 +1554,7 @@ var sourceWGSL = (
   isActive: f32,
   isAttribute: f32,
   isHighlightActive: f32,
-  useFloatColors: f32,
+  useByteColors: f32,
   highlightedObjectColor: vec3<f32>,
   highlightColor: vec4<f32>,
 };
@@ -1534,11 +1562,11 @@ var sourceWGSL = (
 @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 {
@@ -1553,7 +1581,7 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
 var picking_default = {
   ...import_shadertools2.picking,
   source: sourceWGSL,
-  defaultUniforms: { ...import_shadertools2.picking.defaultUniforms, useFloatColors: false },
+  defaultUniforms: { ...import_shadertools2.picking.defaultUniforms, useByteColors: true },
   inject: {
     "vs:DECKGL_FILTER_GL_POSITION": `
     // for picking depth values
@@ -2844,11 +2872,13 @@ function lngLatZToWorldPosition(lngLatZ, viewport, offsetMode = false) {
 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;
@@ -2868,15 +2898,24 @@ function getWorldPosition(position, { viewport, modelMatrix, coordinateSystem, c
     [x, y, z] = import_core9.vec4.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((0, import_web_mercator4.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) {
@@ -7414,7 +7453,7 @@ TooltipWidget.defaultProps = {
 // dist/lib/deck.js
 var import_core17 = require("@luma.gl/core");
 var import_webgl = require("@luma.gl/webgl");
-var import_constants11 = require("@luma.gl/webgl/constants");
+var import_constants10 = require("@luma.gl/webgl/constants");
 var import_engine3 = require("@luma.gl/engine");
 var import_engine4 = require("@luma.gl/engine");
 var import_stats2 = require("@probe.gl/stats");
@@ -9027,10 +9066,14 @@ var Attribute = class extends DataColumn {
       }
       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) {
@@ -9050,17 +9093,13 @@ var Attribute = class extends DataColumn {
   // 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();
@@ -9068,6 +9107,41 @@ var Attribute = class extends DataColumn {
     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
@@ -9164,18 +9238,10 @@ var Attribute = class extends DataColumn {
   }
   /* eslint-disable max-depth, max-statements */
   _autoUpdater(attribute, { data, startRow, endRow, 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];
-    }
     assert(typeof accessorFunc === "function", `accessor "${accessor}" is not a function`);
     let i = attribute.getVertexOffset(startRow);
     const { iterable, objectInfo } = createIterable(data, startRow, endRow);
@@ -9250,7 +9316,7 @@ var Attribute = class extends DataColumn {
 // dist/transitions/gpu-interpolation-transition.js
 var import_engine5 = require("@luma.gl/engine");
 var import_shadertools5 = require("@luma.gl/shadertools");
-var import_constants14 = require("@luma.gl/webgl/constants");
+var import_constants13 = require("@luma.gl/webgl/constants");
 
 // dist/utils/array-utils.js
 function padArrayChunk(options) {
@@ -9317,7 +9383,7 @@ function padArray({ source: source3, target, size, getData, sourceStartIndices,
 }
 
 // dist/transitions/gpu-transition-utils.js
-var import_constants13 = require("@luma.gl/webgl/constants");
+var import_constants12 = require("@luma.gl/webgl/constants");
 function cloneAttribute(attribute) {
   const { device, settings, value } = attribute;
   const newAttribute = new Attribute(device, settings);
@@ -11242,7 +11308,7 @@ var defaultProps2 = {
   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,
@@ -11385,7 +11451,7 @@ var Layer = class extends component_default {
   }
   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) {
@@ -11767,7 +11833,6 @@ var Layer = class extends component_default {
   /* (Internal) Called by layer manager when a new layer is found */
   _initialize() {
     assert(!this.internalState);
-    assert(Number.isFinite(this.props.coordinateSystem));
     debug(TRACE_INITIALIZE, this);
     const attributeManager = this._getAttributeManager();
     if (attributeManager) {