@openhps/core/dist/cjs/three/nodes/display/ScreenNode.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.viewportUV = exports.viewportTopLeft = exports.viewportSize = exports.viewportResolution = exports.viewportCoordinate = exports.viewportBottomLeft = exports.viewport = exports.screenUV = exports.screenSize = exports.screenCoordinate = exports.default = void 0;
var _Node = _interopRequireDefault(require("../core/Node.js"));
var _constants = require("../core/constants.js");
var _UniformNode = require("../core/UniformNode.js");
var _TSLBase = require("../tsl/TSLBase.js");
var _Vector = require("../../math/Vector2.js");
var _Vector2 = require("../../math/Vector4.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
let screenSizeVec, viewportVec;

/**
 * This node provides a collection of screen related metrics.
 * Depending on {@link ScreenNode#scope}, the nodes can represent
 * resolution or viewport data as well as fragment or uv coordinates.
 *
 * @augments Node
 */
class ScreenNode extends _Node.default {
  static get type() {
    return 'ScreenNode';
  }

  /**
   * Constructs a new screen node.
   *
   * @param {('coordinate'|'viewport'|'size'|'uv')} scope - The node's scope.
   */
  constructor(scope) {
    super();

    /**
     * The node represents different metric depending on which scope is selected.
     *
     * - `ScreenNode.COORDINATE`: Window-relative coordinates of the current fragment according to WebGPU standards.
     * - `ScreenNode.VIEWPORT`: The current viewport defined as a four-dimensional vector.
     * - `ScreenNode.SIZE`: The dimensions of the current bound framebuffer.
     * - `ScreenNode.UV`: Normalized coordinates.
     *
     * @type {('coordinate'|'viewport'|'size'|'uv')}
     */
    this.scope = scope;

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

  /**
   * This method is overwritten since the node type depends on the selected scope.
   *
   * @return {('vec2'|'vec4')} The node type.
   */
  getNodeType() {
    if (this.scope === ScreenNode.VIEWPORT) return 'vec4';else return 'vec2';
  }

  /**
   * This method is overwritten since the node's update type depends on the selected scope.
   *
   * @return {NodeUpdateType} The update type.
   */
  getUpdateType() {
    let updateType = _constants.NodeUpdateType.NONE;
    if (this.scope === ScreenNode.SIZE || this.scope === ScreenNode.VIEWPORT) {
      updateType = _constants.NodeUpdateType.RENDER;
    }
    this.updateType = updateType;
    return updateType;
  }

  /**
   * `ScreenNode` implements {@link Node#update} to retrieve viewport and size information
   * from the current renderer.
   *
   * @param {NodeFrame} frame - A reference to the current node frame.
   */
  update({
    renderer
  }) {
    const renderTarget = renderer.getRenderTarget();
    if (this.scope === ScreenNode.VIEWPORT) {
      if (renderTarget !== null) {
        viewportVec.copy(renderTarget.viewport);
      } else {
        renderer.getViewport(viewportVec);
        viewportVec.multiplyScalar(renderer.getPixelRatio());
      }
    } else {
      if (renderTarget !== null) {
        screenSizeVec.width = renderTarget.width;
        screenSizeVec.height = renderTarget.height;
      } else {
        renderer.getDrawingBufferSize(screenSizeVec);
      }
    }
  }
  setup( /*builder*/
  ) {
    const scope = this.scope;
    let output = null;
    if (scope === ScreenNode.SIZE) {
      output = (0, _UniformNode.uniform)(screenSizeVec || (screenSizeVec = new _Vector.Vector2()));
    } else if (scope === ScreenNode.VIEWPORT) {
      output = (0, _UniformNode.uniform)(viewportVec || (viewportVec = new _Vector2.Vector4()));
    } else {
      output = (0, _TSLBase.vec2)(screenCoordinate.div(screenSize));
    }
    return output;
  }
  generate(builder) {
    if (this.scope === ScreenNode.COORDINATE) {
      let coord = builder.getFragCoord();
      if (builder.isFlipY()) {
        // follow webgpu standards

        const size = builder.getNodeProperties(screenSize).outputNode.build(builder);
        coord = `${builder.getType('vec2')}( ${coord}.x, ${size}.y - ${coord}.y )`;
      }
      return coord;
    }
    return super.generate(builder);
  }
}
ScreenNode.COORDINATE = 'coordinate';
ScreenNode.VIEWPORT = 'viewport';
ScreenNode.SIZE = 'size';
ScreenNode.UV = 'uv';
var _default = exports.default = ScreenNode; // Screen
/**
 * TSL object that represents normalized screen coordinates, unitless in `[0, 1]`.
 *
 * @tsl
 * @type {ScreenNode<vec2>}
 */
const screenUV = exports.screenUV = /*@__PURE__*/(0, _TSLBase.nodeImmutable)(ScreenNode, ScreenNode.UV);

/**
 * TSL object that represents the screen resolution in physical pixel units.
 *
 * @tsl
 * @type {ScreenNode<vec2>}
 */
const screenSize = exports.screenSize = /*@__PURE__*/(0, _TSLBase.nodeImmutable)(ScreenNode, ScreenNode.SIZE);

/**
 * TSL object that represents the current `x`/`y` pixel position on the screen in physical pixel units.
 *
 * @tsl
 * @type {ScreenNode<vec2>}
 */
const screenCoordinate = exports.screenCoordinate = /*@__PURE__*/(0, _TSLBase.nodeImmutable)(ScreenNode, ScreenNode.COORDINATE);

// Viewport

/**
 * TSL object that represents the viewport rectangle as `x`, `y`, `width` and `height` in physical pixel units.
 *
 * @tsl
 * @type {ScreenNode<vec4>}
 */
const viewport = exports.viewport = /*@__PURE__*/(0, _TSLBase.nodeImmutable)(ScreenNode, ScreenNode.VIEWPORT);

/**
 * TSL object that represents the viewport resolution in physical pixel units.
 *
 * @tsl
 * @type {ScreenNode<vec2>}
 */
const viewportSize = exports.viewportSize = viewport.zw;

/**
 * TSL object that represents the current `x`/`y` pixel position on the viewport in physical pixel units.
 *
 * @tsl
 * @type {ScreenNode<vec2>}
 */
const viewportCoordinate = exports.viewportCoordinate = /*@__PURE__*/screenCoordinate.sub(viewport.xy);

/**
 * TSL object that represents normalized viewport coordinates, unitless in `[0, 1]`.
 *
 * @tsl
 * @type {ScreenNode<vec2>}
 */
const viewportUV = exports.viewportUV = /*@__PURE__*/viewportCoordinate.div(viewportSize);

// Deprecated

/**
 * @deprecated since r169. Use {@link screenSize} instead.
 */
const viewportResolution = exports.viewportResolution = /*@__PURE__*/(0, _TSLBase.Fn)(() => {
  // @deprecated, r169

  console.warn('THREE.TSL: "viewportResolution" is deprecated. Use "screenSize" instead.');
  return screenSize;
}, 'vec2').once()();

/**
 * @tsl
 * @deprecated since r168. Use {@link screenUV} instead.
 * @type {Node<vec2>}
 */
const viewportTopLeft = exports.viewportTopLeft = /*@__PURE__*/(0, _TSLBase.Fn)(() => {
  // @deprecated, r168

  console.warn('THREE.TSL: "viewportTopLeft" is deprecated. Use "screenUV" instead.');
  return screenUV;
}, 'vec2').once()();

/**
 * @tsl
 * @deprecated since r168. Use `screenUV.flipY()` instead.
 * @type {Node<vec2>}
 */
const viewportBottomLeft = exports.viewportBottomLeft = /*@__PURE__*/(0, _TSLBase.Fn)(() => {
  // @deprecated, r168

  console.warn('THREE.TSL: "viewportBottomLeft" is deprecated. Use "screenUV.flipY()" instead.');
  return screenUV.flipY();
}, 'vec2').once()();