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

package/package.json

@@ -3,7 +3,7 @@
   "description": "deck.gl core library",
   "license": "MIT",
   "type": "module",
-  "version": "9.3.0-alpha.5",
+  "version": "9.3.0-beta.1",
   "publishConfig": {
     "access": "public"
   },
@@ -40,12 +40,12 @@
     "prepublishOnly": "npm run build-debugger && npm run build-bundle && npm run build-bundle -- --env=dev"
   },
   "dependencies": {
-    "@loaders.gl/core": "^4.4.0-alpha.18",
-    "@loaders.gl/images": "^4.4.0-alpha.18",
-    "@luma.gl/core": "^9.3.0-alpha.10",
-    "@luma.gl/engine": "^9.3.0-alpha.10",
-    "@luma.gl/shadertools": "^9.3.0-alpha.10",
-    "@luma.gl/webgl": "^9.3.0-alpha.10",
+    "@loaders.gl/core": "^4.4.1",
+    "@loaders.gl/images": "^4.4.1",
+    "@luma.gl/core": "^9.3.2",
+    "@luma.gl/engine": "^9.3.2",
+    "@luma.gl/shadertools": "^9.3.2",
+    "@luma.gl/webgl": "^9.3.2",
     "@math.gl/core": "^4.1.0",
     "@math.gl/sun": "^4.1.0",
     "@math.gl/types": "^4.1.0",
@@ -57,5 +57,5 @@
     "gl-matrix": "^3.0.0",
     "mjolnir.js": "^3.0.0"
   },
-  "gitHead": "c3ad1cee357af674cc31df37979d61325baf9d7a"
+  "gitHead": "a8b482631c7b10460411b08c8c674b86176ec191"
 }

package/src/lib/attribute/attribute.ts

