@openhps/core/dist/cjs/three/nodes/utils/TriplanarTexturesNode.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.triplanarTextures = exports.triplanarTexture = exports.default = void 0;
var _Node = _interopRequireDefault(require("../core/Node.js"));
var _OperatorNode = require("../math/OperatorNode.js");
var _Normal = require("../accessors/Normal.js");
var _Position = require("../accessors/Position.js");
var _TextureNode = require("../accessors/TextureNode.js");
var _TSLBase = require("../tsl/TSLBase.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
 * Can be used for triplanar texture mapping.
 *
 * ```js
 * material.colorNode = triplanarTexture( texture( diffuseMap ) );
 * ```
 *
 * @augments Node
 */
class TriplanarTexturesNode extends _Node.default {
  static get type() {
    return 'TriplanarTexturesNode';
  }

  /**
   * Constructs a new triplanar textures node.
   *
   * @param {Node} textureXNode - First texture node.
   * @param {?Node} [textureYNode=null] - Second texture node. When not set, the shader will sample from `textureXNode` instead.
   * @param {?Node} [textureZNode=null] - Third texture node. When not set, the shader will sample from `textureXNode` instead.
   * @param {?Node<float>} [scaleNode=float(1)] - The scale node.
   * @param {?Node<vec3>} [positionNode=positionLocal] - Vertex positions in local space.
   * @param {?Node<vec3>} [normalNode=normalLocal] - Normals in local space.
   */
  constructor(textureXNode, textureYNode = null, textureZNode = null, scaleNode = (0, _TSLBase.float)(1), positionNode = _Position.positionLocal, normalNode = _Normal.normalLocal) {
    super('vec4');

    /**
     * First texture node.
     *
     * @type {Node}
     */
    this.textureXNode = textureXNode;

    /**
     * Second texture node. When not set, the shader will sample from `textureXNode` instead.
     *
     * @type {?Node}
     * @default null
     */
    this.textureYNode = textureYNode;

    /**
     * Third texture node. When not set, the shader will sample from `textureXNode` instead.
     *
     * @type {?Node}
     * @default null
     */
    this.textureZNode = textureZNode;

    /**
     * The scale node.
     *
     * @type {Node<float>}
     * @default float(1)
     */
    this.scaleNode = scaleNode;

    /**
     * Vertex positions in local space.
     *
     * @type {Node<vec3>}
     * @default positionLocal
     */
    this.positionNode = positionNode;

    /**
     * Normals in local space.
     *
     * @type {Node<vec3>}
     * @default normalLocal
     */
    this.normalNode = normalNode;
  }
  setup() {
    const {
      textureXNode,
      textureYNode,
      textureZNode,
      scaleNode,
      positionNode,
      normalNode
    } = this;

    // Ref: https://github.com/keijiro/StandardTriplanar

    // Blending factor of triplanar mapping
    let bf = normalNode.abs().normalize();
    bf = bf.div(bf.dot((0, _TSLBase.vec3)(1.0)));

    // Triplanar mapping
    const tx = positionNode.yz.mul(scaleNode);
    const ty = positionNode.zx.mul(scaleNode);
    const tz = positionNode.xy.mul(scaleNode);

    // Base color
    const textureX = textureXNode.value;
    const textureY = textureYNode !== null ? textureYNode.value : textureX;
    const textureZ = textureZNode !== null ? textureZNode.value : textureX;
    const cx = (0, _TextureNode.texture)(textureX, tx).mul(bf.x);
    const cy = (0, _TextureNode.texture)(textureY, ty).mul(bf.y);
    const cz = (0, _TextureNode.texture)(textureZ, tz).mul(bf.z);
    return (0, _OperatorNode.add)(cx, cy, cz);
  }
}
var _default = exports.default = TriplanarTexturesNode;
/**
 * TSL function for creating a triplanar textures node.
 *
 * @tsl
 * @function
 * @param {Node} textureXNode - First texture node.
 * @param {?Node} [textureYNode=null] - Second texture node. When not set, the shader will sample from `textureXNode` instead.
 * @param {?Node} [textureZNode=null] - Third texture node. When not set, the shader will sample from `textureXNode` instead.
 * @param {?Node<float>} [scaleNode=float(1)] - The scale node.
 * @param {?Node<vec3>} [positionNode=positionLocal] - Vertex positions in local space.
 * @param {?Node<vec3>} [normalNode=normalLocal] - Normals in local space.
 * @returns {TriplanarTexturesNode}
 */
const triplanarTextures = exports.triplanarTextures = /*@__PURE__*/(0, _TSLBase.nodeProxy)(TriplanarTexturesNode).setParameterLength(1, 6);

/**
 * TSL function for creating a triplanar textures node.
 *
 * @tsl
 * @function
 * @param {Node} textureXNode - First texture node.
 * @param {?Node} [textureYNode=null] - Second texture node. When not set, the shader will sample from `textureXNode` instead.
 * @param {?Node} [textureZNode=null] - Third texture node. When not set, the shader will sample from `textureXNode` instead.
 * @param {?Node<float>} [scaleNode=float(1)] - The scale node.
 * @param {?Node<vec3>} [positionNode=positionLocal] - Vertex positions in local space.
 * @param {?Node<vec3>} [normalNode=normalLocal] - Normals in local space.
 * @returns {TriplanarTexturesNode}
 */
const triplanarTexture = (...params) => triplanarTextures(...params);
exports.triplanarTexture = triplanarTexture;