@luma.gl/engine 9.1.0-alpha.9 → 9.1.0-beta.11

package/dist/models/billboard-texture-model.js

@@ -0,0 +1,78 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { ClipSpace } from "./clip-space.js";
+const BACKGROUND_FS_WGSL = /* wgsl */ `\
+@group(0) @binding(0) var backgroundTexture: texture_2d<f32>;
+@group(0) @binding(1) var backgroundTextureSampler: sampler;
+
+fn billboardTexture_getTextureUV(coordinates: vec2<f32>) -> vec2<f32> {
+	let iTexSize: vec2<u32> = textureDimensions(backgroundTexture, 0) * 2;
+	let texSize: vec2<f32> = vec2<f32>(f32(iTexSize.x), f32(iTexSize.y));
+	var position: vec2<f32> = coordinates.xy / texSize;
+	return position;
+} 
+
+@fragment
+fn fragmentMain(inputs: FragmentInputs) -> @location(0) vec4<f32> {
+	let position: vec2<f32> = billboardTexture_getTextureUV(inputs.coordinate);
+	return textureSample(backgroundTexture, backgroundTextureSampler, position);
+}
+`;
+const BACKGROUND_FS = /* glsl */ `\
+#version 300 es
+precision highp float;
+
+uniform sampler2D backgroundTexture;
+out vec4 fragColor;
+
+vec2 billboardTexture_getTextureUV() {
+  ivec2 iTexSize = textureDimensions(backgroundTexture, 0) * 2;
+  vec2 texSize = vec2(float(iTexSize.x), float(iTexSize.y));
+  vec2 position = gl_FragCoord.xy / texSize;
+  return position;
+}
+
+void main(void) {
+  vec2 position = billboardTexture_getTextureUV();
+  fragColor = texture(backgroundTexture, position);
+}
+`;
+/**
+ * Model that renders a bitmap into the "background", i.e covering the screen
+ */
+export class BackgroundTextureModel extends ClipSpace {
+    constructor(device, props) {
+        super(device, {
+            id: props.id || 'background-texture-model',
+            source: BACKGROUND_FS_WGSL,
+            fs: BACKGROUND_FS,
+            parameters: {
+                depthWriteEnabled: false,
+                depthCompare: 'always',
+                ...(props.blend
+                    ? {
+                        blend: true,
+                        blendColorOperation: 'add',
+                        blendAlphaOperation: 'add',
+                        blendColorSrcFactor: 'one',
+                        blendColorDstFactor: 'one-minus-src-color',
+                        blendAlphaSrcFactor: 'one',
+                        blendAlphaDstFactor: 'one-minus-src-alpha'
+                    }
+                    : {})
+            }
+        });
+        this.setTexture(props.backgroundTexture);
+    }
+    setTexture(backgroundTexture) {
+        this.setBindings({
+            backgroundTexture
+        });
+    }
+    predraw() {
+        this.shaderInputs.setProps({});
+        super.predraw();
+    }
+}
+//# sourceMappingURL=billboard-texture-model.js.map

package/dist/models/billboard-texture-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"billboard-texture-model.js","sourceRoot":"","sources":["../../src/models/billboard-texture-model.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,SAAS,EAAC,wBAAqB;AAEvC,MAAM,kBAAkB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;CAgBrC,CAAC;AAEF,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;CAkBhC,CAAC;AAcF;;GAEG;AACH,MAAM,OAAO,sBAAuB,SAAQ,SAAS;IACnD,YAAY,MAAc,EAAE,KAAkC;QAC5D,KAAK,CAAC,MAAM,EAAE;YACZ,EAAE,EAAE,KAAK,CAAC,EAAE,IAAI,0BAA0B;YAC1C,MAAM,EAAE,kBAAkB;YAC1B,EAAE,EAAE,aAAa;YACjB,UAAU,EAAE;gBACV,iBAAiB,EAAE,KAAK;gBACxB,YAAY,EAAE,QAAQ;gBACtB,GAAG,CAAC,KAAK,CAAC,KAAK;oBACb,CAAC,CAAC;wBACE,KAAK,EAAE,IAAI;wBACX,mBAAmB,EAAE,KAAK;wBAC1B,mBAAmB,EAAE,KAAK;wBAC1B,mBAAmB,EAAE,KAAK;wBAC1B,mBAAmB,EAAE,qBAAqB;wBAC1C,mBAAmB,EAAE,KAAK;wBAC1B,mBAAmB,EAAE,qBAAqB;qBAC3C;oBACH,CAAC,CAAC,EAAE,CAAC;aACR;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC3C,CAAC;IAED,UAAU,CAAC,iBAAyC;QAClD,IAAI,CAAC,WAAW,CAAC;YACf,iBAAiB;SAClB,CAAC,CAAC;IACL,CAAC;IAEQ,OAAO;QACd,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC/B,KAAK,CAAC,OAAO,EAAE,CAAC;IAClB,CAAC;CACF"}

