@openhps/core/dist/cjs/three/renderers/WebGLCubeRenderTarget.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.WebGLCubeRenderTarget = void 0;
var _constants = require("../constants.js");
var _Mesh = require("../objects/Mesh.js");
var _BoxGeometry = require("../geometries/BoxGeometry.js");
var _ShaderMaterial = require("../materials/ShaderMaterial.js");
var _UniformsUtils = require("./shaders/UniformsUtils.js");
var _WebGLRenderTarget = require("./WebGLRenderTarget.js");
var _CubeCamera = require("../cameras/CubeCamera.js");
var _CubeTexture = require("../textures/CubeTexture.js");
/**
 * A cube render target used in context of {@link WebGLRenderer}.
 *
 * @augments WebGLRenderTarget
 */
class WebGLCubeRenderTarget extends _WebGLRenderTarget.WebGLRenderTarget {
  /**
   * Constructs a new cube render target.
   *
   * @param {number} [size=1] - The size of the render target.
   * @param {RenderTarget~Options} [options] - The configuration object.
   */
  constructor(size = 1, options = {}) {
    super(size, size, options);

    /**
     * This flag can be used for type testing.
     *
     * @type {boolean}
     * @readonly
     * @default true
     */
    this.isWebGLCubeRenderTarget = true;
    const image = {
      width: size,
      height: size,
      depth: 1
    };
    const images = [image, image, image, image, image, image];

    /**
     * Overwritten with a different texture type.
     *
     * @type {DataArrayTexture}
     */
    this.texture = new _CubeTexture.CubeTexture(images, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace);

    // By convention -- likely based on the RenderMan spec from the 1990's -- cube maps are specified by WebGL (and three.js)
    // in a coordinate system in which positive-x is to the right when looking up the positive-z axis -- in other words,
    // in a left-handed coordinate system. By continuing this convention, preexisting cube maps continued to render correctly.

    // three.js uses a right-handed coordinate system. So environment maps used in three.js appear to have px and nx swapped
    // and the flag isRenderTargetTexture controls this conversion. The flip is not required when using WebGLCubeRenderTarget.texture
    // as a cube texture (this is detected when isRenderTargetTexture is set to true for cube textures).

    this.texture.isRenderTargetTexture = true;
    this.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;
    this.texture.minFilter = options.minFilter !== undefined ? options.minFilter : _constants.LinearFilter;
  }

  /**
   * Converts the given equirectangular texture to a cube map.
   *
   * @param {WebGLRenderer} renderer - The renderer.
   * @param {Texture} texture - The equirectangular texture.
   * @return {WebGLCubeRenderTarget} A reference to this cube render target.
   */
  fromEquirectangularTexture(renderer, texture) {
    this.texture.type = texture.type;
    this.texture.colorSpace = texture.colorSpace;
    this.texture.generateMipmaps = texture.generateMipmaps;
    this.texture.minFilter = texture.minFilter;
    this.texture.magFilter = texture.magFilter;
    const shader = {
      uniforms: {
        tEquirect: {
          value: null
        }
      },
      vertexShader: /* glsl */`

				varying vec3 vWorldDirection;

				vec3 transformDirection( in vec3 dir, in mat4 matrix ) {

					return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );

				}

				void main() {

					vWorldDirection = transformDirection( position, modelMatrix );

					#include <begin_vertex>
					#include <project_vertex>

				}
			`,
      fragmentShader: /* glsl */`

				uniform sampler2D tEquirect;

				varying vec3 vWorldDirection;

				#include <common>

				void main() {

					vec3 direction = normalize( vWorldDirection );

					vec2 sampleUV = equirectUv( direction );

					gl_FragColor = texture2D( tEquirect, sampleUV );

				}
			`
    };
    const geometry = new _BoxGeometry.BoxGeometry(5, 5, 5);
    const material = new _ShaderMaterial.ShaderMaterial({
      name: 'CubemapFromEquirect',
      uniforms: (0, _UniformsUtils.cloneUniforms)(shader.uniforms),
      vertexShader: shader.vertexShader,
      fragmentShader: shader.fragmentShader,
      side: _constants.BackSide,
      blending: _constants.NoBlending
    });
    material.uniforms.tEquirect.value = texture;
    const mesh = new _Mesh.Mesh(geometry, material);
    const currentMinFilter = texture.minFilter;

    // Avoid blurred poles
    if (texture.minFilter === _constants.LinearMipmapLinearFilter) texture.minFilter = _constants.LinearFilter;
    const camera = new _CubeCamera.CubeCamera(1, 10, this);
    camera.update(renderer, mesh);
    texture.minFilter = currentMinFilter;
    mesh.geometry.dispose();
    mesh.material.dispose();
    return this;
  }

  /**
   * Clears this cube render target.
   *
   * @param {WebGLRenderer} renderer - The renderer.
   * @param {boolean} [color=true] - Whether the color buffer should be cleared or not.
   * @param {boolean} [depth=true] - Whether the depth buffer should be cleared or not.
   * @param {boolean} [stencil=true] - Whether the stencil buffer should be cleared or not.
   */
  clear(renderer, color = true, depth = true, stencil = true) {
    const currentRenderTarget = renderer.getRenderTarget();
    for (let i = 0; i < 6; i++) {
      renderer.setRenderTarget(this, i);
      renderer.clear(color, depth, stencil);
    }
    renderer.setRenderTarget(currentRenderTarget);
  }
}
exports.WebGLCubeRenderTarget = WebGLCubeRenderTarget;