@openhps/core/src/three/nodes/code/FunctionCallNode.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = exports.call = void 0;
var _TempNode = _interopRequireDefault(require("../core/TempNode.js"));
var _TSLCore = require("../tsl/TSLCore.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
 * This module represents the call of a {@link FunctionNode}. Developers are usually not confronted
 * with this module since they use the predefined TSL syntax `wgslFn` and `glslFn` which encapsulate
 * this logic.
 *
 * @augments TempNode
 */
class FunctionCallNode extends _TempNode.default {
  static get type() {
    return 'FunctionCallNode';
  }

  /**
   * Constructs a new function call node.
   *
   * @param {?FunctionNode} functionNode - The function node.
   * @param {Object<string, Node>} [parameters={}] - The parameters for the function call.
   */
  constructor(functionNode = null, parameters = {}) {
    super();

    /**
     * The function node.
     *
     * @type {?FunctionNode}
     * @default null
     */
    this.functionNode = functionNode;

    /**
     * The parameters of the function call.
     *
     * @type {Object<string, Node>}
     * @default {}
     */
    this.parameters = parameters;
  }

  /**
   * Sets the parameters of the function call node.
   *
   * @param {Object<string, Node>} parameters - The parameters to set.
   * @return {FunctionCallNode} A reference to this node.
   */
  setParameters(parameters) {
    this.parameters = parameters;
    return this;
  }

  /**
   * Returns the parameters of the function call node.
   *
   * @return {Object<string, Node>} The parameters of this node.
   */
  getParameters() {
    return this.parameters;
  }
  getNodeType(builder) {
    return this.functionNode.getNodeType(builder);
  }
  generate(builder) {
    const params = [];
    const functionNode = this.functionNode;
    const inputs = functionNode.getInputs(builder);
    const parameters = this.parameters;
    const generateInput = (node, inputNode) => {
      const type = inputNode.type;
      const pointer = type === 'pointer';
      let output;
      if (pointer) output = '&' + node.build(builder);else output = node.build(builder, type);
      return output;
    };
    if (Array.isArray(parameters)) {
      if (parameters.length > inputs.length) {
        console.error('THREE.TSL: The number of provided parameters exceeds the expected number of inputs in \'Fn()\'.');
        parameters.length = inputs.length;
      } else if (parameters.length < inputs.length) {
        console.error('THREE.TSL: The number of provided parameters is less than the expected number of inputs in \'Fn()\'.');
        while (parameters.length < inputs.length) {
          parameters.push((0, _TSLCore.float)(0));
        }
      }
      for (let i = 0; i < parameters.length; i++) {
        params.push(generateInput(parameters[i], inputs[i]));
      }
    } else {
      for (const inputNode of inputs) {
        const node = parameters[inputNode.name];
        if (node !== undefined) {
          params.push(generateInput(node, inputNode));
        } else {
          console.error(`THREE.TSL: Input '${inputNode.name}' not found in \'Fn()\'.`);
          params.push(generateInput((0, _TSLCore.float)(0), inputNode));
        }
      }
    }
    const functionName = functionNode.build(builder, 'property');
    return `${functionName}( ${params.join(', ')} )`;
  }
}
var _default = exports.default = FunctionCallNode;
const call = (func, ...params) => {
  params = params.length > 1 || params[0] && params[0].isNode === true ? (0, _TSLCore.nodeArray)(params) : (0, _TSLCore.nodeObjects)(params[0]);
  return (0, _TSLCore.nodeObject)(new FunctionCallNode((0, _TSLCore.nodeObject)(func), params));
};
exports.call = call;
(0, _TSLCore.addMethodChaining)('call', call);