package/dist/models/billboard-texture-module.d.ts

@@ -0,0 +1,10 @@
+export declare const billboardTexture: {
+    readonly name: "billboardTexture";
+    readonly fs: "#version 300 es\n\nuniform billboardTextureUniforms {\n  vec2 topLeft;\n  vec2 bottomRight;\n} billboardTexture;\n\nprecision highp float;\nuniform sampler2D backgroundTexture;\nout vec4 fragColor;\n\nvec2 billboardTexture_getTextureUV() {\n  ivec2 iTexSize = textureSize(backgroundTexture, 0) * 2;\n  vec2 texSize = vec2(float(iTexSize.x), float(iTexSize.y));\n  vec2 position = gl_FragCoord.xy / texSize;\n  return position;\n}\n\nvoid main(void) {\n  vec2 position = billboardTexture_getTextureUV();\n  fragColor = texture(backgroundTexture, position);\n}\n";
+    readonly dependencies: [];
+    readonly uniformTypes: {
+        readonly topLeft: "vec2<f32>";
+        readonly bottomRight: "vec2<f32>";
+    };
+};
+//# sourceMappingURL=billboard-texture-module.d.ts.map

package/dist/models/billboard-texture-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"billboard-texture-module.d.ts","sourceRoot":"","sources":["../../src/models/billboard-texture-module.ts"],"names":[],"mappings":"AAwCA,eAAO,MAAM,gBAAgB;;;;;;;;CAQqD,CAAC"}

package/dist/models/billboard-texture-module.js

@@ -0,0 +1,37 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const BACKGROUND_FS = /* glsl */ `\
+#version 300 es
+
+uniform billboardTextureUniforms {
+  vec2 topLeft;
+  vec2 bottomRight;
+} billboardTexture;
+
+precision highp float;
+uniform sampler2D backgroundTexture;
+out vec4 fragColor;
+
+vec2 billboardTexture_getTextureUV() {
+  ivec2 iTexSize = textureSize(backgroundTexture, 0) * 2;
+  vec2 texSize = vec2(float(iTexSize.x), float(iTexSize.y));
+  vec2 position = gl_FragCoord.xy / texSize;
+  return position;
+}
+
+void main(void) {
+  vec2 position = billboardTexture_getTextureUV();
+  fragColor = texture(backgroundTexture, position);
+}
+`;
+export const billboardTexture = {
+    name: 'billboardTexture',
+    fs: BACKGROUND_FS,
+    dependencies: [],
+    uniformTypes: {
+        topLeft: 'vec2<f32>',
+        bottomRight: 'vec2<f32>'
+    }
+};
+//# sourceMappingURL=billboard-texture-module.js.map

package/dist/models/billboard-texture-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"billboard-texture-module.js","sourceRoot":"","sources":["../../src/models/billboard-texture-module.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,MAAM,aAAa,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBhC,CAAC;AAWF,MAAM,CAAC,MAAM,gBAAgB,GAAG;IAC9B,IAAI,EAAE,kBAAkB;IACxB,EAAE,EAAE,aAAa;IACjB,YAAY,EAAE,EAAE;IAChB,YAAY,EAAE;QACZ,OAAO,EAAE,WAAW;QACpB,WAAW,EAAE,WAAW;KACzB;CAC+E,CAAC"}

package/dist/{lib → models}/clip-space.d.ts

@@ -1,9 +1,11 @@
 import { Device } from '@luma.gl/core';
 import { Model, ModelProps } from "../model/model.js";
+/** Props for ClipSpace */
+export type ClipSpaceProps = Omit<ModelProps, 'vs' | 'vertexCount' | 'geometry'>;
 /**
  * A flat geometry that covers the "visible area" that the GPU renders.
  */
 export declare class ClipSpace extends Model {
-    constructor(device: Device, opts: Omit<ModelProps, 'vs' | 'vertexCount' | 'geometry'>);
+    constructor(device: Device, props: ClipSpaceProps);
 }
 //# sourceMappingURL=clip-space.d.ts.map

