@openhps/core/dist/cjs/three/materials/nodes/PointsNodeMaterial.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _SpriteNodeMaterial = _interopRequireDefault(require("./SpriteNodeMaterial.js"));
var _ScreenNode = require("../../nodes/display/ScreenNode.js");
var _Position = require("../../nodes/accessors/Position.js");
var _ModelNode = require("../../nodes/accessors/ModelNode.js");
var _MaterialNode = require("../../nodes/accessors/MaterialNode.js");
var _RotateNode = require("../../nodes/utils/RotateNode.js");
var _TSLBase = require("../../nodes/tsl/TSLBase.js");
var _PointsMaterial = require("../PointsMaterial.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const _defaultValues = /*@__PURE__*/new _PointsMaterial.PointsMaterial();

/**
 * Node material version of {@link PointsMaterial}.
 *
 * @augments SpriteNodeMaterial
 */
class PointsNodeMaterial extends _SpriteNodeMaterial.default {
  static get type() {
    return 'PointsNodeMaterial';
  }

  /**
   * Constructs a new points node material.
   *
   * @param {Object} [parameters] - The configuration parameter.
   */
  constructor(parameters) {
    super();

    /**
     * This node property provides an additional way to set the point size.
     *
     * @type {?Node<vec2>}
     * @default null
     */
    this.sizeNode = null;

    /**
     * This flag can be used for type testing.
     *
     * @type {boolean}
     * @readonly
     * @default true
     */
    this.isPointsNodeMaterial = true;
    this.setDefaultValues(_defaultValues);
    this.setValues(parameters);
  }
  setupPositionView() {
    const {
      positionNode
    } = this;
    return _ModelNode.modelViewMatrix.mul((0, _TSLBase.vec3)(positionNode || _Position.positionLocal)).xyz;
  }
  setupVertex(builder) {
    const mvp = super.setupVertex(builder);

    // skip further processing if the material is not a node material

    if (builder.material.isNodeMaterial !== true) {
      return mvp;
    }

    // ndc space

    const {
      rotationNode,
      scaleNode,
      sizeNode
    } = this;
    const alignedPosition = _Position.positionGeometry.xy.toVar();
    const aspect = _ScreenNode.viewport.z.div(_ScreenNode.viewport.w);

    // rotation

    if (rotationNode && rotationNode.isNode) {
      const rotation = (0, _TSLBase.float)(rotationNode);
      alignedPosition.assign((0, _RotateNode.rotate)(alignedPosition, rotation));
    }

    // point size

    let pointSize = sizeNode !== null ? (0, _TSLBase.vec2)(sizeNode) : _MaterialNode.materialPointSize;
    if (this.sizeAttenuation === true) {
      pointSize = pointSize.mul(pointSize.div(_Position.positionView.z.negate()));
    }

    // scale

    if (scaleNode && scaleNode.isNode) {
      pointSize = pointSize.mul((0, _TSLBase.vec2)(scaleNode));
    }
    alignedPosition.mulAssign(pointSize.mul(2));
    alignedPosition.assign(alignedPosition.div(_ScreenNode.viewport.z));
    alignedPosition.y.assign(alignedPosition.y.mul(aspect));

    // back to clip space
    alignedPosition.assign(alignedPosition.mul(mvp.w));

    //clipPos.xy += offset;
    mvp.addAssign((0, _TSLBase.vec4)(alignedPosition, 0, 0));
    return mvp;
  }

  /**
   * Whether alpha to coverage should be used or not.
   *
   * @type {boolean}
   * @default true
   */
  get alphaToCoverage() {
    return this._useAlphaToCoverage;
  }
  set alphaToCoverage(value) {
    if (this._useAlphaToCoverage !== value) {
      this._useAlphaToCoverage = value;
      this.needsUpdate = true;
    }
  }
}
var _default = exports.default = PointsNodeMaterial;