@openhps/core/src/three/nodes/core/VarNode.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.temp = exports.default = exports.Var = exports.Const = void 0;
var _Node = _interopRequireDefault(require("./Node.js"));
var _TSLCore = require("../tsl/TSLCore.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
 * Class for representing shader variables as nodes. Variables are created from
 * existing nodes like the following:
 *
 * ```js
 * const depth = sampleDepth( uvNode ).toVar( 'depth' );
 * ```
 *
 * @augments Node
 */
class VarNode extends _Node.default {
  static get type() {
    return 'VarNode';
  }

  /**
   * Constructs a new variable node.
   *
   * @param {Node} node - The node for which a variable should be created.
   * @param {?string} [name=null] - The name of the variable in the shader.
   * @param {boolean} [readOnly=false] - The read-only flag.
   */
  constructor(node, name = null, readOnly = false) {
    super();

    /**
     * The node for which a variable should be created.
     *
     * @type {Node}
     */
    this.node = node;

    /**
     * The name of the variable in the shader. If no name is defined,
     * the node system auto-generates one.
     *
     * @type {?string}
     * @default null
     */
    this.name = name;

    /**
     * `VarNode` sets this property to `true` by default.
     *
     * @type {boolean}
     * @default true
     */
    this.global = true;

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

    /**
     *
     * The read-only flag.
     *
     * @type {boolean}
     * @default false
     */
    this.readOnly = readOnly;
  }
  getMemberType(builder, name) {
    return this.node.getMemberType(builder, name);
  }
  getElementType(builder) {
    return this.node.getElementType(builder);
  }
  getNodeType(builder) {
    return this.node.getNodeType(builder);
  }
  generate(builder) {
    const {
      node,
      name,
      readOnly
    } = this;
    const {
      renderer
    } = builder;
    const isWebGPUBackend = renderer.backend.isWebGPUBackend === true;
    let isDeterministic = false;
    let shouldTreatAsReadOnly = false;
    if (readOnly) {
      isDeterministic = builder.isDeterministic(node);
      shouldTreatAsReadOnly = isWebGPUBackend ? readOnly : isDeterministic;
    }
    const vectorType = builder.getVectorType(this.getNodeType(builder));
    const snippet = node.build(builder, vectorType);
    const nodeVar = builder.getVarFromNode(this, name, vectorType, undefined, shouldTreatAsReadOnly);
    const propertyName = builder.getPropertyName(nodeVar);
    let declarationPrefix = propertyName;
    if (shouldTreatAsReadOnly) {
      if (isWebGPUBackend) {
        declarationPrefix = isDeterministic ? `const ${propertyName}` : `let ${propertyName}`;
      } else {
        const count = builder.getArrayCount(node);
        declarationPrefix = `const ${builder.getVar(nodeVar.type, propertyName, count)}`;
      }
    }
    builder.addLineFlowCode(`${declarationPrefix} = ${snippet}`, this);
    return propertyName;
  }
}
var _default = exports.default = VarNode;
/**
 * TSL function for creating a var node.
 *
 * @tsl
 * @function
 * @param {Node} node - The node for which a variable should be created.
 * @param {?string} name - The name of the variable in the shader.
 * @returns {VarNode}
 */
const createVar = /*@__PURE__*/(0, _TSLCore.nodeProxy)(VarNode);

/**
 * TSL function for creating a var node.
 *
 * @tsl
 * @function
 * @param {Node} node - The node for which a variable should be created.
 * @param {?string} name - The name of the variable in the shader.
 * @returns {VarNode}
 */
const Var = (node, name = null) => createVar(node, name).append();

/**
 * TSL function for creating a const node.
 *
 * @tsl
 * @function
 * @param {Node} node - The node for which a constant should be created.
 * @param {?string} name - The name of the constant in the shader.
 * @returns {VarNode}
 */
exports.Var = Var;
const Const = (node, name = null) => createVar(node, name, true).append();

// Method chaining
exports.Const = Const;
(0, _TSLCore.addMethodChaining)('toVar', Var);
(0, _TSLCore.addMethodChaining)('toConst', Const);

// Deprecated

/**
 * @tsl
 * @function
 * @deprecated since r170. Use `Var( node )` or `node.toVar()` instead.
 *
 * @param {any} node
 * @returns {VarNode}
 */
const temp = node => {
  // @deprecated, r170

  console.warn('TSL: "temp( node )" is deprecated. Use "Var( node )" or "node.toVar()" instead.');
  return createVar(node);
};
exports.temp = temp;
(0, _TSLCore.addMethodChaining)('temp', temp);