package/dist/models/clip-space.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clip-space.d.ts","sourceRoot":"","sources":["../../src/models/clip-space.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AACrC,OAAO,EAAC,KAAK,EAAE,UAAU,EAAC,0BAAuB;AAkDjD,0BAA0B;AAC1B,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,aAAa,GAAG,UAAU,CAAC,CAAC;AAEjF;;GAEG;AACH,qBAAa,SAAU,SAAQ,KAAK;gBACtB,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc;CAwBlD"}

package/dist/models/clip-space.js

@@ -0,0 +1,77 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Model } from "../model/model.js";
+import { Geometry } from "../geometry/geometry.js";
+import { uid } from "../utils/uid.js";
+const CLIPSPACE_VERTEX_SHADER_WGSL = /* wgsl */ `\
+struct VertexInputs {
+  @location(0) clipSpacePosition: vec2<f32>,
+  @location(1) texCoord: vec2<f32>,
+  @location(2) coordinate: vec2<f32>  
+}
+
+struct FragmentInputs {
+  @builtin(position) Position : vec4<f32>,
+  @location(0) position : vec2<f32>,
+  @location(1) coordinate : vec2<f32>,
+  @location(2) uv : vec2<f32>
+};
+
+@vertex
+fn vertexMain(inputs: VertexInputs) -> FragmentInputs {
+  var outputs: FragmentInputs;
+  outputs.Position = vec4(inputs.clipSpacePosition, 0., 1.);
+  outputs.position = inputs.clipSpacePosition;
+  outputs.coordinate = inputs.coordinate;
+  outputs.uv = inputs.texCoord;
+  return outputs;
+}
+`;
+const CLIPSPACE_VERTEX_SHADER = /* glsl */ `\
+#version 300 es
+in vec2 clipSpacePositions;
+in vec2 texCoords;
+in vec2 coordinates;
+
+out vec2 position;
+out vec2 coordinate;
+out vec2 uv;
+
+void main(void) {
+  gl_Position = vec4(clipSpacePositions, 0., 1.);
+  position = clipSpacePositions;
+  coordinate = coordinates;
+  uv = texCoords;
+}
+`;
+/* eslint-disable indent, no-multi-spaces */
+const POSITIONS = [-1, -1, 1, -1, -1, 1, 1, 1];
+/**
+ * A flat geometry that covers the "visible area" that the GPU renders.
+ */
+export class ClipSpace extends Model {
+    constructor(device, props) {
+        const TEX_COORDS = POSITIONS.map(coord => (coord === -1 ? 0 : coord));
+        // For WGSL we need to append the supplied fragment shader to the default vertex shader source
+        if (props.source) {
+            props = { ...props, source: `${CLIPSPACE_VERTEX_SHADER_WGSL}\n${props.source}` };
+        }
+        super(device, {
+            id: props.id || uid('clip-space'),
+            ...props,
+            vs: CLIPSPACE_VERTEX_SHADER,
+            vertexCount: 4,
+            geometry: new Geometry({
+                topology: 'triangle-strip',
+                vertexCount: 4,
+                attributes: {
+                    clipSpacePositions: { size: 2, value: new Float32Array(POSITIONS) },
+                    texCoords: { size: 2, value: new Float32Array(TEX_COORDS) },
+                    coordinates: { size: 2, value: new Float32Array(TEX_COORDS) }
+                }
+            })
+        });
+    }
+}
+//# sourceMappingURL=clip-space.js.map

