@deck.gl/core 9.3.0-alpha.3 → 9.3.0-alpha.5

package/src/passes/pick-layers-pass.ts

@@ -148,8 +148,12 @@ export default class PickLayersPass extends LayersPass {
       // Encode pickable layers that include 'draw' operation (including 'terrain+draw')
       Object.assign(pickParameters, PICKING_BLENDING);
       pickParameters.blend = true;
-      // TODO: blendColor no longer part of luma.gl API
-      pickParameters.blendColor = encodeColor(this._colorEncoderState, layer, viewport);
+      if (this.device.type === 'webgpu') {
+        // WebGPU uses render-pass dynamic state for constant blending.
+        pickParameters.blendConstant = encodeColor(this._colorEncoderState, layer, viewport);
+      } else {
+        pickParameters.blendColor = encodeColor(this._colorEncoderState, layer, viewport);
+      }
       if (operation.includes('terrain') && layer.state?._hasPickingCover) {
         // For terrain+draw layers with a valid cover FBO, the terrain shader outputs the
         // cover FBO pixel which already has correctly encoded alpha from the cover encoder.

package/src/passes/screen-pass-uniforms.ts

@@ -6,7 +6,7 @@ import type {TextureView} from '@luma.gl/core';
 import type {ShaderModule} from '@luma.gl/shadertools';
 
 const uniformBlock = `\
-uniform screenUniforms {
+layout(std140) uniform screenUniforms {
   vec2 texSize;
 } screen;
 `;

package/src/shaderlib/color/color.ts

@@ -7,15 +7,6 @@ import {LayerProps} from '../../types/layer-props';
 
 const colorWGSL = /* WGSL */ `
 
-struct ColorUniforms {
-  opacity: f32,
-};
-
-var<private> color: ColorUniforms = ColorUniforms(1.0);
-// TODO (kaapp) avoiding binding index collisions to handle layer opacity 
-// requires some thought.
-// @group(0) @binding(0) var<uniform> color: ColorUniforms;
-
 @must_use
 fn deckgl_premultiplied_alpha(fragColor: vec4<f32>) -> vec4<f32> {
     return vec4(fragColor.rgb * fragColor.a, fragColor.a); 
@@ -43,9 +34,6 @@ export default {
     // TODO - v10: use raw opacity?
     // opacity: Math.pow(props.opacity!, 1 / 2.2)
     return {};
-  },
-  uniformTypes: {
-    opacity: 'f32'
   }
   // @ts-ignore TODO v9.1
 } as const satisfies ShaderModule<LayerProps, ColorUniforms, {}>;

package/src/shaderlib/misc/layer-uniforms.ts

@@ -5,8 +5,17 @@
 import type {ShaderModule} from '@luma.gl/shadertools';
 import type {LayerProps} from '../../types/layer-props';
 
+const uniformBlockWGSL = /* wgsl */ `\
+struct LayerUniforms {
+  opacity: f32,
+};
+
+@group(0) @binding(auto)
+var<uniform> layer: LayerUniforms;
+`;
+
 const uniformBlock = `\
-uniform layerUniforms {
+layout(std140) uniform layerUniforms {
   uniform float opacity;
 } layer;
 `;
@@ -17,6 +26,7 @@ export type LayerUniforms = {
 
 export const layerUniforms = {
   name: 'layer',
+  source: uniformBlockWGSL,
   vs: uniformBlock,
   fs: uniformBlock,
   getUniforms: (props: Partial<LayerProps>) => {

package/src/shaderlib/picking/picking.ts

@@ -4,8 +4,38 @@
 
 import {picking} from '@luma.gl/shadertools';
 
+const sourceWGSL = /* wgsl */ `\
+struct pickingUniforms {
+  isActive: f32,
+  isAttribute: f32,
+  isHighlightActive: f32,
+  useFloatColors: f32,
+  highlightedObjectColor: vec3<f32>,
+  highlightColor: vec4<f32>,
+};
+
+@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);
+}
+
+fn picking_normalizeColor4(color: vec4<f32>) -> vec4<f32> {
+  return select(color / 255.0, color, picking.useFloatColors > 0.5);
+}
+
+fn picking_isColorZero(color: vec3<f32>) -> bool {
+  return dot(color, vec3<f32>(1.0)) < 0.00001;
+}
+
+fn picking_isColorValid(color: vec3<f32>) -> bool {
+  return dot(color, vec3<f32>(1.0)) > 0.00001;
+}
+`;
+
 export default {
   ...picking,
+  source: sourceWGSL,
   defaultUniforms: {...picking.defaultUniforms, useFloatColors: false},
   inject: {
     'vs:DECKGL_FILTER_GL_POSITION': `

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

@@ -20,7 +20,7 @@ ${COORDINATE_SYSTEM_GLSL_CONSTANTS}
 ${PROJECTION_MODE_GLSL_CONSTANTS}
 ${UNIT_GLSL_CONSTANTS}
 
-uniform projectUniforms {
+layout(std140) uniform projectUniforms {
   bool wrapLongitude;
   int coordinateSystem;
   vec3 commonUnitsPerMeter;

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

@@ -50,14 +50,13 @@ struct ProjectUniforms {
   pseudoMeters: i32,
 };
 
-@group(0) @binding(0)
+@group(0) @binding(auto)
 var<uniform> project: ProjectUniforms;
 
 // -----------------------------------------------------------------------------
-// Geometry data
-// (In your GLSL code, "geometry" was assumed to be available globally. In WGSL,
-// you might supply this via vertex attributes or a uniform. Here we define a
-// uniform struct for demonstration.)
+// Geometry data shared across the project helpers.
+// The active layer shader is responsible for populating this private module
+// state before calling the project functions below.
 // -----------------------------------------------------------------------------
 
 // Structure to carry additional geometry data used by deck.gl filters.
@@ -70,7 +69,6 @@ struct Geometry {
   pickingColor: vec3<f32>,
 };
 
-// @group(0) @binding(1)
 var<private> geometry: Geometry;
 `;
 

package/src/shaderlib/shadow/shadow.ts

@@ -15,7 +15,7 @@ import type Viewport from '../../viewports/viewport';
 import type {ProjectProps, ProjectUniforms} from '../project/viewport-uniforms';
 
 const uniformBlock = /* glsl */ `
-uniform shadowUniforms {
+layout(std140) uniform shadowUniforms {
   bool drawShadowMap;
   bool useShadowMap;
   vec4 color;

package/src/transitions/gpu-interpolation-transition.ts

@@ -6,7 +6,7 @@ import type {Device} from '@luma.gl/core';
 import {Timeline, BufferTransform} from '@luma.gl/engine';
 import {fp64arithmetic} from '@luma.gl/shadertools';
 import type {ShaderModule} from '@luma.gl/shadertools';
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 import Attribute from '../lib/attribute/attribute';
 import {
   getAttributeTypeFromSize,
@@ -112,7 +112,7 @@ export default class GPUInterpolationTransition extends GPUTransitionBase<Interp
 }
 
 const uniformBlock = `\
-uniform interpolationUniforms {
+layout(std140) uniform interpolationUniforms {
   float time;
 } interpolation;
 `;

package/src/transitions/gpu-spring-transition.ts

@@ -116,7 +116,7 @@ export default class GPUSpringTransition extends GPUTransitionBase<SpringTransit
 }
 
 const uniformBlock = `\
-uniform springUniforms {
+layout(std140) uniform springUniforms {
   float damping;
   float stiffness;
 } spring;

package/src/transitions/gpu-transition-utils.ts

@@ -6,7 +6,7 @@ import type {Device, Buffer, VertexFormat} from '@luma.gl/core';
 import {padArray} from '../utils/array-utils';
 import {NumericArray, TypedArray, TypedArrayConstructor} from '../types/types';
 import Attribute from '../lib/attribute/attribute';
-import {GL} from '@luma.gl/constants';
+import {GL} from '@luma.gl/webgl/constants';
 
 /** Create a new empty attribute with the same settings: type, shader layout etc. */
 export function cloneAttribute(attribute: Attribute): Attribute {
@@ -150,9 +150,8 @@ export function padBuffer({
     ? (attribute.value as TypedArray)
     : // TODO(v9.1): Avoid non-portable synchronous reads.
       new ArrayType(
-        attribute
-          .getBuffer()!
-          .readSyncWebGL(byteOffset, toLength * ArrayType.BYTES_PER_ELEMENT).buffer
+        attribute.getBuffer()!.readSyncWebGL(byteOffset, toLength * ArrayType.BYTES_PER_ELEMENT)
+          .buffer as ArrayBuffer
       );
   if (attribute.settings.normalized && !isConstant) {
     const getter = getData;
@@ -166,7 +165,7 @@ export function padBuffer({
 
   // TODO(v9.1): Avoid non-portable synchronous reads.
   const source = buffer
-    ? new Float32Array(buffer.readSyncWebGL(targetByteOffset, fromLength * 4).buffer)
+    ? new Float32Array(buffer.readSyncWebGL(targetByteOffset, fromLength * 4).buffer as ArrayBuffer)
     : new Float32Array(0);
   const target = new Float32Array(toLength);
   padArray({

package/src/utils/typed-array-manager.ts

@@ -52,7 +52,7 @@ export class TypedArrayManager {
         return typedArray;
       }
       if (newSize * typedArray.BYTES_PER_ELEMENT <= typedArray.buffer.byteLength) {
-        return new Type(typedArray.buffer, 0, newSize) as T;
+        return new Type(typedArray.buffer as ArrayBuffer, 0, newSize) as T;
       }
     }
 
@@ -119,9 +119,9 @@ export class TypedArrayManager {
     const {byteLength} = buffer;
     const i = pool.findIndex(b => b.byteLength >= byteLength);
     if (i < 0) {
-      pool.push(buffer);
+      pool.push(buffer as ArrayBuffer);
     } else if (i > 0 || pool.length < this.opts.poolSize) {
-      pool.splice(i, 0, buffer);
+      pool.splice(i, 0, buffer as ArrayBuffer);
     }
     if (pool.length > this.opts.poolSize) {
       // Drop the smallest one