@openhps/core/src/three/nodes/utils/StorageArrayElementNode.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.storageElement = exports.default = void 0;
var _TSLBase = require("../tsl/TSLBase.js");
var _ArrayElementNode = _interopRequireDefault(require("./ArrayElementNode.js"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
 * This class enables element access on instances of {@link StorageBufferNode}.
 * In most cases, it is indirectly used when accessing elements with the
 * {@link StorageBufferNode#element} method.
 *
 * ```js
 * const position = positionStorage.element( instanceIndex );
 * ```
 *
 * @augments ArrayElementNode
 */
class StorageArrayElementNode extends _ArrayElementNode.default {
  static get type() {
    return 'StorageArrayElementNode';
  }

  /**
   * Constructs storage buffer element node.
   *
   * @param {StorageBufferNode} storageBufferNode - The storage buffer node.
   * @param {Node} indexNode - The index node that defines the element access.
   */
  constructor(storageBufferNode, indexNode) {
    super(storageBufferNode, indexNode);

    /**
     * This flag can be used for type testing.
     *
     * @type {boolean}
     * @readonly
     * @default true
     */
    this.isStorageArrayElementNode = true;
  }

  /**
   * The storage buffer node.
   *
   * @param {Node} value
   * @type {StorageBufferNode}
   */
  set storageBufferNode(value) {
    this.node = value;
  }
  get storageBufferNode() {
    return this.node;
  }
  getMemberType(builder, name) {
    const structTypeNode = this.storageBufferNode.structTypeNode;
    if (structTypeNode) {
      return structTypeNode.getMemberType(builder, name);
    }
    return 'void';
  }
  setup(builder) {
    if (builder.isAvailable('storageBuffer') === false) {
      if (this.node.isPBO === true) {
        builder.setupPBO(this.node);
      }
    }
    return super.setup(builder);
  }
  generate(builder, output) {
    let snippet;
    const isAssignContext = builder.context.assign;

    //

    if (builder.isAvailable('storageBuffer') === false) {
      if (this.node.isPBO === true && isAssignContext !== true && (this.node.value.isInstancedBufferAttribute || builder.shaderStage !== 'compute')) {
        snippet = builder.generatePBO(this);
      } else {
        snippet = this.node.build(builder);
      }
    } else {
      snippet = super.generate(builder);
    }
    if (isAssignContext !== true) {
      const type = this.getNodeType(builder);
      snippet = builder.format(snippet, type, output);
    }
    return snippet;
  }
}
var _default = exports.default = StorageArrayElementNode;
/**
 * TSL function for creating a storage element node.
 *
 * @tsl
 * @function
 * @param {StorageBufferNode} storageBufferNode - The storage buffer node.
 * @param {Node} indexNode - The index node that defines the element access.
 * @returns {StorageArrayElementNode}
 */
const storageElement = exports.storageElement = /*@__PURE__*/(0, _TSLBase.nodeProxy)(StorageArrayElementNode).setParameterLength(2);