@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.6

package/dist/modules/engine/gpu-animation/gpu-animation.js

@@ -0,0 +1,228 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+const source = /* wgsl */ `
+#ifdef HAS_GPU_CROWD_ANIMATION
+@group(0) @binding(auto) var<storage, read> gpuAnimationFrames: array<vec4f>;
+
+fn readGPUAnimationFrame(frame: u32, offset: u32, frameStride: u32) -> vec4f {
+  return gpuAnimationFrames[frame * frameStride + offset];
+}
+
+fn sampleGPUAnimationFrame(
+  frames: vec4f,
+  blend: vec4f,
+  offset: u32,
+  frameStride: u32
+) -> vec4f {
+  let first = mix(
+    readGPUAnimationFrame(u32(frames.x), offset, frameStride),
+    readGPUAnimationFrame(u32(frames.y), offset, frameStride),
+    frames.z
+  );
+  if (blend.w <= 0.0) {
+    return first;
+  }
+  let second = mix(
+    readGPUAnimationFrame(u32(blend.x), offset, frameStride),
+    readGPUAnimationFrame(u32(blend.y), offset, frameStride),
+    blend.z
+  );
+  return mix(first, second, blend.w);
+}
+
+fn sampleGPUAnimationMatrix(
+  frames: vec4f,
+  blend: vec4f,
+  firstColumn: u32,
+  frameStride: u32
+) -> mat4x4f {
+  return mat4x4f(
+    sampleGPUAnimationFrame(frames, blend, firstColumn, frameStride),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 1u, frameStride),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 2u, frameStride),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 3u, frameStride)
+  );
+}
+
+fn getGPUAnimatedSkinMatrix(
+  weights: vec4f,
+  joints: vec4u,
+  frames: vec4f,
+  blend: vec4f,
+  frameStride: u32
+) -> mat4x4f {
+  return weights.x * sampleGPUAnimationMatrix(frames, blend, 4u + joints.x * 4u, frameStride)
+       + weights.y * sampleGPUAnimationMatrix(frames, blend, 4u + joints.y * 4u, frameStride)
+       + weights.z * sampleGPUAnimationMatrix(frames, blend, 4u + joints.z * 4u, frameStride)
+       + weights.w * sampleGPUAnimationMatrix(frames, blend, 4u + joints.w * 4u, frameStride);
+}
+#endif
+
+#ifdef HAS_INSTANCED_MORPH
+@group(0) @binding(auto) var<storage, read> gpuMorphTargets: array<vec4f>;
+
+#ifndef HAS_GPU_CROWD_ANIMATION
+@group(0) @binding(auto) var<storage, read> gpuMorphWeights: array<vec4f>;
+#endif
+
+fn getGPUCrowdMorphWeight(
+  instanceIndex: u32,
+  targetIndex: u32,
+  targetCount: u32,
+  jointsPerInstance: u32,
+  frames: vec4f,
+  blend: vec4f,
+  frameStride: u32
+) -> f32 {
+#ifdef HAS_GPU_CROWD_ANIMATION
+  let offset = 4u + jointsPerInstance * 4u + targetIndex;
+  return sampleGPUAnimationFrame(frames, blend, offset, frameStride).x;
+#else
+  let packedCount = (targetCount + 3u) / 4u;
+  let packedWeights = gpuMorphWeights[instanceIndex * packedCount + targetIndex / 4u];
+  return packedWeights[targetIndex % 4u];
+#endif
+}
+
+fn getGPUCrowdMorphDelta(
+  instanceIndex: u32,
+  vertexIndex: u32,
+  attributeIndex: u32,
+  vertexCount: u32,
+  targetCount: u32,
+  jointsPerInstance: u32,
+  frames: vec4f,
+  blend: vec4f,
+  frameStride: u32
+) -> vec3f {
+  var result = vec3f(0.0);
+  for (var targetIndex = 0u; targetIndex < targetCount; targetIndex++) {
+    let weight = getGPUCrowdMorphWeight(
+      instanceIndex,
+      targetIndex,
+      targetCount,
+      jointsPerInstance,
+      frames,
+      blend,
+      frameStride
+    );
+    let offset = (targetIndex * 3u + attributeIndex) * vertexCount + vertexIndex;
+    result += gpuMorphTargets[offset].xyz * weight;
+  }
+  return result;
+}
+#endif
+`;
+const vs = /* glsl */ `
+#ifdef HAS_GPU_CROWD_ANIMATION
+uniform highp sampler2D gpuAnimationFrames;
+
+vec4 sampleGPUAnimationFrame(vec4 frames, vec4 blend, int offset) {
+  vec4 first = mix(
+    texelFetch(gpuAnimationFrames, ivec2(offset, int(frames.x)), 0),
+    texelFetch(gpuAnimationFrames, ivec2(offset, int(frames.y)), 0),
+    frames.z
+  );
+  if (blend.w <= 0.0) {
+    return first;
+  }
+  vec4 second = mix(
+    texelFetch(gpuAnimationFrames, ivec2(offset, int(blend.x)), 0),
+    texelFetch(gpuAnimationFrames, ivec2(offset, int(blend.y)), 0),
+    blend.z
+  );
+  return mix(first, second, blend.w);
+}
+
+mat4 sampleGPUAnimationMatrix(vec4 frames, vec4 blend, int firstColumn) {
+  return mat4(
+    sampleGPUAnimationFrame(frames, blend, firstColumn),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 1),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 2),
+    sampleGPUAnimationFrame(frames, blend, firstColumn + 3)
+  );
+}
+
+mat4 getGPUAnimatedSkinMatrix(vec4 weights, uvec4 joints, vec4 frames, vec4 blend) {
+  return weights.x * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.x) * 4)
+       + weights.y * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.y) * 4)
+       + weights.z * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.z) * 4)
+       + weights.w * sampleGPUAnimationMatrix(frames, blend, 4 + int(joints.w) * 4);
+}
+#endif
+
+#ifdef HAS_INSTANCED_MORPH
+uniform highp sampler2D gpuMorphTargets;
+
+#ifndef HAS_GPU_CROWD_ANIMATION
+uniform highp sampler2D gpuMorphWeights;
+#endif
+
+float getGPUCrowdMorphWeight(
+  uint instanceIndex,
+  uint targetIndex,
+  uint jointsPerInstance,
+  vec4 frames,
+  vec4 blend
+) {
+#ifdef HAS_GPU_CROWD_ANIMATION
+  int offset = 4 + int(jointsPerInstance) * 4 + int(targetIndex);
+  return sampleGPUAnimationFrame(frames, blend, offset).x;
+#else
+  vec4 packedWeights = texelFetch(
+    gpuMorphWeights,
+    ivec2(int(targetIndex / 4u), int(instanceIndex)),
+    0
+  );
+  return packedWeights[int(targetIndex % 4u)];
+#endif
+}
+
+vec3 getGPUCrowdMorphDelta(
+  uint instanceIndex,
+  uint vertexIndex,
+  uint attributeIndex,
+  uint targetCount,
+  uint jointsPerInstance,
+  vec4 frames,
+  vec4 blend
+) {
+  vec3 result = vec3(0.0);
+  for (uint targetIndex = 0u; targetIndex < targetCount; targetIndex++) {
+    float weight = getGPUCrowdMorphWeight(
+      instanceIndex,
+      targetIndex,
+      jointsPerInstance,
+      frames,
+      blend
+    );
+    result += texelFetch(
+      gpuMorphTargets,
+      ivec2(int(vertexIndex), int(targetIndex * 3u + attributeIndex)),
+      0
+    ).xyz * weight;
+  }
+  return result;
+}
+#endif
+`;
+/** Portable baked clip sampling and independent per-instance morph deformation. */
+export const gpuAnimation = {
+    name: 'gpuAnimation',
+    props: {},
+    uniforms: {},
+    bindings: {},
+    source,
+    vs,
+    fs: '',
+    bindingLayout: [
+        { name: 'gpuAnimationFrames', group: 0, visibility: 1 },
+        { name: 'gpuMorphTargets', group: 0, visibility: 1 },
+        { name: 'gpuMorphWeights', group: 0, visibility: 1 }
+    ],
+    getUniforms(props = {}) {
+        return props;
+    }
+};
+//# sourceMappingURL=gpu-animation.js.map

