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

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.HemisphereLightHelper = void 0;
var _Vector = require("../math/Vector3.js");
var _Color = require("../math/Color.js");
var _Object3D = require("../core/Object3D.js");
var _Mesh = require("../objects/Mesh.js");
var _MeshBasicMaterial = require("../materials/MeshBasicMaterial.js");
var _OctahedronGeometry = require("../geometries/OctahedronGeometry.js");
var _BufferAttribute = require("../core/BufferAttribute.js");
const _vector = /*@__PURE__*/new _Vector.Vector3();
const _color1 = /*@__PURE__*/new _Color.Color();
const _color2 = /*@__PURE__*/new _Color.Color();

/**
 * Creates a visual aid consisting of a spherical mesh for a
 * given {@link HemisphereLight}.
 *
 * ```js
 * const light = new THREE.HemisphereLight( 0xffffbb, 0x080820, 1 );
 * const helper = new THREE.HemisphereLightHelper( light, 5 );
 * scene.add( helper );
 * ```
 *
 * @augments Object3D
 */
class HemisphereLightHelper extends _Object3D.Object3D {
  /**
   * Constructs a new hemisphere light helper.
   *
   * @param {HemisphereLight} light - The light to be visualized.
   * @param {number} [size=1] - The size of the mesh used to visualize the light.
   * @param {number|Color|string} [color] - The helper's color. If not set, the helper will take
   * the color of the light.
   */
  constructor(light, size, color) {
    super();

    /**
     * The light being visualized.
     *
     * @type {HemisphereLight}
     */
    this.light = light;
    this.matrix = light.matrixWorld;
    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 = 'HemisphereLightHelper';
    const geometry = new _OctahedronGeometry.OctahedronGeometry(size);
    geometry.rotateY(Math.PI * 0.5);
    this.material = new _MeshBasicMaterial.MeshBasicMaterial({
      wireframe: true,
      fog: false,
      toneMapped: false
    });
    if (this.color === undefined) this.material.vertexColors = true;
    const position = geometry.getAttribute('position');
    const colors = new Float32Array(position.count * 3);
    geometry.setAttribute('color', new _BufferAttribute.BufferAttribute(colors, 3));
    this.add(new _Mesh.Mesh(geometry, this.material));
    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.children[0].geometry.dispose();
    this.children[0].material.dispose();
  }

  /**
   * Updates the helper to match the position and direction of the
   * light being visualized.
   */
  update() {
    const mesh = this.children[0];
    if (this.color !== undefined) {
      this.material.color.set(this.color);
    } else {
      const colors = mesh.geometry.getAttribute('color');
      _color1.copy(this.light.color);
      _color2.copy(this.light.groundColor);
      for (let i = 0, l = colors.count; i < l; i++) {
        const color = i < l / 2 ? _color1 : _color2;
        colors.setXYZ(i, color.r, color.g, color.b);
      }
      colors.needsUpdate = true;
    }
    this.light.updateWorldMatrix(true, false);
    mesh.lookAt(_vector.setFromMatrixPosition(this.light.matrixWorld).negate());
  }
}
exports.HemisphereLightHelper = HemisphereLightHelper;