@openhps/core/dist/cjs/three/helpers/SpotLightHelper.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.SpotLightHelper = void 0;
var _Vector = require("../math/Vector3.js");
var _Object3D = require("../core/Object3D.js");
var _LineSegments = require("../objects/LineSegments.js");
var _LineBasicMaterial = require("../materials/LineBasicMaterial.js");
var _BufferAttribute = require("../core/BufferAttribute.js");
var _BufferGeometry = require("../core/BufferGeometry.js");
const _vector = /*@__PURE__*/new _Vector.Vector3();

/**
 * This displays a cone shaped helper object for a {@link SpotLight}.
 *
 * ```js
 * const spotLight = new THREE.SpotLight( 0xffffff );
 * spotLight.position.set( 10, 10, 10 );
 * scene.add( spotLight );
 *
 * const spotLightHelper = new THREE.SpotLightHelper( spotLight );
 * scene.add( spotLightHelper );
 * ```
 *
 * @augments Object3D
 */
class SpotLightHelper extends _Object3D.Object3D {
  /**
   * Constructs a new spot light helper.
   *
   * @param {HemisphereLight} light - The light to be visualized.
   * @param {number|Color|string} [color] - The helper's color. If not set, the helper will take
   * the color of the light.
   */
  constructor(light, color) {
    super();

    /**
     * The light being visualized.
     *
     * @type {SpotLight}
     */
    this.light = light;
    this.matrixAutoUpdate = false;

    /**
     * The color parameter passed in the constructor.
     * If not set, the helper will take the color of the light.
     *
     * @type {number|Color|string}
     */
    this.color = color;
    this.type = 'SpotLightHelper';
    const geometry = new _BufferGeometry.BufferGeometry();
    const positions = [0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, -1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, -1, 1];
    for (let i = 0, j = 1, l = 32; i < l; i++, j++) {
      const p1 = i / l * Math.PI * 2;
      const p2 = j / l * Math.PI * 2;
      positions.push(Math.cos(p1), Math.sin(p1), 1, Math.cos(p2), Math.sin(p2), 1);
    }
    geometry.setAttribute('position', new _BufferAttribute.Float32BufferAttribute(positions, 3));
    const material = new _LineBasicMaterial.LineBasicMaterial({
      fog: false,
      toneMapped: false
    });
    this.cone = new _LineSegments.LineSegments(geometry, material);
    this.add(this.cone);
    this.update();
  }

  /**
   * Frees the GPU-related resources allocated by this instance. Call this
   * method whenever this instance is no longer used in your app.
   */
  dispose() {
    this.cone.geometry.dispose();
    this.cone.material.dispose();
  }

  /**
   * Updates the helper to match the position and direction of the
   * light being visualized.
   */
  update() {
    this.light.updateWorldMatrix(true, false);
    this.light.target.updateWorldMatrix(true, false);

    // update the local matrix based on the parent and light target transforms
    if (this.parent) {
      this.parent.updateWorldMatrix(true);
      this.matrix.copy(this.parent.matrixWorld).invert().multiply(this.light.matrixWorld);
    } else {
      this.matrix.copy(this.light.matrixWorld);
    }
    this.matrixWorld.copy(this.light.matrixWorld);
    const coneLength = this.light.distance ? this.light.distance : 1000;
    const coneWidth = coneLength * Math.tan(this.light.angle);
    this.cone.scale.set(coneWidth, coneWidth, coneLength);
    _vector.setFromMatrixPosition(this.light.target.matrixWorld);
    this.cone.lookAt(_vector);
    if (this.color !== undefined) {
      this.cone.material.color.set(this.color);
    } else {
      this.cone.material.color.copy(this.light.color);
    }
  }
}
exports.SpotLightHelper = SpotLightHelper;