package/dist/modules/engine/gpu-animation/gpu-animation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-animation.js","sourceRoot":"","sources":["../../../../src/modules/engine/gpu-animation/gpu-animation.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,4DAA4D;AAM5D,MAAM,MAAM,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgHzB,CAAC;AAEF,MAAM,EAAE,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4FrB,CAAC;AAYF,mFAAmF;AACnF,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,cAAc;IACpB,KAAK,EAAE,EAAuB;IAC9B,QAAQ,EAAE,EAAE;IACZ,QAAQ,EAAE,EAA0B;IACpC,MAAM;IACN,EAAE;IACF,EAAE,EAAE,EAAE;IACN,aAAa,EAAE;QACb,EAAC,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAC;QACrD,EAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAC;QAClD,EAAC,IAAI,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAC;KACnD;IACD,WAAW,CAAC,QAA2B,EAAE;QACvC,OAAO,KAAK,CAAC;IACf,CAAC;CAC2E,CAAC"}

package/dist/modules/engine/picking/picking.cjs

@@ -0,0 +1,210 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var picking_exports = {};
+__export(picking_exports, {
+  picking: () => picking
+});
+module.exports = __toCommonJS(picking_exports);
+var import_normalize_byte_colors = require("../../../lib/color/normalize-byte-colors.cjs");
+const DEFAULT_HIGHLIGHT_COLOR = [0, 1, 1, 1];
+const vs = (
+  /* glsl */
+  `layout(std140) uniform pickingUniforms {
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useByteColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
+} picking;
+
+out vec4 picking_vRGBcolor_Avalid;
+
+// Normalize unsigned byte color to 0-1 range
+vec3 picking_normalizeColor(vec3 color) {
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
+}
+
+// Normalize unsigned byte color to 0-1 range
+vec4 picking_normalizeColor(vec4 color) {
+  return picking.useByteColors > 0.5 ? color / 255.0 : color;
+}
+
+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_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 */
+  `layout(std140) uniform pickingUniforms {
+  float isActive;
+  float isAttribute;
+  float isHighlightActive;
+  float useByteColors;
+  vec3 highlightedObjectColor;
+  vec4 highlightColor;
+} picking;
+
+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);
+}
+`
+);
+const picking = {
+  props: {},
+  uniforms: {},
+  name: "picking",
+  uniformTypes: {
+    isActive: "f32",
+    isAttribute: "f32",
+    isHighlightActive: "f32",
+    useByteColors: "f32",
+    highlightedObjectColor: "vec3<f32>",
+    highlightColor: "vec4<f32>"
+  },
+  defaultUniforms: {
+    isActive: false,
+    isAttribute: false,
+    isHighlightActive: false,
+    useByteColors: true,
+    highlightedObjectColor: [0, 0, 0],
+    highlightColor: DEFAULT_HIGHLIGHT_COLOR
+  },
+  vs,
+  fs,
+  getUniforms
+};
+function getUniforms(opts = {}, prevUniforms) {
+  const uniforms = {};
+  const useByteColors = (0, import_normalize_byte_colors.resolveUseByteColors)(opts.useByteColors, true);
+  if (opts.highlightedObjectColor === void 0) {
+  } 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) {
+    uniforms.highlightColor = (0, import_normalize_byte_colors.normalizeByteColor4)(opts.highlightColor, useByteColors);
+  }
+  if (opts.isActive !== void 0) {
+    uniforms.isActive = Boolean(opts.isActive);
+    uniforms.isAttribute = Boolean(opts.isAttribute);
+  }
+  if (opts.useByteColors !== void 0) {
+    uniforms.useByteColors = Boolean(opts.useByteColors);
+  }
+  return uniforms;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  picking
+});

package/dist/modules/engine/picking/picking.d.ts

@@ -0,0 +1,77 @@
+import type { NumberArray3, NumberArray4 } from '@math.gl/core';
+/**
+ * Props for the picking module, which depending on mode renders picking colors or highlighted item.
+ * When active, renders picking colors, assumed to be rendered to off-screen "picking" buffer.
+ * When inactive, renders normal colors, with the exception of selected object which is rendered with highlight
+ */
+export type PickingProps = {
+    /** Are we picking? I.e. rendering picking colors? */
+    isActive?: boolean;
+    /** Set to true when picking an attribute value instead of object index */
+    isAttribute?: boolean;
+    /** Set to a picking color to visually highlight that item, or `null` to explicitly clear **/
+    highlightedObjectColor?: NumberArray3 | null;
+    /** Color of visual highlight of "selected" item */
+    highlightColor?: NumberArray3 | NumberArray4;
+    /** Interpret highlight colors as byte-style 0-255 values. */
+    useByteColors?: boolean;
+};
+/**
+ * Uniforms for the picking module, which renders picking colors and highlighted item.
+ * When active, renders picking colors, assumed to be rendered to off-screen "picking" buffer.
+ * When inactive, renders normal colors, with the exception of selected object which is rendered with highlight
+ */
+export type PickingUniforms = {
+    /**
+     * When true, renders picking colors. Set when rendering to off-screen "picking" buffer.
+     * When false, renders normal colors, with the exception of selected object which is rendered with highlight
+     */
+    isActive?: boolean;
+    /** Set to true when picking an attribute value instead of object index */
+    isAttribute?: boolean;
+    /** Interpret highlight colors as byte-style 0-255 values. */
+    useByteColors?: boolean;
+    /** Do we have a highlighted item? */
+    isHighlightActive?: boolean;
+    /** Set to a picking color to visually highlight that item */
+    highlightedObjectColor?: NumberArray3;
+    /** Color of visual highlight of "selected" item */
+    highlightColor?: NumberArray4;
+};
+/**
+ * Deprecated legacy picking module retained for compatibility with existing
+ * shaders users such as deck.gl. Keep the shader contract stable.
+ *
+ * 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 props: PickingProps;
+    readonly uniforms: PickingUniforms;
+    readonly name: "picking";
+    readonly uniformTypes: {
+        readonly isActive: "f32";
+        readonly isAttribute: "f32";
+        readonly isHighlightActive: "f32";
+        readonly useByteColors: "f32";
+        readonly highlightedObjectColor: "vec3<f32>";
+        readonly highlightColor: "vec4<f32>";
+    };
+    readonly defaultUniforms: {
+        readonly isActive: false;
+        readonly isAttribute: false;
+        readonly isHighlightActive: false;
+        readonly useByteColors: true;
+        readonly highlightedObjectColor: [0, 0, 0];
+        readonly highlightColor: NumberArray4;
+    };
+    readonly vs: "layout(std140) uniform pickingUniforms {\n  float isActive;\n  float isAttribute;\n  float isHighlightActive;\n  float useByteColors;\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.useByteColors > 0.5 ? color / 255.0 : color;\n}\n\n// Normalize unsigned byte color to 0-1 range\nvec4 picking_normalizeColor(vec4 color) {\n  return picking.useByteColors > 0.5 ? color / 255.0 : color;\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 useByteColors;\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: typeof getUniforms;
+};
+declare function getUniforms(opts?: PickingProps, prevUniforms?: PickingUniforms): PickingUniforms;
+export {};
+//# sourceMappingURL=picking.d.ts.map

package/dist/modules/engine/picking/picking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"picking.d.ts","sourceRoot":"","sources":["../../../../src/modules/engine/picking/picking.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,YAAY,EAAE,YAAY,EAAC,MAAM,eAAe,CAAC;AAM9D;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,0EAA0E;IAC1E,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,6FAA6F;IAC7F,sBAAsB,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7C,mDAAmD;IACnD,cAAc,CAAC,EAAE,YAAY,GAAG,YAAY,CAAC;IAC7C,6DAA6D;IAC7D,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,0EAA0E;IAC1E,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,6DAA6D;IAC7D,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,qCAAqC;IACrC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,6DAA6D;IAC7D,sBAAsB,CAAC,EAAE,YAAY,CAAC;IACtC,mDAAmD;IACnD,cAAc,CAAC,EAAE,YAAY,CAAC;CAC/B,CAAC;AAuIF;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO;oBACL,YAAY;uBACT,eAAe;;;;;;;;;;;;;;;;;;;;;CAwB+B,CAAC;AAEjE,iBAAS,WAAW,CAAC,IAAI,GAAE,YAAiB,EAAE,YAAY,CAAC,EAAE,eAAe,GAAG,eAAe,CA4B7F"}