@@ -222,10 +222,16 @@ export default class Attribute extends DataColumn<AttributeOptions, AttributeInt
         !this.buffer ||
         this.buffer.byteLength < (this.value as TypedArray).byteLength + this.byteOffset
       ) {
-        this.setData({
-          value: this.value,
-          constant: this.constant
-        });
+        if (this.constant) {
+          // Route constant updater output through the same path used by constant accessors
+          // so WebGPU can materialize a real buffer while WebGL keeps a constant attribute.
+          this.setConstantValue(context, this.value);
+        } else {
+          this.setData({
+            value: this.value,
+            constant: this.constant
+          });
+        }
         // Setting attribute.constant in updater is a legacy approach that interferes with allocation in the next cycle
         // Respect it here but reset after use
         this.constant = false;
@@ -255,23 +261,20 @@ export default class Attribute extends DataColumn<AttributeOptions, AttributeInt
   // Use generic value
   // Returns true if successful
   setConstantValue(context: any, value?: any): boolean {
-    // TODO(ibgreen): WebGPU does not support constant values,
-    // they will be emulated as buffers instead for now.
-    const isWebGPU = this.device.type === 'webgpu';
-    if (isWebGPU || value === undefined || typeof value === 'function') {
-      if (isWebGPU && typeof value !== 'function') {
-        const normalisedValue = this._normalizeValue(value, [], 0);
-        // ensure we trigger an update for the attribute's emulated buffer
-        // where webgl would perform the update here
-        if (!this._areValuesEqual(normalisedValue, this.value)) {
-          this.setNeedsUpdate('WebGPU constant updated');
-        }
-      }
+    if (value === undefined || typeof value === 'function') {
       return false;
     }
 
     const transformedValue =
       this.settings.transform && context ? this.settings.transform.call(context, value) : value;
+
+    if (this.device.type === 'webgpu') {
+      // WebGPU has no equivalent of WebGL constant vertex attributes, so we expand the
+      // constant into a full per-instance buffer before passing it to luma.gl.
+      return this.setConstantBufferValue(transformedValue, this.numInstances);
+    }
+
+    // WebGL can bind the normalized/transformed value directly as a constant attribute.
     const hasChanged = this.setData({constant: true, value: transformedValue});
 
     if (hasChanged) {
@@ -281,6 +284,56 @@ export default class Attribute extends DataColumn<AttributeOptions, AttributeInt
     return true;
   }
 
+  setConstantBufferValue(value: any, numInstances: number): boolean {
+    const ArrayType = this.settings.defaultType;
+    const constantValue = this._normalizeValue(value, new ArrayType(this.size), 0) as TypedArray;
+    if (this._hasConstantBufferValue(constantValue, numInstances)) {
+      // The emulated buffer already matches this constant, so avoid a redundant upload.
+      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;
+  }
+
+  private _hasConstantBufferValue(value: NumericArray, numInstances: number): boolean {
+    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
@@ -432,23 +485,13 @@ export default class Attribute extends DataColumn<AttributeOptions, AttributeInt
       numInstances: number;
     }
   ): void {
-    if (attribute.constant) {
-      // @ts-ignore TODO(ibgreen) declare context?
-      if (this.context.device.type !== 'webgpu') {
-        return;
-      }
-    }
     const {settings, state, value, size, startIndices} = attribute;
 
     const {accessor, transform} = settings;
-    let accessorFunc: Accessor<any, any> =
+    const accessorFunc: Accessor<any, any> =
       state.binaryAccessor ||
       // @ts-ignore
       (typeof accessor === 'function' ? accessor : props[accessor]);
-    // TODO(ibgreen) WebGPU needs buffers, generate an accessor function from a constant
-    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);

package/src/lib/constants.ts

@@ -2,9 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-// Note: The numeric values here are matched by shader code in the
-// "project" and "project64" shader modules. Both places need to be
-// updated.
 import log from '../utils/log';
 import {Pan, InputDirection, Pinch, Tap} from 'mjolnir.js';
 import type {PanRecognizerOptions, PinchRecognizerOptions, TapRecognizerOptions} from 'mjolnir.js';
@@ -12,46 +9,55 @@ import type {PanRecognizerOptions, PinchRecognizerOptions, TapRecognizerOptions}
 /**
  * The coordinate system that positions/dimensions are defined in.
  */
+export type CoordinateSystem =
+  | 'default'
+  | 'lnglat'
+  | 'meter-offsets'
+  | 'lnglat-offsets'
+  | 'cartesian';
+
+/**
+ * The coordinate system that positions/dimensions are defined in.
+ * String constants are the public API.
+ * @deprecated Use string constants directly.
+ */
 export const 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'
 } as const;
 
-// Enums cannot be directly exported as they are not transpiled correctly into ES5, see https://github.com/visgl/deck.gl/issues/7130
-export type CoordinateSystem = -1 | 0 | 1 | 2 | 3;
-
 // Deprecated
 /* eslint-disable accessor-pairs */
 Object.defineProperty(COORDINATE_SYSTEM, 'IDENTITY', {
   get: () => {
     log.deprecated('COORDINATE_SYSTEM.IDENTITY', 'COORDINATE_SYSTEM.CARTESIAN')();
-    return 0;
+    return COORDINATE_SYSTEM.CARTESIAN;
   }
 });
 /* eslint-enable accessor-pairs */

package/src/lib/deck.ts

@@ -18,9 +18,9 @@ import {VERSION} from './init';
 
 import {luma} from '@luma.gl/core';
 import {webgl2Adapter} from '@luma.gl/webgl';
+import {GL} from '@luma.gl/webgl/constants';
 import {Timeline} from '@luma.gl/engine';
 import {AnimationLoop} from '@luma.gl/engine';
-import {GL} from '@luma.gl/webgl/constants';
 import type {CanvasContextProps, Device, DeviceProps, Framebuffer, Parameters} from '@luma.gl/core';
 import type {ShaderModule} from '@luma.gl/shadertools';
 

package/src/lib/layer.ts

@@ -5,7 +5,6 @@
 /* eslint-disable react/no-direct-mutation-state */
 import {Buffer, Parameters as LumaParameters, TypedArray} from '@luma.gl/core';
 import {WebGLDevice} from '@luma.gl/webgl';
-import {COORDINATE_SYSTEM} from './constants';
 import AttributeManager from './attribute/attribute-manager';
 import UniformTransitionManager from './uniform-transition-manager';
 import {diffProps, validateProps} from '../lifecycle/props';
@@ -138,7 +137,7 @@ const defaultProps: DefaultProps<LayerProps> = {
   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,
@@ -358,9 +357,9 @@ export default abstract class Layer<PropsT extends {} = {}> extends Component<
   use64bitPositions(): boolean {
     const {coordinateSystem} = this.props;
     return (
-      coordinateSystem === COORDINATE_SYSTEM.DEFAULT ||
-      coordinateSystem === COORDINATE_SYSTEM.LNGLAT ||
-      coordinateSystem === COORDINATE_SYSTEM.CARTESIAN
+      coordinateSystem === 'default' ||
+      coordinateSystem === 'lnglat' ||
+      coordinateSystem === 'cartesian'
     );
   }
 
@@ -869,7 +868,6 @@ export default abstract class Layer<PropsT extends {} = {}> extends Component<
   /* (Internal) Called by layer manager when a new layer is found */
   _initialize() {
     assert(!this.internalState); // finalized layer cannot be reused
-    assert(Number.isFinite(this.props.coordinateSystem)); // invalid coordinateSystem
 
     debug(TRACE_INITIALIZE, this);
 

package/src/passes/layers-pass.ts

@@ -2,7 +2,12 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Device, Parameters, RenderPassParameters} from '@luma.gl/core';
+import type {
+  Device,
+  Parameters,
+  RenderPassParameters,
+  RenderPipelineParameters
+} from '@luma.gl/core';
 import type {Framebuffer, RenderPass} from '@luma.gl/core';
 import type {NumberArray4} from '@math.gl/core';
 
@@ -16,6 +21,18 @@ import type {PickingProps} from '@luma.gl/shadertools';
 
 export type Rect = {x: number; y: number; width: number; height: number};
 
+// WebGPU complication: Matching attachment state of the renderpass requires including a depth buffer
+const WEBGPU_DEFAULT_DRAW_PARAMETERS: RenderPipelineParameters = {
+  depthWriteEnabled: true,
+  depthCompare: 'less-equal',
+  blendColorOperation: 'add',
+  blendColorSrcFactor: 'src-alpha',
+  blendColorDstFactor: 'one',
+  blendAlphaOperation: 'add',
+  blendAlphaSrcFactor: 'one-minus-dst-alpha',
+  blendAlphaDstFactor: 'one'
+};
+
 export type LayersPassRenderOptions = {
   /** @deprecated TODO v9 recommend we rename this to framebuffer to minimize confusion */
   target?: Framebuffer | null;
@@ -206,7 +223,10 @@ export default class LayersPass extends Pass {
           pass,
           shaderModuleProps
         );
+        const defaultParams =
+          layer.context.device.type === 'webgpu' ? WEBGPU_DEFAULT_DRAW_PARAMETERS : null;
         layerParam.layerParameters = {
+          ...defaultParams,
           ...layer.context.deck?.props.parameters,
           ...this.getLayerParameters(layer, layerIndex, viewport)
         };

package/src/shaderlib/index.ts

@@ -2,9 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {ShaderAssembler} from '@luma.gl/shadertools';
-
-import {gouraudMaterial, phongMaterial} from '@luma.gl/shadertools';
+import {ShaderAssembler, gouraudMaterial, phongMaterial} from '@luma.gl/shadertools';
 import {layerUniforms} from './misc/layer-uniforms';
 import color from './color/color';
 import geometry from './misc/geometry';

package/src/shaderlib/picking/picking.ts

@@ -9,7 +9,7 @@ struct pickingUniforms {
   isActive: f32,
   isAttribute: f32,
   isHighlightActive: f32,
-  useFloatColors: f32,
+  useByteColors: f32,
   highlightedObjectColor: vec3<f32>,
   highlightColor: vec4<f32>,
 };
@@ -17,11 +17,11 @@ struct pickingUniforms {
 @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 {
@@ -36,7 +36,7 @@ fn picking_isColorValid(color: vec3<f32>) -> bool {
 export default {
   ...picking,
   source: sourceWGSL,
-  defaultUniforms: {...picking.defaultUniforms, useFloatColors: false},
+  defaultUniforms: {...picking.defaultUniforms, useByteColors: true},
   inject: {
     'vs:DECKGL_FILTER_GL_POSITION': `
     // for picking depth values

package/src/shaderlib/project/project-functions.ts

@@ -6,7 +6,6 @@
  * Projection utils
  * TODO: move to Viewport class?
  */
-import {COORDINATE_SYSTEM} from '../../lib/constants';
 import {getOffsetOrigin} from './viewport-uniforms';
 import WebMercatorViewport from '../../viewports/web-mercator-viewport';
 
@@ -56,14 +55,14 @@ 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 === undefined) {
     fromCoordinateSystem = coordinateSystem;
+  } else if (fromCoordinateSystem === 'default') {
+    fromCoordinateSystem = viewport.isGeospatial ? 'lnglat' : 'cartesian';
   }
   if (fromCoordinateOrigin === undefined) {
     fromCoordinateOrigin = coordinateOrigin;
@@ -103,28 +102,39 @@ export function getWorldPosition(
   }
 
   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]) as [number, number, number],
         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}`);
   }
 }
 

package/src/shaderlib/project/project.glsl.ts

@@ -2,12 +2,21 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {COORDINATE_SYSTEM, PROJECTION_MODE, UNIT} from '../../lib/constants';
-
-// We are generating these from the js code in constants.js
-const COORDINATE_SYSTEM_GLSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM)
-  .map(key => `const int COORDINATE_SYSTEM_${key} = ${COORDINATE_SYSTEM[key]};`)
-  .join('');
+import {PROJECTION_MODE, UNIT} from '../../lib/constants';
+import {getShaderCoordinateSystem} from './viewport-uniforms';
+
+const SHADER_COORDINATE_SYSTEMS = [
+  'default',
+  'lnglat',
+  'meter-offsets',
+  'lnglat-offsets',
+  'cartesian'
+] as const;
+
+const COORDINATE_SYSTEM_GLSL_CONSTANTS = SHADER_COORDINATE_SYSTEMS.map(
+  coordinateSystem =>
+    `const int COORDINATE_SYSTEM_${coordinateSystem.toUpperCase().replaceAll('-', '_')} = ${getShaderCoordinateSystem(coordinateSystem)};`
+).join('');
 const PROJECTION_MODE_GLSL_CONSTANTS = Object.keys(PROJECTION_MODE)
   .map(key => `const int PROJECTION_MODE_${key} = ${PROJECTION_MODE[key]};`)
   .join('');

package/src/shaderlib/project/project.wgsl.ts

@@ -2,12 +2,21 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {COORDINATE_SYSTEM, PROJECTION_MODE, UNIT} from '../../lib/constants';
-
-// We are generating these from the js code in constants.js
-const COORDINATE_SYSTEM_WGSL_CONSTANTS = Object.keys(COORDINATE_SYSTEM)
-  .map(key => `const COORDINATE_SYSTEM_${key}: i32 = ${COORDINATE_SYSTEM[key]};`)
-  .join('');
+import {PROJECTION_MODE, UNIT} from '../../lib/constants';
+import {getShaderCoordinateSystem} from './viewport-uniforms';
+
+const SHADER_COORDINATE_SYSTEMS = [
+  'default',
+  'lnglat',
+  'meter-offsets',
+  'lnglat-offsets',
+  'cartesian'
+] as const;
+
+const COORDINATE_SYSTEM_WGSL_CONSTANTS = SHADER_COORDINATE_SYSTEMS.map(
+  coordinateSystem =>
+    `const COORDINATE_SYSTEM_${coordinateSystem.toUpperCase().replaceAll('-', '_')}: i32 = ${getShaderCoordinateSystem(coordinateSystem)};`
+).join('');
 const PROJECTION_MODE_WGSL_CONSTANTS = Object.keys(PROJECTION_MODE)
   .map(key => `const PROJECTION_MODE_${key}: i32 = ${PROJECTION_MODE[key]};`)
   .join('');

package/src/shaderlib/project/viewport-uniforms.ts

@@ -6,7 +6,7 @@
 
 import {mat4, Matrix4Like, vec4} from '@math.gl/core';
 
-import {COORDINATE_SYSTEM, PROJECTION_MODE} from '../../lib/constants';
+import {PROJECTION_MODE} from '../../lib/constants';
 
 import memoize from '../../utils/memoize';
 
@@ -24,6 +24,23 @@ const IDENTITY_MATRIX: Matrix4Like = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0,
 const DEFAULT_PIXELS_PER_UNIT2: Vec3 = [0, 0, 0];
 const DEFAULT_COORDINATE_ORIGIN: Vec3 = [0, 0, 0];
 
+/** Coordinate system constants */
+const COORDINATE_SYSTEM_NUMBERS = {
+  default: -1,
+  cartesian: 0,
+  lnglat: 1,
+  'meter-offsets': 2,
+  'lnglat-offsets': 3
+} as const satisfies Record<CoordinateSystem, -1 | 0 | 1 | 2 | 3>;
+
+export function getShaderCoordinateSystem(coordinateSystem: CoordinateSystem) {
+  const shaderCoordinateSystem = COORDINATE_SYSTEM_NUMBERS[coordinateSystem];
+  if (shaderCoordinateSystem === undefined) {
+    throw new Error(`Invalid coordinateSystem: ${coordinateSystem}`);
+  }
+  return shaderCoordinateSystem;
+}
+
 const getMemoizedViewportUniforms = memoize(calculateViewportUniforms);
 
 export function getOffsetOrigin(
@@ -43,10 +60,7 @@ export function getOffsetOrigin(
   let geospatialOrigin: Vec3 | null;
   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
@@ -57,21 +71,18 @@ export function getOffsetOrigin(
 
   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') {
         // viewport center in world space
         // @ts-expect-error when using LNGLAT coordinates, we expect the viewport to be geospatial, in which case geospatialOrigin is defined
         shaderCoordinateOrigin = geospatialOrigin;
-      } else if (coordinateSystem === COORDINATE_SYSTEM.CARTESIAN) {
+      } else if (coordinateSystem === 'cartesian') {
         // viewport center in common space
         shaderCoordinateOrigin = [
           Math.fround(viewport.center[0]),
@@ -223,14 +234,12 @@ export function getUniformsFromViewport({
   devicePixelRatio = 1,
   modelMatrix = null,
   // Match Layer.defaultProps
-  coordinateSystem = COORDINATE_SYSTEM.DEFAULT,
+  coordinateSystem = 'default',
   coordinateOrigin = DEFAULT_COORDINATE_ORIGIN,
   autoWrapLongitude = false
 }: ProjectProps): ProjectUniforms {
-  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({
@@ -283,7 +292,7 @@ function calculateViewportUniforms({
 
   const uniforms: ProjectUniforms = {
     // Projection mode values
-    coordinateSystem,
+    coordinateSystem: getShaderCoordinateSystem(coordinateSystem),
     projectionMode: viewport.projectionMode,
     coordinateOrigin: shaderCoordinateOrigin,
     commonOrigin: originCommon.slice(0, 3) as Vec3,
@@ -324,13 +333,13 @@ function calculateViewportUniforms({
       unitsPerDegree2: Vec3;
     };
     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':
         // @ts-expect-error _pseudoMeters only exists on WebMercatorView
         if (!viewport._pseudoMeters) {
           uniforms.commonUnitsPerMeter = distanceScalesAtOrigin.unitsPerMeter;
@@ -340,7 +349,7 @@ function calculateViewportUniforms({
         break;
 
       // a.k.a "preprojected" positions
-      case COORDINATE_SYSTEM.CARTESIAN:
+      case 'cartesian':
         uniforms.commonUnitsPerWorldUnit = [1, 1, distanceScalesAtOrigin.unitsPerMeter[2]];
         uniforms.commonUnitsPerWorldUnit2 = [0, 0, distanceScalesAtOrigin.unitsPerMeter2[2]];
         break;

package/src/shaderlib/shadow/shadow.ts

@@ -12,7 +12,11 @@ import {pixelsToWorld} from '@math.gl/web-mercator';
 import type {Texture} from '@luma.gl/core';
 import {ShaderModule} from '@luma.gl/shadertools';
 import type Viewport from '../../viewports/viewport';
-import type {ProjectProps, ProjectUniforms} from '../project/viewport-uniforms';
+import {
+  ProjectProps,
+  ProjectUniforms,
+  getShaderCoordinateSystem
+} from '../project/viewport-uniforms';
 
 const uniformBlock = /* glsl */ `
 layout(std140) uniform shadowUniforms {
@@ -236,7 +240,7 @@ function createShadowUniforms(
       .translate(new Vector3(projectProps.viewport.center).negate());
 
     if (
-      projectUniforms.coordinateSystem === COORDINATE_SYSTEM.LNGLAT &&
+      projectUniforms.coordinateSystem === getShaderCoordinateSystem('lnglat') &&
       projectUniforms.projectionMode === PROJECTION_MODE.WEB_MERCATOR
     ) {
       viewProjectionMatrices[i] = viewProjectionMatrixCentered;

package/src/utils/texture.ts

@@ -59,6 +59,8 @@ export function createTexture(
   });
   if (device.type === 'webgl') {
     texture.generateMipmapsWebGL();
+  } else if (device.type === 'webgpu') {
+    device.generateMipmapsWebGPU(texture);
   }
 
   // Track this texture