Metadata picking preparation

packages/engine/Source/Renderer/DrawCommand.js

@@ -40,6 +40,8 @@ function DrawCommand(options) {
   this._owner = options.owner;
   this._debugOverlappingFrustums = 0;
   this._pickId = options.pickId;
+  this._pickMetadataAllowed = options.pickMetadataAllowed === true;
+  this._pickedMetadataInfo = undefined;
 
   // Set initial flags.
   this._flags = 0;
@@ -511,7 +513,7 @@ Object.defineProperties(DrawCommand.prototype, {
    * during the pick pass.
    *
    * @memberof DrawCommand.prototype
-   * @type {string}
+   * @type {string|undefined}
    * @default undefined
    */
   pickId: {
@@ -525,6 +527,40 @@ Object.defineProperties(DrawCommand.prototype, {
       }
     },
   },
+
+  /**
+   * Whether metadata picking is allowed
+   *
+   * @memberof DrawCommand.prototype
+   * @type {boolean}
+   * @default undefined
+   * @private
+   */
+  pickMetadataAllowed: {
+    get: function () {
+      return this._pickMetadataAllowed;
+    },
+  },
+
+  /**
+   * Information about picked metadata.
+   *
+   * @memberof DrawCommand.prototype
+   * @type {PickedMetadataInfo|undefined}
+   * @default undefined
+   */
+  pickedMetadataInfo: {
+    get: function () {
+      return this._pickedMetadataInfo;
+    },
+    set: function (value) {
+      if (this._pickedMetadataInfo !== value) {
+        this._pickedMetadataInfo = value;
+        this.dirty = true;
+      }
+    },
+  },
+
   /**
    * Whether this command should be executed in the pick pass only.
    *
@@ -590,6 +626,8 @@ DrawCommand.shallowClone = function (command, result) {
   result._owner = command._owner;
   result._debugOverlappingFrustums = command._debugOverlappingFrustums;
   result._pickId = command._pickId;
+  result._pickMetadataAllowed = command._pickMetadataAllowed;
+  result._pickedMetadataInfo = command._pickedMetadataInfo;
   result._flags = command._flags;
 
   result.dirty = true;

packages/engine/Source/Scene/DerivedCommand.js

@@ -2,6 +2,7 @@ import defined from "../Core/defined.js";
 import DrawCommand from "../Renderer/DrawCommand.js";
 import RenderState from "../Renderer/RenderState.js";
 import ShaderSource from "../Renderer/ShaderSource.js";
+import MetadataType from "./MetadataType.js";
 
 /**
  * @private
@@ -375,6 +376,179 @@ DerivedCommand.createPickDerivedCommand = function (
   return result;
 };
 
+/**
+ * @private
+ */
+function replaceDefine(defines, defineName, newDefineValue) {
+  const n = defines.length;
+  for (let i = 0; i < n; i++) {
+    if (defines[i].startsWith(defineName)) {
+      defines[i] = `${defineName} ${newDefineValue}`;
+    }
+  }
+}
+
+/**
+ * @private
+ */
+function getComponentCount(classProperty) {
+  if (!classProperty.isArray) {
+    return MetadataType.getComponentCount(classProperty.type);
+  }
+  return classProperty.arrayLength;
+}
+function getGlslType(classProperty) {
+  const componentCount = getComponentCount(classProperty);
+  if (classProperty.normalized) {
+    if (componentCount === 1) {
+      return "float";
+    }
+    return `vec${componentCount}`;
+  }
+  if (componentCount === 1) {
+    return "int";
+  }
+  return `ivec${componentCount}`;
+}
+
+/**
+ * @private
+ */
+function getPickMetadataShaderProgram(
+  context,
+  shaderProgram,
+  pickedMetadataInfo
+) {
+  const schemaId = pickedMetadataInfo.schemaId;
+  const className = pickedMetadataInfo.className;
+  const propertyName = pickedMetadataInfo.propertyName;
+  const keyword = `pickMetadata-${schemaId}-${className}-${propertyName}`;
+  let shader = context.shaderCache.getDerivedShaderProgram(
+    shaderProgram,
+    keyword
+  );
+  if (defined(shader)) {
+    return shader;
+  }
+
+  const classProperty = pickedMetadataInfo.classProperty;
+  const glslType = getGlslType(classProperty);
+
+  // Define the components that will go into the output `metadataValues`.
+  // By default, all of them are 0.0.
+  const sourceValueStrings = ["0.0", "0.0", "0.0", "0.0"];
+  const componentCount = getComponentCount(classProperty);
+  if (componentCount === 1) {
+    // When the property is a scalar, store its value directly
+    // in `metadataValues.x`
+    sourceValueStrings[0] = `float(value)`;
+  } else {
+    // When the property is an array, store the array elements
+    // in `metadataValues.x/y/z/w`
+    const components = ["x", "y", "z", "w"];
+    for (let i = 0; i < componentCount; i++) {
+      const component = components[i];
+      const valueString = `value.${component}`;
+      sourceValueStrings[i] = `float(${valueString})`;
+    }
+  }
+
+  // Make sure that the `metadataValues` components are all in
+  // the range [0, 1] (which will result in RGBA components
+  // in [0, 255] during rendering)
+  if (!classProperty.normalized) {
+    for (let i = 0; i < componentCount; i++) {
+      sourceValueStrings[i] += " / 255.0";
+    }
+  }
+
+  let fs = shaderProgram.fragmentShaderSource;
+  const newDefines = [...fs.defines];
+  newDefines.push("METADATA_PICKING_ENABLED");
+
+  // Replace the defines of the shader, using the type, property
+  // access, and value components  that have been determined
+  replaceDefine(newDefines, "METADATA_PICKING_VALUE_TYPE", glslType);
+  replaceDefine(
+    newDefines,
+    "METADATA_PICKING_VALUE_STRING",
+    `metadata.${propertyName}`
+  );
+  replaceDefine(
+    newDefines,
+    "METADATA_PICKING_VALUE_COMPONENT_X",
+    sourceValueStrings[0]
+  );
+  replaceDefine(
+    newDefines,
+    "METADATA_PICKING_VALUE_COMPONENT_Y",
+    sourceValueStrings[1]
+  );
+  replaceDefine(
+    newDefines,
+    "METADATA_PICKING_VALUE_COMPONENT_Z",
+    sourceValueStrings[2]
+  );
+  replaceDefine(
+    newDefines,
+    "METADATA_PICKING_VALUE_COMPONENT_W",
+    sourceValueStrings[3]
+  );
+
+  // XXX_METADATA_PICKING
+  //*/
+  console.log("newDefines");
+  for (const d of newDefines) {
+    console.log(d);
+  }
+  //*/
+  fs = new ShaderSource({
+    sources: fs.sources,
+    defines: newDefines,
+  });
+  shader = context.shaderCache.createDerivedShaderProgram(
+    shaderProgram,
+    keyword,
+    {
+      vertexShaderSource: shaderProgram.vertexShaderSource,
+      fragmentShaderSource: fs,
+      attributeLocations: shaderProgram._attributeLocations,
+    }
+  );
+  return shader;
+}
+
+/**
+ * @private
+ */
+DerivedCommand.createPickMetadataDerivedCommand = function (
+  scene,
+  command,
+  context,
+  result
+) {
+  if (!defined(result)) {
+    result = {};
+  }
+  result.pickMetadataCommand = DrawCommand.shallowClone(
+    command,
+    result.pickMetadataCommand
+  );
+
+  result.pickMetadataCommand.shaderProgram = getPickMetadataShaderProgram(
+    context,
+    command.shaderProgram,
+    command.pickedMetadataInfo
+  );
+  result.pickMetadataCommand.renderState = getPickRenderState(
+    scene,
+    command.renderState
+  );
+  result.shaderProgramId = command.shaderProgram.id;
+
+  return result;
+};
+
 function getHdrShaderProgram(context, shaderProgram) {
   let shader = context.shaderCache.getDerivedShaderProgram(
     shaderProgram,

packages/engine/Source/Scene/FrameState.js

@@ -421,6 +421,37 @@ function FrameState(context, creditDisplay, jobScheduler) {
    * @default 0.0
    */
   this.minimumTerrainHeight = 0.0;
+
+  /**
+   * Whether metadata picking is currently in progress.
+   *
+   * This is set to `true` in the `Picking.pickMetadata` function,
+   * immediately before updating and executing the draw commands,
+   * and set back to `false` immediately afterwards. It will be
+   * used to determine whether the metadata picking draw commands
+   * should be executed, in the `Scene.executeCommand` function.
+   *
+   * @type {boolean}
+   * @default false
+   */
+  this.pickingMetadata = false;
+
+  /**
+   * Metadata picking information.
+   *
+   * This describes the metadata property that is supposed to be picked
+   * in a `Picking.pickMetadata` call.
+   *
+   * This is stored in the frame state and in the metadata picking draw
+   * commands. In the `Scene.updateDerivedCommands` call, it will be
+   * checked whether the instance that is stored in the frame state
+   * is different from the one in the draw command, and if necessary,
+   * the derived commands for metadata picking will be updated based
+   * on this information.
+   *
+   * @type {PickedMetadataInfo|undefined}
+   */
+  this.pickedMetadataInfo = undefined;
 }
 
 /**

packages/engine/Source/Scene/MetadataPicking.js

@@ -0,0 +1,105 @@
+import MetadataComponentType from "./MetadataComponentType.js";
+
+/**
+ * Utility functions for metadata picking.
+ *
+ * These are used by the `Picking.pickMetadata` function to decode
+ * the metadata values that have been read from the frame buffer
+ * into the actual metadata values, according to the structure
+ * defined by the `MetadataClassProperty`.
+ *
+ * This is marked as 'private', but supposed to be used in Picking.js.
+ *
+ * @private
+ */
+function MetadataPicking() {}
+
+/**
+ * Returns the value at the specified inded of the given data view,
+ * interpreting the data to have the given component type.
+ *
+ * @param {MetadataComponentType} componentType The `MetadataComponentType`
+ * @param {DataView} dataView The data view
+ * @param {number} index The index
+ * @returns {number|bigint|undefined} The value
+ *
+ * @private
+ */
+MetadataPicking.decodeMetadataValue = function (
+  componentType,
+  dataView,
+  index
+) {
+  switch (componentType) {
+    case MetadataComponentType.INT8:
+      return dataView.getInt8(index);
+    case MetadataComponentType.UINT8:
+      return dataView.getUint8(index);
+    case MetadataComponentType.INT16:
+      return dataView.getInt16(index);
+    case MetadataComponentType.UINT16:
+      return dataView.getUint16(index);
+    case MetadataComponentType.INT32:
+      return dataView.getInt32(index);
+    case MetadataComponentType.UINT32:
+      return dataView.getUint32(index);
+    case MetadataComponentType.INT64:
+      return dataView.getBigInt64(index);
+    case MetadataComponentType.UINT64:
+      return dataView.getBigUint64(index);
+    case MetadataComponentType.FLOAT32:
+      return dataView.getFloat32(index);
+    case MetadataComponentType.FLOAT64:
+      return dataView.getFloat64(index);
+  }
+  // Appropriate error handling?
+  return undefined;
+};
+
+/**
+ * Decode the given raw values into a metadata property value.
+ *
+ * The given values are a `Uint8Array` containing the RGBA
+ * values that have been read from the metadata picking
+ * frame buffer. They are assumed to contain the value for
+ * the given class property, as encoded by the
+ * `ModelDrawCommands` for metadata picking.
+ *
+ * @param {MetadataClassProperty} classProperty The `MetadataClassProperty`
+ * @param {Uint8Array} rawValues The raw values
+ * @returns {number|bigint|undefined} The value
+ *
+ * @private
+ */
+MetadataPicking.decodeMetadataValues = function (classProperty, rawValues) {
+  const componentType = classProperty.componentType;
+  const dataView = new DataView(
+    rawValues.buffer,
+    rawValues.byteOffset,
+    rawValues.byteLength
+  );
+  if (classProperty.isArray) {
+    const arrayLength = classProperty.arrayLength;
+    const result = Array(arrayLength);
+    for (let i = 0; i < arrayLength; i++) {
+      const element = MetadataPicking.decodeMetadataValue(
+        componentType,
+        dataView,
+        i
+      );
+      if (classProperty.normalized) {
+        result[i] = element / 255.0;
+      } else {
+        result[i] = element;
+      }
+    }
+    return result;
+  }
+  const value = MetadataPicking.decodeMetadataValue(componentType, dataView, 0);
+  if (classProperty.normalized) {
+    return value / 255.0;
+  }
+  return value;
+};
+
+export default Object.freeze(MetadataPicking);