package/dist/models/clip-space.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clip-space.js","sourceRoot":"","sources":["../../src/models/clip-space.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,KAAK,EAAa,0BAAuB;AACjD,OAAO,EAAC,QAAQ,EAAC,gCAA6B;AAC9C,OAAO,EAAC,GAAG,EAAC,wBAAqB;AAEjC,MAAM,4BAA4B,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuB/C,CAAC;AAEF,MAAM,uBAAuB,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;CAgB1C,CAAC;AAEF,4CAA4C;AAC5C,MAAM,SAAS,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;AAK/C;;GAEG;AACH,MAAM,OAAO,SAAU,SAAQ,KAAK;IAClC,YAAY,MAAc,EAAE,KAAqB;QAC/C,MAAM,UAAU,GAAG,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QAEtE,8FAA8F;QAC9F,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YACjB,KAAK,GAAG,EAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,4BAA4B,KAAK,KAAK,CAAC,MAAM,EAAE,EAAC,CAAC;QACjF,CAAC;QAED,KAAK,CAAC,MAAM,EAAE;YACZ,EAAE,EAAE,KAAK,CAAC,EAAE,IAAI,GAAG,CAAC,YAAY,CAAC;YACjC,GAAG,KAAK;YACR,EAAE,EAAE,uBAAuB;YAC3B,WAAW,EAAE,CAAC;YACd,QAAQ,EAAE,IAAI,QAAQ,CAAC;gBACrB,QAAQ,EAAE,gBAAgB;gBAC1B,WAAW,EAAE,CAAC;gBACd,UAAU,EAAE;oBACV,kBAAkB,EAAE,EAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,YAAY,CAAC,SAAS,CAAC,EAAC;oBACjE,SAAS,EAAE,EAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,YAAY,CAAC,UAAU,CAAC,EAAC;oBACzD,WAAW,EAAE,EAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,YAAY,CAAC,UAAU,CAAC,EAAC;iBAC5D;aACF,CAAC;SACH,CAAC,CAAC;IACL,CAAC;CACF"}

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

