@luma.gl/engine 9.2.6 → 9.3.0-alpha.10

package/dist/modules/picking/color-picking.js

@@ -1,144 +1,178 @@
 // luma.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { pickingUniforms, GLSL_UNIFORMS, WGSL_UNIFORMS } from "./picking-uniforms.js";
+import { pickingUniforms, GLSL_UNIFORMS, WGSL_UNIFORMS, INVALID_INDEX } from "./picking-uniforms.js";
 const source = /* wgsl */ `\
 ${WGSL_UNIFORMS}
-`;
-const vs = /* glsl */ `\
-${GLSL_UNIFORMS}
-out vec4 picking_vRGBcolor_Avalid;
 
-// Normalize unsigned byte color to 0-1 range
-vec3 picking_normalizeColor(vec3 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
-}
+const COLOR_PICKING_INVALID_INDEX = ${INVALID_INDEX};
+const COLOR_PICKING_MAX_OBJECT_INDEX = 16777214;
+const COLOR_PICKING_MAX_BATCH_INDEX = 254;
 
-// Normalize unsigned byte color to 0-1 range
-vec4 picking_normalizeColor(vec4 color) {
-  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+fn picking_setObjectIndex(objectIndex: i32) -> i32 {
+  return objectIndex;
 }
 
-bool picking_isColorZero(vec3 color) {
-  return dot(color, vec3(1.0)) < 0.00001;
+fn picking_isObjectHighlighted(objectIndex: i32) -> bool {
+  return
+    picking.isHighlightActive != 0 &&
+    picking.highlightedBatchIndex == picking.batchIndex &&
+    picking.highlightedObjectIndex == objectIndex;
 }
 
-bool picking_isColorValid(vec3 color) {
-  return dot(color, vec3(1.0)) > 0.00001;
+fn picking_filterHighlightColor(color: vec4<f32>, objectIndex: i32) -> vec4<f32> {
+  if (picking.isActive != 0 || !picking_isObjectHighlighted(objectIndex)) {
+    return color;
+  }
+
+  let highLightAlpha = picking.highlightColor.a;
+  let blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
+  if (blendedAlpha == 0.0) {
+    return vec4<f32>(color.rgb, 0.0);
+  }
+
+  let highLightRatio = highLightAlpha / blendedAlpha;
+  let blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
+  return vec4<f32>(blendedRGB, blendedAlpha);
 }
 
-// Check if this vertex is highlighted 
-bool isVertexHighlighted(vec3 vertexColor) {
-  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+fn picking_canEncodePickInfo(objectIndex: i32) -> bool {
   return
-    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));
+    objectIndex != COLOR_PICKING_INVALID_INDEX &&
+    objectIndex >= 0 &&
+    objectIndex <= COLOR_PICKING_MAX_OBJECT_INDEX &&
+    picking.batchIndex >= 0 &&
+    picking.batchIndex <= COLOR_PICKING_MAX_BATCH_INDEX;
 }
 
-// Set the current picking color
-void picking_setPickingColor(vec3 pickingColor) {
-  pickingColor = picking_normalizeColor(pickingColor);
-
-  if (bool(picking.isActive)) {
-    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable
-    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));
-
-    if (!bool(picking.isAttribute)) {
-      // Stores the picking color so that the fragment shader can render it during picking
-      picking_vRGBcolor_Avalid.rgb = pickingColor;
-    }
-  } else {
-    // Do the comparison with selected item color in vertex shader as it should mean fewer compares
-    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));
+fn picking_getPickingColor(objectIndex: i32) -> vec4<f32> {
+  if (!picking_canEncodePickInfo(objectIndex)) {
+    return vec4<f32>(0.0, 0.0, 0.0, 0.0);
   }
+
+  let encodedObjectIndex = objectIndex + 1;
+  let red = encodedObjectIndex % 256;
+  let green = (encodedObjectIndex / 256) % 256;
+  let blue = (encodedObjectIndex / 65536) % 256;
+  let alpha = picking.batchIndex + 1;
+
+  return vec4<f32>(
+    f32(red) / 255.0,
+    f32(green) / 255.0,
+    f32(blue) / 255.0,
+    f32(alpha) / 255.0
+  );
 }
 
-void picking_setObjectIndex(uint objectIndex) {
-  if (bool(picking.isActive)) {
-    uint index = objectIndex;
-    if (picking.indexMode == PICKING_INDEX_MODE_INSTANCE) {
-      index = uint(gl_InstanceID);
+fn picking_filterPickingColor(color: vec4<f32>, objectIndex: i32) -> vec4<f32> {
+  if (picking.isActive != 0) {
+    if (!picking_canEncodePickInfo(objectIndex)) {
+      discard;
     }
-    picking_vRGBcolor_Avalid.r = float(index % 255) / 255.0;
-    picking_vRGBcolor_Avalid.g = float((index / 255) % 255) / 255.0;
-    picking_vRGBcolor_Avalid.b = float((index / 255 / 255) %255) / 255.0;
+    return picking_getPickingColor(objectIndex);
   }
-}
 
-void picking_setPickingAttribute(float value) {
-  if (bool(picking.isAttribute)) {
-    picking_vRGBcolor_Avalid.r = value;
-  }
+  return color;
 }
+`;
+const vs = /* glsl */ `\
+${GLSL_UNIFORMS}
 
-void picking_setPickingAttribute(vec2 value) {
-  if (bool(picking.isAttribute)) {
-    picking_vRGBcolor_Avalid.rg = value;
-  }
-}
+const int INDEX_PICKING_MODE_INSTANCE = 0;
+const int INDEX_PICKING_MODE_CUSTOM = 1;
+
+const int COLOR_PICKING_INVALID_INDEX = ${INVALID_INDEX};
 
-void picking_setPickingAttribute(vec3 value) {
-  if (bool(picking.isAttribute)) {
-    picking_vRGBcolor_Avalid.rgb = value;
+flat out int picking_objectIndex;
+
+void picking_setObjectIndex(int objectIndex) {
+  switch (picking.indexMode) {
+    case INDEX_PICKING_MODE_INSTANCE:
+      picking_objectIndex = gl_InstanceID;
+      break;
+    case INDEX_PICKING_MODE_CUSTOM:
+      picking_objectIndex = objectIndex;
+      break;
   }
 }
 `;
 const fs = /* glsl */ `\
 ${GLSL_UNIFORMS}
 
-in vec4 picking_vRGBcolor_Avalid;
+const int COLOR_PICKING_INVALID_INDEX = ${INVALID_INDEX};
+const int COLOR_PICKING_MAX_OBJECT_INDEX = 16777214;
+const int COLOR_PICKING_MAX_BATCH_INDEX = 254;
+
+flat in int picking_objectIndex;
+
+bool picking_isFragmentHighlighted() {
+  return
+    bool(picking.isHighlightActive) &&
+    picking.highlightedBatchIndex == picking.batchIndex &&
+    picking.highlightedObjectIndex == picking_objectIndex
+    ;
+}
 
-/*
- * Returns highlight color if this item is selected.
- */
 vec4 picking_filterHighlightColor(vec4 color) {
-  // If we are still picking, we don't highlight
-  if (picking.isActive > 0.5) {
+  if (bool(picking.isActive)) {
     return color;
   }
 
-  bool selected = bool(picking_vRGBcolor_Avalid.a);
+  if (!picking_isFragmentHighlighted()) {
+    return color;
+  }
 
-  if (selected) {
-    // Blend in highlight color based on its alpha value
-    float highLightAlpha = picking.highlightColor.a;
-    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
-    float highLightRatio = highLightAlpha / blendedAlpha;
+  float highLightAlpha = picking.highlightColor.a;
+  float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
+  float highLightRatio = highLightAlpha / blendedAlpha;
 
-    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
-    return vec4(blendedRGB, blendedAlpha);
-  } else {
-    return color;
+  vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
+  return vec4(blendedRGB, blendedAlpha);
+}
+
+bool picking_canEncodePickInfo(int objectIndex) {
+  return
+    objectIndex != COLOR_PICKING_INVALID_INDEX &&
+    objectIndex >= 0 &&
+    objectIndex <= COLOR_PICKING_MAX_OBJECT_INDEX &&
+    picking.batchIndex >= 0 &&
+    picking.batchIndex <= COLOR_PICKING_MAX_BATCH_INDEX;
+}
+
+vec4 picking_getPickingColor() {
+  if (!picking_canEncodePickInfo(picking_objectIndex)) {
+    return vec4(0.0);
   }
+
+  int encodedObjectIndex = picking_objectIndex + 1;
+  int red = encodedObjectIndex % 256;
+  int green = (encodedObjectIndex / 256) % 256;
+  int blue = (encodedObjectIndex / 65536) % 256;
+  int alpha = picking.batchIndex + 1;
+
+  return vec4(float(red), float(green), float(blue), float(alpha)) / 255.0;
 }
 
-/*
- * Returns picking color if picking enabled else unmodified argument.
- */
 vec4 picking_filterPickingColor(vec4 color) {
   if (bool(picking.isActive)) {
-    if (picking_vRGBcolor_Avalid.a == 0.0) {
+    if (!picking_canEncodePickInfo(picking_objectIndex)) {
       discard;
     }
-    return picking_vRGBcolor_Avalid;
+    return picking_getPickingColor();
   }
+
   return color;
 }
 
-/*
- * Returns picking color if picking is enabled if not
- * highlight color if this item is selected, otherwise unmodified argument.
- */
 vec4 picking_filterColor(vec4 color) {
-  vec4 highlightColor = picking_filterHighlightColor(color);
-  return picking_filterPickingColor(highlightColor);
+  vec4 outColor = color;
+  outColor = picking_filterHighlightColor(outColor);
+  outColor = picking_filterPickingColor(outColor);
+  return outColor;
 }
 `;
 /**
- * Provides support for color-coding-based picking and highlighting.
- * In particular, supports picking a specific instance in an instanced
- * draw call and highlighting an instance based on its picking color,
- * and correspondingly, supports picking and highlighting groups of
- * primitives with the same picking color in non-instanced draw-calls
+ * Provides support for object-index based color picking and highlighting.
  */
 export const picking = {
     ...pickingUniforms,
@@ -147,31 +181,4 @@ export const picking = {
     vs,
     fs
 };
-// function getUniforms(opts: PickingProps = {}, prevUniforms?: PickingUniforms): PickingUniforms {
-//   const uniforms = {} as PickingUniforms;
-//   if (opts.highlightedObjectColor === undefined) {
-//     // Unless highlightedObjectColor explicitly null or set, do not update state
-//   } else if (opts.highlightedObjectColor === null) {
-//     uniforms.isHighlightActive = false;
-//   } else {
-//     uniforms.isHighlightActive = true;
-//     const highlightedObjectColor = opts.highlightedObjectColor.slice(0, 3);
-//     uniforms.highlightedObjectColor = highlightedObjectColor;
-//   }
-//   if (opts.highlightColor) {
-//     const color = Array.from(opts.highlightColor, x => x / 255);
-//     if (!Number.isFinite(color[3])) {
-//       color[3] = 1;
-//     }
-//     uniforms.highlightColor = color;
-//   }
-//   if (opts.isActive !== undefined) {
-//     uniforms.isActive = Boolean(opts.isActive);
-//     uniforms.isAttribute = Boolean(opts.isAttribute);
-//   }
-//   if (opts.useFloatColors !== undefined) {
-//     uniforms.useFloatColors = Boolean(opts.useFloatColors);
-//   }
-//   return uniforms;
-// }
 //# sourceMappingURL=color-picking.js.map

package/dist/modules/picking/color-picking.js.map

@@ -1 +1 @@
-{"version":3,"file":"color-picking.js","sourceRoot":"","sources":["../../../src/modules/picking/color-picking.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,eAAe,EAAE,aAAa,EAAE,aAAa,EAAC,8BAA2B;AAEjF,MAAM,MAAM,GAAG,UAAU,CAAC;EACxB,aAAa;CACd,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;EACpB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2Ed,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;EACpB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDd,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,GAAG,eAAe;IAClB,IAAI,EAAE,SAAS;IACf,MAAM;IACN,EAAE;IACF,EAAE;CAC6E,CAAC;AAElF,mGAAmG;AACnG,4CAA4C;AAE5C,qDAAqD;AACrD,mFAAmF;AACnF,uDAAuD;AACvD,0CAA0C;AAC1C,aAAa;AACb,yCAAyC;AACzC,8EAA8E;AAC9E,gEAAgE;AAChE,MAAM;AAEN,+BAA+B;AAC/B,mEAAmE;AACnE,wCAAwC;AACxC,sBAAsB;AACtB,QAAQ;AACR,uCAAuC;AACvC,MAAM;AAEN,uCAAuC;AACvC,kDAAkD;AAClD,wDAAwD;AACxD,MAAM;AAEN,6CAA6C;AAC7C,8DAA8D;AAC9D,MAAM;AAEN,qBAAqB;AACrB,IAAI"}
+{"version":3,"file":"color-picking.js","sourceRoot":"","sources":["../../../src/modules/picking/color-picking.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAC,8BAA2B;AAEhG,MAAM,MAAM,GAAG,UAAU,CAAC;EACxB,aAAa;;sCAEuB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqElD,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;EACpB,aAAa;;;;;0CAK2B,aAAa;;;;;;;;;;;;;;CActD,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;EACpB,aAAa;;0CAE2B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEtD,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,GAAG,eAAe;IAClB,IAAI,EAAE,SAAS;IACf,MAAM;IACN,EAAE;IACF,EAAE;CAC6E,CAAC"}

package/dist/modules/picking/index-picking.d.ts

@@ -12,9 +12,9 @@ import type { PickingProps, PickingUniforms } from "./picking-uniforms.js";
  */
 export declare const picking: {
     readonly name: "picking";
-    readonly source: "struct pickingUniforms {\n  isActive: int32;\n  indexMode: int32;\n  batchIndex: int32;\n\n  isHighlightActive: int32;\n  highlightedBatchIndex: int32;\n  highlightedObjectIndex: int32;\n  highlightColor: vec4<f32>;\n} picking;\n\n\nconst INDEX_PICKING_MODE_INSTANCE = 0;\nconst INDEX_PICKING_MODE_CUSTOM = 1;\nconst INDEX_PICKING_INVALID_INDEX = -1; // 2^32 - 1\n\nstruct indexPickingFragmentInputs = {\n  objectIndex: int32;\n};\n\nlet indexPickingFragmentInputs: indexPickingFragmentInputs;\n\n/**\n * Vertex shaders should call this function to set the object index.\n * If using instance or vertex mode, argument will be ignored, 0 can be supplied.\n */\nfn picking_setObjectIndex(objectIndex: int32) {\n  switch (picking.indexMode) {\n    case INDEX_PICKING_MODE_INSTANCE, default: {\n      picking_objectIndex = instance_index;\n    };\n    case INDEX_PICKING_MODE_CUSTOM: {\n      picking_objectIndex = objectIndex;\n    };\n  }\n}\n\n";
-    readonly vs: "precision highp float;\nprecision highp int;\n\nuniform pickingUniforms {\n  int isActive;\n  int indexMode;\n  int batchIndex;\n\n  int isHighlightActive;\n  int highlightedBatchIndex;\n  int highlightedObjectIndex;\n  vec4 highlightColor;\n} picking;\n\n\nconst int INDEX_PICKING_MODE_INSTANCE = 0;\nconst int INDEX_PICKING_MODE_CUSTOM = 1;\n\nconst int INDEX_PICKING_INVALID_INDEX = -1; // 2^32 - 1\n\nflat out int picking_objectIndex;\n\n/**\n * Vertex shaders should call this function to set the object index.\n * If using instance or vertex mode, argument will be ignored, 0 can be supplied.\n */\nvoid picking_setObjectIndex(int objectIndex) {\n  switch (picking.indexMode) {\n    case INDEX_PICKING_MODE_INSTANCE:\n      picking_objectIndex = gl_InstanceID;\n      break;\n    case INDEX_PICKING_MODE_CUSTOM:\n      picking_objectIndex = objectIndex;\n      break;\n  }\n}\n";
-    readonly fs: "precision highp float;\nprecision highp int;\n\nuniform pickingUniforms {\n  int isActive;\n  int indexMode;\n  int batchIndex;\n\n  int isHighlightActive;\n  int highlightedBatchIndex;\n  int highlightedObjectIndex;\n  vec4 highlightColor;\n} picking;\n\n\nconst int INDEX_PICKING_INVALID_INDEX = -1; // 2^32 - 1\n\nflat in int picking_objectIndex;\n\n/**\n * Check if this vertex is highlighted (part of the selected batch and object)\n */ \nbool picking_isFragmentHighlighted() {\n  return \n    bool(picking.isHighlightActive) &&\n    picking.highlightedBatchIndex == picking.batchIndex &&\n    picking.highlightedObjectIndex == picking_objectIndex\n    ;\n}\n\n/**\n * Returns highlight color if this item is selected.\n */\nvec4 picking_filterHighlightColor(vec4 color) {\n  // If we are still picking, we don't highlight\n  if (bool(picking.isActive)) {\n    return color;\n  }\n\n  // If we are not highlighted, return color as is\n  if (!picking_isFragmentHighlighted()) {\n    return color;\n  }\n   \n  // Blend in highlight color based on its alpha value\n  float highLightAlpha = picking.highlightColor.a;\n  float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);\n  float highLightRatio = highLightAlpha / blendedAlpha;\n\n  vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);\n  return vec4(blendedRGB, blendedAlpha);\n}\n\n/*\n * Returns picking color if picking enabled else unmodified argument.\n */\nivec4 picking_getPickingColor() {\n  // Assumes that colorAttachment0 is rg32int\n  // TODO? - we could render indices into a second color attachment and not mess with fragColor\n  return ivec4(picking_objectIndex, picking.batchIndex, 0u, 0u);  \n}\n\nvec4 picking_filterPickingColor(vec4 color) {\n  if (bool(picking.isActive)) {\n    if (picking_objectIndex == INDEX_PICKING_INVALID_INDEX) {\n      discard;\n    }\n  }\n  return color;\n}\n\n/*\n * Returns picking color if picking is enabled if not\n * highlight color if this item is selected, otherwise unmodified argument.\n */\nvec4 picking_filterColor(vec4 color) {\n  vec4 outColor = color;\n  outColor = picking_filterHighlightColor(outColor);\n  outColor = picking_filterPickingColor(outColor);\n  return outColor;\n}\n";
+    readonly source: "struct pickingUniforms {\n  isActive: i32,\n  indexMode: i32,\n  batchIndex: i32,\n\n  isHighlightActive: i32,\n  highlightedBatchIndex: i32,\n  highlightedObjectIndex: i32,\n  highlightColor: vec4<f32>,\n};\n\n@group(0) @binding(auto) var<uniform> picking: pickingUniforms;\n\n\nconst INDEX_PICKING_MODE_INSTANCE = 0;\nconst INDEX_PICKING_MODE_CUSTOM = 1;\nconst INDEX_PICKING_INVALID_INDEX = -1; // 2^32 - 1\n\n/**\n * WGSL shaders need to carry the returned object index through their own stage outputs.\n */\nfn picking_setObjectIndex(objectIndex: i32) -> i32 {\n  return objectIndex;\n}\n\nfn picking_isObjectHighlighted(objectIndex: i32) -> bool {\n  return\n    picking.isHighlightActive != 0 &&\n    picking.highlightedBatchIndex == picking.batchIndex &&\n    picking.highlightedObjectIndex == objectIndex;\n}\n\nfn picking_filterHighlightColor(color: vec4<f32>, objectIndex: i32) -> vec4<f32> {\n  if (picking.isActive != 0 || !picking_isObjectHighlighted(objectIndex)) {\n    return color;\n  }\n\n  let highLightAlpha = picking.highlightColor.a;\n  let blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);\n  if (blendedAlpha == 0.0) {\n    return vec4<f32>(color.rgb, 0.0);\n  }\n\n  let highLightRatio = highLightAlpha / blendedAlpha;\n  let blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);\n  return vec4<f32>(blendedRGB, blendedAlpha);\n}\n\nfn picking_filterPickingColor(color: vec4<f32>, objectIndex: i32) -> vec4<f32> {\n  if (picking.isActive != 0 && objectIndex == INDEX_PICKING_INVALID_INDEX) {\n    discard;\n  }\n  return color;\n}\n\nfn picking_getPickingColor(objectIndex: i32) -> vec2<i32> {\n  return vec2<i32>(objectIndex, picking.batchIndex);\n}\n\n";
+    readonly vs: "precision highp float;\nprecision highp int;\n\nlayout(std140) uniform pickingUniforms {\n  int isActive;\n  int indexMode;\n  int batchIndex;\n\n  int isHighlightActive;\n  int highlightedBatchIndex;\n  int highlightedObjectIndex;\n  vec4 highlightColor;\n} picking;\n\n\nconst int INDEX_PICKING_MODE_INSTANCE = 0;\nconst int INDEX_PICKING_MODE_CUSTOM = 1;\n\nconst int INDEX_PICKING_INVALID_INDEX = -1; // 2^32 - 1\n\nflat out int picking_objectIndex;\n\n/**\n * Vertex shaders should call this function to set the object index.\n * If using instance or vertex mode, argument will be ignored, 0 can be supplied.\n */\nvoid picking_setObjectIndex(int objectIndex) {\n  switch (picking.indexMode) {\n    case INDEX_PICKING_MODE_INSTANCE:\n      picking_objectIndex = gl_InstanceID;\n      break;\n    case INDEX_PICKING_MODE_CUSTOM:\n      picking_objectIndex = objectIndex;\n      break;\n  }\n}\n";
+    readonly fs: "precision highp float;\nprecision highp int;\n\nlayout(std140) uniform pickingUniforms {\n  int isActive;\n  int indexMode;\n  int batchIndex;\n\n  int isHighlightActive;\n  int highlightedBatchIndex;\n  int highlightedObjectIndex;\n  vec4 highlightColor;\n} picking;\n\n\nconst int INDEX_PICKING_INVALID_INDEX = -1; // 2^32 - 1\n\nflat in int picking_objectIndex;\n\n/**\n * Check if this vertex is highlighted (part of the selected batch and object)\n */ \nbool picking_isFragmentHighlighted() {\n  return \n    bool(picking.isHighlightActive) &&\n    picking.highlightedBatchIndex == picking.batchIndex &&\n    picking.highlightedObjectIndex == picking_objectIndex\n    ;\n}\n\n/**\n * Returns highlight color if this item is selected.\n */\nvec4 picking_filterHighlightColor(vec4 color) {\n  // If we are still picking, we don't highlight\n  if (bool(picking.isActive)) {\n    return color;\n  }\n\n  // If we are not highlighted, return color as is\n  if (!picking_isFragmentHighlighted()) {\n    return color;\n  }\n   \n  // Blend in highlight color based on its alpha value\n  float highLightAlpha = picking.highlightColor.a;\n  float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);\n  float highLightRatio = highLightAlpha / blendedAlpha;\n\n  vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);\n  return vec4(blendedRGB, blendedAlpha);\n}\n\n/*\n * Returns picking color if picking enabled else unmodified argument.\n */\nivec4 picking_getPickingColor() {\n  // Assumes that colorAttachment0 is rg32int\n  // TODO? - we could render indices into a second color attachment and not mess with fragColor\n  return ivec4(picking_objectIndex, picking.batchIndex, 0u, 0u);  \n}\n\nvec4 picking_filterPickingColor(vec4 color) {\n  if (bool(picking.isActive)) {\n    if (picking_objectIndex == INDEX_PICKING_INVALID_INDEX) {\n      discard;\n    }\n  }\n  return color;\n}\n\n/*\n * Returns picking color if picking is enabled if not\n * highlight color if this item is selected, otherwise unmodified argument.\n */\nvec4 picking_filterColor(vec4 color) {\n  vec4 outColor = color;\n  outColor = picking_filterHighlightColor(outColor);\n  outColor = picking_filterPickingColor(outColor);\n  return outColor;\n}\n";
     readonly props: PickingProps;
     readonly uniforms: PickingUniforms;
     readonly uniformTypes: Required<import("@luma.gl/shadertools").UniformTypes<PickingUniforms>>;
@@ -22,7 +22,7 @@ export declare const picking: {
         readonly isActive: false;
         readonly indexMode: 0;
         readonly batchIndex: 0;
-        readonly isHighlightActive: true;
+        readonly isHighlightActive: false;
         readonly highlightedBatchIndex: -1;
         readonly highlightedObjectIndex: -1;
         readonly highlightColor: import("@math.gl/types").NumberArray4;

package/dist/modules/picking/index-picking.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index-picking.d.ts","sourceRoot":"","sources":["../../../src/modules/picking/index-picking.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAkB,YAAY,EAAE,eAAe,EAAC,8BAA2B;AAoIvF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;CAM6D,CAAC"}
+{"version":3,"file":"index-picking.d.ts","sourceRoot":"","sources":["../../../src/modules/picking/index-picking.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAkB,YAAY,EAAE,eAAe,EAAC,8BAA2B;AAwJvF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;CAM6D,CAAC"}

package/dist/modules/picking/index-picking.js

@@ -10,25 +10,45 @@ const INDEX_PICKING_MODE_INSTANCE = 0;
 const INDEX_PICKING_MODE_CUSTOM = 1;
 const INDEX_PICKING_INVALID_INDEX = ${INVALID_INDEX}; // 2^32 - 1
 
-struct indexPickingFragmentInputs = {
-  objectIndex: int32;
-};
-
-let indexPickingFragmentInputs: indexPickingFragmentInputs;
-
 /**
- * Vertex shaders should call this function to set the object index.
- * If using instance or vertex mode, argument will be ignored, 0 can be supplied.
+ * WGSL shaders need to carry the returned object index through their own stage outputs.
  */
-fn picking_setObjectIndex(objectIndex: int32) {
-  switch (picking.indexMode) {
-    case INDEX_PICKING_MODE_INSTANCE, default: {
-      picking_objectIndex = instance_index;
-    };
-    case INDEX_PICKING_MODE_CUSTOM: {
-      picking_objectIndex = objectIndex;
-    };
+fn picking_setObjectIndex(objectIndex: i32) -> i32 {
+  return objectIndex;
+}
+
+fn picking_isObjectHighlighted(objectIndex: i32) -> bool {
+  return
+    picking.isHighlightActive != 0 &&
+    picking.highlightedBatchIndex == picking.batchIndex &&
+    picking.highlightedObjectIndex == objectIndex;
+}
+
+fn picking_filterHighlightColor(color: vec4<f32>, objectIndex: i32) -> vec4<f32> {
+  if (picking.isActive != 0 || !picking_isObjectHighlighted(objectIndex)) {
+    return color;
+  }
+
+  let highLightAlpha = picking.highlightColor.a;
+  let blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);
+  if (blendedAlpha == 0.0) {
+    return vec4<f32>(color.rgb, 0.0);
   }
+
+  let highLightRatio = highLightAlpha / blendedAlpha;
+  let blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
+  return vec4<f32>(blendedRGB, blendedAlpha);
+}
+
+fn picking_filterPickingColor(color: vec4<f32>, objectIndex: i32) -> vec4<f32> {
+  if (picking.isActive != 0 && objectIndex == INDEX_PICKING_INVALID_INDEX) {
+    discard;
+  }
+  return color;
+}
+
+fn picking_getPickingColor(objectIndex: i32) -> vec2<i32> {
+  return vec2<i32>(objectIndex, picking.batchIndex);
 }
 
 `;

package/dist/modules/picking/index-picking.js.map

@@ -1 +1 @@
-{"version":3,"file":"index-picking.js","sourceRoot":"","sources":["../../../src/modules/picking/index-picking.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAC,8BAA2B;AAEhG,UAAU;AAEV,MAAM,MAAM,GAAG,UAAU,CAAC;EACxB,aAAa;;;;sCAIuB,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAuBlD,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;EACpB,aAAa;;;;;0CAK2B,aAAa;;;;;;;;;;;;;;;;;;CAkBtD,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;EACpB,aAAa;;0CAE2B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEtD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,GAAG,eAAe;IAClB,IAAI,EAAE,SAAS;IACf,MAAM;IACN,EAAE;IACF,EAAE;CAC6E,CAAC"}
+{"version":3,"file":"index-picking.js","sourceRoot":"","sources":["../../../src/modules/picking/index-picking.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAC,8BAA2B;AAEhG,UAAU;AAEV,MAAM,MAAM,GAAG,UAAU,CAAC;EACxB,aAAa;;;;sCAIuB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2ClD,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;EACpB,aAAa;;;;;0CAK2B,aAAa;;;;;;;;;;;;;;;;;;CAkBtD,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;EACpB,aAAa;;0CAE2B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEtD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,GAAG,eAAe;IAClB,IAAI,EAAE,SAAS;IACf,MAAM;IACN,EAAE;IACF,EAAE;CAC6E,CAAC"}

package/dist/modules/picking/legacy-color-picking.d.ts

@@ -0,0 +1,26 @@
+/** @deprecated Use `picking`/`colorPicking` for object picking. */
+export declare const legacyColorPicking: {
+    readonly props: import("@luma.gl/shadertools").PickingProps;
+    readonly uniforms: import("@luma.gl/shadertools").PickingUniforms;
+    readonly name: "picking";
+    readonly uniformTypes: {
+        readonly isActive: "f32";
+        readonly isAttribute: "f32";
+        readonly isHighlightActive: "f32";
+        readonly useFloatColors: "f32";
+        readonly highlightedObjectColor: "vec3<f32>";
+        readonly highlightColor: "vec4<f32>";
+    };
+    readonly defaultUniforms: {
+        readonly isActive: false;
+        readonly isAttribute: false;
+        readonly isHighlightActive: false;
+        readonly useFloatColors: true;
+        readonly highlightedObjectColor: [0, 0, 0];
+        readonly highlightColor: import("@math.gl/types").NumberArray4;
+    };
+    readonly vs: "layout(std140) uniform pickingUniforms {\n  float isActive;\n  float isAttribute;\n  float isHighlightActive;\n  float useFloatColors;\n  vec3 highlightedObjectColor;\n  vec4 highlightColor;\n} picking;\n\nout vec4 picking_vRGBcolor_Avalid;\n\n// Normalize unsigned byte color to 0-1 range\nvec3 picking_normalizeColor(vec3 color) {\n  return picking.useFloatColors > 0.5 ? color : color / 255.0;\n}\n\n// Normalize unsigned byte color to 0-1 range\nvec4 picking_normalizeColor(vec4 color) {\n  return picking.useFloatColors > 0.5 ? color : color / 255.0;\n}\n\nbool picking_isColorZero(vec3 color) {\n  return dot(color, vec3(1.0)) < 0.00001;\n}\n\nbool picking_isColorValid(vec3 color) {\n  return dot(color, vec3(1.0)) > 0.00001;\n}\n\n// Check if this vertex is highlighted \nbool isVertexHighlighted(vec3 vertexColor) {\n  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);\n  return\n    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));\n}\n\n// Set the current picking color\nvoid picking_setPickingColor(vec3 pickingColor) {\n  pickingColor = picking_normalizeColor(pickingColor);\n\n  if (bool(picking.isActive)) {\n    // Use alpha as the validity flag. If pickingColor is [0, 0, 0] fragment is non-pickable\n    picking_vRGBcolor_Avalid.a = float(picking_isColorValid(pickingColor));\n\n    if (!bool(picking.isAttribute)) {\n      // Stores the picking color so that the fragment shader can render it during picking\n      picking_vRGBcolor_Avalid.rgb = pickingColor;\n    }\n  } else {\n    // Do the comparison with selected item color in vertex shader as it should mean fewer compares\n    picking_vRGBcolor_Avalid.a = float(isVertexHighlighted(pickingColor));\n  }\n}\n\nvoid picking_setPickingAttribute(float value) {\n  if (bool(picking.isAttribute)) {\n    picking_vRGBcolor_Avalid.r = value;\n  }\n}\n\nvoid picking_setPickingAttribute(vec2 value) {\n  if (bool(picking.isAttribute)) {\n    picking_vRGBcolor_Avalid.rg = value;\n  }\n}\n\nvoid picking_setPickingAttribute(vec3 value) {\n  if (bool(picking.isAttribute)) {\n    picking_vRGBcolor_Avalid.rgb = value;\n  }\n}\n";
+    readonly fs: "layout(std140) uniform pickingUniforms {\n  float isActive;\n  float isAttribute;\n  float isHighlightActive;\n  float useFloatColors;\n  vec3 highlightedObjectColor;\n  vec4 highlightColor;\n} picking;\n\nin vec4 picking_vRGBcolor_Avalid;\n\n/*\n * Returns highlight color if this item is selected.\n */\nvec4 picking_filterHighlightColor(vec4 color) {\n  // If we are still picking, we don't highlight\n  if (picking.isActive > 0.5) {\n    return color;\n  }\n\n  bool selected = bool(picking_vRGBcolor_Avalid.a);\n\n  if (selected) {\n    // Blend in highlight color based on its alpha value\n    float highLightAlpha = picking.highlightColor.a;\n    float blendedAlpha = highLightAlpha + color.a * (1.0 - highLightAlpha);\n    float highLightRatio = highLightAlpha / blendedAlpha;\n\n    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);\n    return vec4(blendedRGB, blendedAlpha);\n  } else {\n    return color;\n  }\n}\n\n/*\n * Returns picking color if picking enabled else unmodified argument.\n */\nvec4 picking_filterPickingColor(vec4 color) {\n  if (bool(picking.isActive)) {\n    if (picking_vRGBcolor_Avalid.a == 0.0) {\n      discard;\n    }\n    return picking_vRGBcolor_Avalid;\n  }\n  return color;\n}\n\n/*\n * Returns picking color if picking is enabled if not\n * highlight color if this item is selected, otherwise unmodified argument.\n */\nvec4 picking_filterColor(vec4 color) {\n  vec4 highlightColor = picking_filterHighlightColor(color);\n  return picking_filterPickingColor(highlightColor);\n}\n";
+    readonly getUniforms: (opts?: import("@luma.gl/shadertools").PickingProps, prevUniforms?: import("@luma.gl/shadertools").PickingUniforms) => import("@luma.gl/shadertools").PickingUniforms;
+};
+//# sourceMappingURL=legacy-color-picking.d.ts.map

package/dist/modules/picking/legacy-color-picking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-color-picking.d.ts","sourceRoot":"","sources":["../../../src/modules/picking/legacy-color-picking.ts"],"names":[],"mappings":"AAMA,mEAAmE;AACnE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;CAAqB,CAAC"}

package/dist/modules/picking/legacy-color-picking.js

@@ -0,0 +1,7 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { picking as shadertoolsPicking } from '@luma.gl/shadertools';
+/** @deprecated Use `picking`/`colorPicking` for object picking. */
+export const legacyColorPicking = shadertoolsPicking;
+//# sourceMappingURL=legacy-color-picking.js.map

package/dist/modules/picking/legacy-color-picking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"legacy-color-picking.js","sourceRoot":"","sources":["../../../src/modules/picking/legacy-color-picking.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,OAAO,EAAC,OAAO,IAAI,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAEnE,mEAAmE;AACnE,MAAM,CAAC,MAAM,kBAAkB,GAAG,kBAAkB,CAAC"}

package/dist/modules/picking/picking-manager.d.ts

@@ -1,28 +1,46 @@
 import { Device, Framebuffer } from '@luma.gl/core';
 import { ShaderInputs } from "../../shader-inputs.js";
 import { pickingUniforms } from "./picking-uniforms.js";
+declare const COLOR_PICKING_MAX_OBJECT_INDEX = 16777214;
+declare const COLOR_PICKING_MAX_BATCH_INDEX = 254;
 /** Information about picked object */
 export type PickInfo = {
     batchIndex: number | null;
     objectIndex: number | null;
 };
+export type PickingMode = 'auto' | 'index' | 'color';
+export type ResolvedPickingMode = Exclude<PickingMode, 'auto'>;
+/** @deprecated Use `PickingMode`. */
+export type PickingBackend = PickingMode;
+/** @deprecated Use `ResolvedPickingMode`. */
+export type ResolvedPickingBackend = ResolvedPickingMode;
 export type PickingManagerProps = {
-    /** Shader Inputs from models to pick */
+    /** Shader inputs from models to pick */
     shaderInputs?: ShaderInputs<{
         picking: typeof pickingUniforms.props;
     }>;
     /** Callback */
     onObjectPicked?: (info: PickInfo) => void;
+    /** Select a picking mode. Defaults to `color`. Use `auto` to prefer `index` when supported. */
+    mode?: PickingMode;
+    /** @deprecated Use `mode`. */
+    backend?: PickingBackend;
 };
+export declare function resolvePickingMode(deviceType: Device['type'], mode?: PickingMode, indexPickingSupported?: boolean): ResolvedPickingMode;
+export declare function supportsIndexPicking(device: Device): boolean;
+/** @deprecated Use `resolvePickingMode`. */
+export declare const resolvePickingBackend: typeof resolvePickingMode;
+export declare function decodeIndexPickInfo(pixelData: Int32Array): PickInfo;
+export declare function decodeColorPickInfo(pixelData: Uint8Array): PickInfo;
 /**
- * Helper class for using the new picking module
- * @todo Port to WebGPU
+ * Helper class for using object picking with backend-specific readback.
  * @todo Support multiple models
  * @todo Switching picking module
  */
 export declare class PickingManager {
     device: Device;
     props: Required<PickingManagerProps>;
+    mode: ResolvedPickingMode;
     /** Info from latest pick operation */
     pickInfo: PickInfo;
     /** Framebuffer used for picking */
@@ -41,5 +59,13 @@ export declare class PickingManager {
      * use the center pixel location in device pixel range
      */
     getPickPosition(mousePosition: [number, number]): [number, number];
+    protected createIndexFramebuffer(): Framebuffer;
+    protected createColorFramebuffer(): Framebuffer;
+    protected setPickingProps(props: Partial<typeof pickingUniforms.props>): void;
+    protected readPickInfo(framebuffer: Framebuffer, pickPosition: [number, number]): Promise<PickInfo | null>;
+    protected readIndexPickInfo(framebuffer: Framebuffer, [pickX, pickY]: [number, number]): Promise<PickInfo | null>;
+    protected readColorPickInfo(framebuffer: Framebuffer, [pickX, pickY]: [number, number]): Promise<PickInfo | null>;
+    protected hasPickInfoChanged(pickInfo: PickInfo): boolean;
 }
+export { COLOR_PICKING_MAX_BATCH_INDEX, COLOR_PICKING_MAX_OBJECT_INDEX };
 //# sourceMappingURL=picking-manager.d.ts.map

package/dist/modules/picking/picking-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"picking-manager.d.ts","sourceRoot":"","sources":["../../../src/modules/picking/picking-manager.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAE,WAAW,EAAC,MAAM,eAAe,CAAC;AAClD,OAAO,EAAC,YAAY,EAAC,+BAA4B;AACjD,OAAO,EAAC,eAAe,EAAgB,8BAA2B;AAGlE,sCAAsC;AACtC,MAAM,MAAM,QAAQ,GAAG;IACrB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,wCAAwC;IACxC,YAAY,CAAC,EAAE,YAAY,CAAC;QAAC,OAAO,EAAE,OAAO,eAAe,CAAC,KAAK,CAAA;KAAC,CAAC,CAAC;IACrE,eAAe;IACf,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;CAC3C,CAAC;AAEF;;;;;GAKG;AACH,qBAAa,cAAc;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAAC;IACrC,sCAAsC;IACtC,QAAQ,EAAE,QAAQ,CAAyC;IAC3D,mCAAmC;IACnC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAQ;IAEvC,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,mBAAmB,CAAC,CAGhD;gBAEU,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,mBAAmB;IAKtD,OAAO;IAKP,cAAc;IAUd,wCAAwC;IACxC,cAAc;IAId,2CAA2C;IAC3C,eAAe;IAeT,cAAc,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;IA4C/E;;;OAGG;IACH,eAAe,CAAC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;CAMnE"}
+{"version":3,"file":"picking-manager.d.ts","sourceRoot":"","sources":["../../../src/modules/picking/picking-manager.ts"],"names":[],"mappings":"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"}