@@ -0,0 +1,28 @@
+import type { PickingProps, PickingUniforms } from "./picking-uniforms.js";
+/**
+ * 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
+ */
+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";
+    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\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_setObjectIndex(uint objectIndex) {\n  if (bool(picking.isActive)) {\n    uint index = objectIndex;\n    if (picking.indexMode == PICKING_INDEX_MODE_INSTANCE) {\n      index = uint(gl_InstanceID);\n    }\n    picking_vRGBcolor_Avalid.r = float(index % 255) / 255.0;\n    picking_vRGBcolor_Avalid.g = float((index / 255) % 255) / 255.0;\n    picking_vRGBcolor_Avalid.b = float((index / 255 / 255) %255) / 255.0;\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: "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\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 props: PickingProps;
+    readonly uniforms: PickingUniforms;
+    readonly uniformTypes: Required<import("modules/shadertools/dist/lib/utils/uniform-types").UniformTypes<PickingUniforms>>;
+    readonly defaultUniforms: {
+        readonly isActive: false;
+        readonly indexMode: 0;
+        readonly batchIndex: 0;
+        readonly isHighlightActive: true;
+        readonly highlightedBatchIndex: -1;
+        readonly highlightedObjectIndex: -1;
+        readonly highlightColor: import("@math.gl/types").NumberArray4;
+    };
+    readonly getUniforms: (props?: PickingProps, prevUniforms?: PickingUniforms) => PickingUniforms;
+};
+//# sourceMappingURL=color-picking.d.ts.map

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

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

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

@@ -0,0 +1,177 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { pickingUniforms, GLSL_UNIFORMS, WGSL_UNIFORMS } 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;
+}
+
+// Normalize unsigned byte color to 0-1 range
+vec4 picking_normalizeColor(vec4 color) {
+  return picking.useFloatColors > 0.5 ? color : color / 255.0;
+}
+
+bool picking_isColorZero(vec3 color) {
+  return dot(color, vec3(1.0)) < 0.00001;
+}
+
+bool picking_isColorValid(vec3 color) {
+  return dot(color, vec3(1.0)) > 0.00001;
+}
+
+// Check if this vertex is highlighted 
+bool isVertexHighlighted(vec3 vertexColor) {
+  vec3 highlightedObjectColor = picking_normalizeColor(picking.highlightedObjectColor);
+  return
+    bool(picking.isHighlightActive) && picking_isColorZero(abs(vertexColor - highlightedObjectColor));
+}
+
+// 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));
+  }
+}
+
+void picking_setObjectIndex(uint objectIndex) {
+  if (bool(picking.isActive)) {
+    uint index = objectIndex;
+    if (picking.indexMode == PICKING_INDEX_MODE_INSTANCE) {
+      index = uint(gl_InstanceID);
+    }
+    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;
+  }
+}
+
+void picking_setPickingAttribute(float value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.r = value;
+  }
+}
+
+void picking_setPickingAttribute(vec2 value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rg = value;
+  }
+}
+
+void picking_setPickingAttribute(vec3 value) {
+  if (bool(picking.isAttribute)) {
+    picking_vRGBcolor_Avalid.rgb = value;
+  }
+}
+`;
+const fs = /* glsl */ `\
+${GLSL_UNIFORMS}
+
+in vec4 picking_vRGBcolor_Avalid;
+
+/*
+ * 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) {
+    return color;
+  }
+
+  bool selected = bool(picking_vRGBcolor_Avalid.a);
+
+  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;
+
+    vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
+    return vec4(blendedRGB, blendedAlpha);
+  } else {
+    return color;
+  }
+}
+
+/*
+ * 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) {
+      discard;
+    }
+    return picking_vRGBcolor_Avalid;
+  }
+  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);
+}
+`;
+/**
+ * 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
+ */
+export const picking = {
+    ...pickingUniforms,
+    name: 'picking',
+    source,
+    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

@@ -0,0 +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"}

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

@@ -0,0 +1,32 @@
+import type { PickingProps, PickingUniforms } from "./picking-uniforms.js";
+/**
+ * Provides support for color-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
+ *
+ * @note Color based picking has the significant advantage in that it can be added to any
+ * existing shader without requiring any additional picking logic.
+ */
+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 props: PickingProps;
+    readonly uniforms: PickingUniforms;
+    readonly uniformTypes: Required<import("modules/shadertools/dist/lib/utils/uniform-types").UniformTypes<PickingUniforms>>;
+    readonly defaultUniforms: {
+        readonly isActive: false;
+        readonly indexMode: 0;
+        readonly batchIndex: 0;
+        readonly isHighlightActive: true;
+        readonly highlightedBatchIndex: -1;
+        readonly highlightedObjectIndex: -1;
+        readonly highlightColor: import("@math.gl/types").NumberArray4;
+    };
+    readonly getUniforms: (props?: PickingProps, prevUniforms?: PickingUniforms) => PickingUniforms;
+};
+//# sourceMappingURL=index-picking.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,148 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { pickingUniforms, GLSL_UNIFORMS, WGSL_UNIFORMS, INVALID_INDEX } from "./picking-uniforms.js";
+// SHADERS
+const source = /* wgsl */ `\
+${WGSL_UNIFORMS}
+
+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.
+ */
+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;
+    };
+  }
+}
+
+`;
+const vs = /* glsl */ `\
+${GLSL_UNIFORMS}
+
+const int INDEX_PICKING_MODE_INSTANCE = 0;
+const int INDEX_PICKING_MODE_CUSTOM = 1;
+
+const int INDEX_PICKING_INVALID_INDEX = ${INVALID_INDEX}; // 2^32 - 1
+
+flat out int picking_objectIndex;
+
+/**
+ * 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.
+ */
+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}
+
+const int INDEX_PICKING_INVALID_INDEX = ${INVALID_INDEX}; // 2^32 - 1
+
+flat in int picking_objectIndex;
+
+/**
+ * Check if this vertex is highlighted (part of the selected batch and object)
+ */ 
+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 (bool(picking.isActive)) {
+    return color;
+  }
+
+  // If we are not highlighted, return color as is
+  if (!picking_isFragmentHighlighted()) {
+    return color;
+  }
+   
+  // 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;
+
+  vec3 blendedRGB = mix(color.rgb, picking.highlightColor.rgb, highLightRatio);
+  return vec4(blendedRGB, blendedAlpha);
+}
+
+/*
+ * Returns picking color if picking enabled else unmodified argument.
+ */
+ivec4 picking_getPickingColor() {
+  // Assumes that colorAttachment0 is rg32int
+  // TODO? - we could render indices into a second color attachment and not mess with fragColor
+  return ivec4(picking_objectIndex, picking.batchIndex, 0u, 0u);  
+}
+
+vec4 picking_filterPickingColor(vec4 color) {
+  if (bool(picking.isActive)) {
+    if (picking_objectIndex == INDEX_PICKING_INVALID_INDEX) {
+      discard;
+    }
+  }
+  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 outColor = color;
+  outColor = picking_filterHighlightColor(outColor);
+  outColor = picking_filterPickingColor(outColor);
+  return outColor;
+}
+`;
+/**
+ * Provides support for color-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
+ *
+ * @note Color based picking has the significant advantage in that it can be added to any
+ * existing shader without requiring any additional picking logic.
+ */
+export const picking = {
+    ...pickingUniforms,
+    name: 'picking',
+    source,
+    vs,
+    fs
+};
+//# sourceMappingURL=index-picking.js.map

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

@@ -0,0 +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"}