@openhps/core
Version:
Open Hybrid Positioning System - Core component
646 lines (622 loc) • 27.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _NodeMaterial = _interopRequireDefault(require("../../../materials/nodes/NodeMaterial.js"));
var _PMREMUtils = require("../../../nodes/pmrem/PMREMUtils.js");
var _EquirectUVNode = require("../../../nodes/utils/EquirectUVNode.js");
var _UniformNode = require("../../../nodes/core/UniformNode.js");
var _UniformArrayNode = require("../../../nodes/accessors/UniformArrayNode.js");
var _TextureNode = require("../../../nodes/accessors/TextureNode.js");
var _CubeTextureNode = require("../../../nodes/accessors/CubeTextureNode.js");
var _TSLBase = require("../../../nodes/tsl/TSLBase.js");
var _UV = require("../../../nodes/accessors/UV.js");
var _AttributeNode = require("../../../nodes/core/AttributeNode.js");
var _OrthographicCamera = require("../../../cameras/OrthographicCamera.js");
var _Color = require("../../../math/Color.js");
var _Vector = require("../../../math/Vector3.js");
var _BufferGeometry = require("../../../core/BufferGeometry.js");
var _BufferAttribute = require("../../../core/BufferAttribute.js");
var _RenderTarget = require("../../../core/RenderTarget.js");
var _Mesh = require("../../../objects/Mesh.js");
var _PerspectiveCamera = require("../../../cameras/PerspectiveCamera.js");
var _MeshBasicMaterial = require("../../../materials/MeshBasicMaterial.js");
var _BoxGeometry = require("../../../geometries/BoxGeometry.js");
var _constants = require("../../../constants.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const LOD_MIN = 4;
// The standard deviations (radians) associated with the extra mips. These are
// chosen to approximate a Trowbridge-Reitz distribution function times the
// geometric shadowing function. These sigma values squared must match the
// variance #defines in cube_uv_reflection_fragment.glsl.js.
const EXTRA_LOD_SIGMA = [0.125, 0.215, 0.35, 0.446, 0.526, 0.582];
// The maximum length of the blur for loop. Smaller sigmas will use fewer
// samples and exit early, but not recompile the shader.
const MAX_SAMPLES = 20;
const _flatCamera = /*@__PURE__*/new _OrthographicCamera.OrthographicCamera(-1, 1, 1, -1, 0, 1);
const _cubeCamera = /*@__PURE__*/new _PerspectiveCamera.PerspectiveCamera(90, 1);
const _clearColor = /*@__PURE__*/new _Color.Color();
let _oldTarget = null;
let _oldActiveCubeFace = 0;
let _oldActiveMipmapLevel = 0;
// Golden Ratio
const PHI = (1 + Math.sqrt(5)) / 2;
const INV_PHI = 1 / PHI;
// Vertices of a dodecahedron (except the opposites, which represent the
// same axis), used as axis directions evenly spread on a sphere.
const _axisDirections = [/*@__PURE__*/new _Vector.Vector3(-PHI, INV_PHI, 0), /*@__PURE__*/new _Vector.Vector3(PHI, INV_PHI, 0), /*@__PURE__*/new _Vector.Vector3(-INV_PHI, 0, PHI), /*@__PURE__*/new _Vector.Vector3(INV_PHI, 0, PHI), /*@__PURE__*/new _Vector.Vector3(0, PHI, -INV_PHI), /*@__PURE__*/new _Vector.Vector3(0, PHI, INV_PHI), /*@__PURE__*/new _Vector.Vector3(-1, 1, -1), /*@__PURE__*/new _Vector.Vector3(1, 1, -1), /*@__PURE__*/new _Vector.Vector3(-1, 1, 1), /*@__PURE__*/new _Vector.Vector3(1, 1, 1)];
const _origin = /*@__PURE__*/new _Vector.Vector3();
// maps blur materials to their uniforms dictionary
const _uniformsMap = new WeakMap();
// WebGPU Face indices
const _faceLib = [3, 1, 5, 0, 4, 2];
const _direction = /*@__PURE__*/(0, _PMREMUtils.getDirection)((0, _UV.uv)(), (0, _AttributeNode.attribute)('faceIndex')).normalize();
const _outputDirection = /*@__PURE__*/(0, _TSLBase.vec3)(_direction.x, _direction.y, _direction.z);
/**
* This class generates a Prefiltered, Mipmapped Radiance Environment Map
* (PMREM) from a cubeMap environment texture. This allows different levels of
* blur to be quickly accessed based on material roughness. It is packed into a
* special CubeUV format that allows us to perform custom interpolation so that
* we can support nonlinear formats such as RGBE. Unlike a traditional mipmap
* chain, it only goes down to the LOD_MIN level (above), and then creates extra
* even more filtered 'mips' at the same LOD_MIN resolution, associated with
* higher roughness levels. In this way we maintain resolution to smoothly
* interpolate diffuse lighting while limiting sampling computation.
*
* Paper: Fast, Accurate Image-Based Lighting:
* {@link https://drive.google.com/file/d/15y8r_UpKlU9SvV4ILb0C3qCPecS8pvLz/view}
*/
class PMREMGenerator {
/**
* Constructs a new PMREM generator.
*
* @param {Renderer} renderer - The renderer.
*/
constructor(renderer) {
this._renderer = renderer;
this._pingPongRenderTarget = null;
this._lodMax = 0;
this._cubeSize = 0;
this._lodPlanes = [];
this._sizeLods = [];
this._sigmas = [];
this._lodMeshes = [];
this._blurMaterial = null;
this._cubemapMaterial = null;
this._equirectMaterial = null;
this._backgroundBox = null;
}
get _hasInitialized() {
return this._renderer.hasInitialized();
}
/**
* Generates a PMREM from a supplied Scene, which can be faster than using an
* image if networking bandwidth is low. Optional sigma specifies a blur radius
* in radians to be applied to the scene before PMREM generation. Optional near
* and far planes ensure the scene is rendered in its entirety.
*
* @param {Scene} scene - The scene to be captured.
* @param {number} [sigma=0] - The blur radius in radians.
* @param {number} [near=0.1] - The near plane distance.
* @param {number} [far=100] - The far plane distance.
* @param {Object} [options={}] - The configuration options.
* @param {number} [options.size=256] - The texture size of the PMREM.
* @param {Vector3} [options.renderTarget=origin] - The position of the internal cube camera that renders the scene.
* @param {?RenderTarget} [options.renderTarget=null] - The render target to use.
* @return {RenderTarget} The resulting PMREM.
* @see {@link PMREMGenerator#fromSceneAsync}
*/
fromScene(scene, sigma = 0, near = 0.1, far = 100, options = {}) {
const {
size = 256,
position = _origin,
renderTarget = null
} = options;
this._setSize(size);
if (this._hasInitialized === false) {
console.warn('THREE.PMREMGenerator: .fromScene() called before the backend is initialized. Try using .fromSceneAsync() instead.');
const cubeUVRenderTarget = renderTarget || this._allocateTargets();
options.renderTarget = cubeUVRenderTarget;
this.fromSceneAsync(scene, sigma, near, far, options);
return cubeUVRenderTarget;
}
_oldTarget = this._renderer.getRenderTarget();
_oldActiveCubeFace = this._renderer.getActiveCubeFace();
_oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();
const cubeUVRenderTarget = renderTarget || this._allocateTargets();
cubeUVRenderTarget.depthBuffer = true;
this._sceneToCubeUV(scene, near, far, cubeUVRenderTarget, position);
if (sigma > 0) {
this._blur(cubeUVRenderTarget, 0, 0, sigma);
}
this._applyPMREM(cubeUVRenderTarget);
this._cleanup(cubeUVRenderTarget);
return cubeUVRenderTarget;
}
/**
* Generates a PMREM from a supplied Scene, which can be faster than using an
* image if networking bandwidth is low. Optional sigma specifies a blur radius
* in radians to be applied to the scene before PMREM generation. Optional near
* and far planes ensure the scene is rendered in its entirety (the cubeCamera
* is placed at the origin).
*
* @param {Scene} scene - The scene to be captured.
* @param {number} [sigma=0] - The blur radius in radians.
* @param {number} [near=0.1] - The near plane distance.
* @param {number} [far=100] - The far plane distance.
* @param {Object} [options={}] - The configuration options.
* @param {number} [options.size=256] - The texture size of the PMREM.
* @param {Vector3} [options.position=origin] - The position of the internal cube camera that renders the scene.
* @param {?RenderTarget} [options.renderTarget=null] - The render target to use.
* @return {Promise<RenderTarget>} A Promise that resolve with the PMREM when the generation has been finished.
* @see {@link PMREMGenerator#fromScene}
*/
async fromSceneAsync(scene, sigma = 0, near = 0.1, far = 100, options = {}) {
if (this._hasInitialized === false) await this._renderer.init();
return this.fromScene(scene, sigma, near, far, options);
}
/**
* Generates a PMREM from an equirectangular texture, which can be either LDR
* or HDR. The ideal input image size is 1k (1024 x 512),
* as this matches best with the 256 x 256 cubemap output.
*
* @param {Texture} equirectangular - The equirectangular texture to be converted.
* @param {?RenderTarget} [renderTarget=null] - The render target to use.
* @return {RenderTarget} The resulting PMREM.
* @see {@link PMREMGenerator#fromEquirectangularAsync}
*/
fromEquirectangular(equirectangular, renderTarget = null) {
if (this._hasInitialized === false) {
console.warn('THREE.PMREMGenerator: .fromEquirectangular() called before the backend is initialized. Try using .fromEquirectangularAsync() instead.');
this._setSizeFromTexture(equirectangular);
const cubeUVRenderTarget = renderTarget || this._allocateTargets();
this.fromEquirectangularAsync(equirectangular, cubeUVRenderTarget);
return cubeUVRenderTarget;
}
return this._fromTexture(equirectangular, renderTarget);
}
/**
* Generates a PMREM from an equirectangular texture, which can be either LDR
* or HDR. The ideal input image size is 1k (1024 x 512),
* as this matches best with the 256 x 256 cubemap output.
*
* @param {Texture} equirectangular - The equirectangular texture to be converted.
* @param {?RenderTarget} [renderTarget=null] - The render target to use.
* @return {Promise<RenderTarget>} The resulting PMREM.
* @see {@link PMREMGenerator#fromEquirectangular}
*/
async fromEquirectangularAsync(equirectangular, renderTarget = null) {
if (this._hasInitialized === false) await this._renderer.init();
return this._fromTexture(equirectangular, renderTarget);
}
/**
* Generates a PMREM from an cubemap texture, which can be either LDR
* or HDR. The ideal input cube size is 256 x 256,
* as this matches best with the 256 x 256 cubemap output.
*
* @param {Texture} cubemap - The cubemap texture to be converted.
* @param {?RenderTarget} [renderTarget=null] - The render target to use.
* @return {RenderTarget} The resulting PMREM.
* @see {@link PMREMGenerator#fromCubemapAsync}
*/
fromCubemap(cubemap, renderTarget = null) {
if (this._hasInitialized === false) {
console.warn('THREE.PMREMGenerator: .fromCubemap() called before the backend is initialized. Try using .fromCubemapAsync() instead.');
this._setSizeFromTexture(cubemap);
const cubeUVRenderTarget = renderTarget || this._allocateTargets();
this.fromCubemapAsync(cubemap, renderTarget);
return cubeUVRenderTarget;
}
return this._fromTexture(cubemap, renderTarget);
}
/**
* Generates a PMREM from an cubemap texture, which can be either LDR
* or HDR. The ideal input cube size is 256 x 256,
* with the 256 x 256 cubemap output.
*
* @param {Texture} cubemap - The cubemap texture to be converted.
* @param {?RenderTarget} [renderTarget=null] - The render target to use.
* @return {Promise<RenderTarget>} The resulting PMREM.
* @see {@link PMREMGenerator#fromCubemap}
*/
async fromCubemapAsync(cubemap, renderTarget = null) {
if (this._hasInitialized === false) await this._renderer.init();
return this._fromTexture(cubemap, renderTarget);
}
/**
* Pre-compiles the cubemap shader. You can get faster start-up by invoking this method during
* your texture's network fetch for increased concurrency.
*
* @returns {Promise}
*/
async compileCubemapShader() {
if (this._cubemapMaterial === null) {
this._cubemapMaterial = _getCubemapMaterial();
await this._compileMaterial(this._cubemapMaterial);
}
}
/**
* Pre-compiles the equirectangular shader. You can get faster start-up by invoking this method during
* your texture's network fetch for increased concurrency.
*
* @returns {Promise}
*/
async compileEquirectangularShader() {
if (this._equirectMaterial === null) {
this._equirectMaterial = _getEquirectMaterial();
await this._compileMaterial(this._equirectMaterial);
}
}
/**
* Disposes of the PMREMGenerator's internal memory. Note that PMREMGenerator is a static class,
* so you should not need more than one PMREMGenerator object. If you do, calling dispose() on
* one of them will cause any others to also become unusable.
*/
dispose() {
this._dispose();
if (this._cubemapMaterial !== null) this._cubemapMaterial.dispose();
if (this._equirectMaterial !== null) this._equirectMaterial.dispose();
if (this._backgroundBox !== null) {
this._backgroundBox.geometry.dispose();
this._backgroundBox.material.dispose();
}
}
// private interface
_setSizeFromTexture(texture) {
if (texture.mapping === _constants.CubeReflectionMapping || texture.mapping === _constants.CubeRefractionMapping) {
this._setSize(texture.image.length === 0 ? 16 : texture.image[0].width || texture.image[0].image.width);
} else {
// Equirectangular
this._setSize(texture.image.width / 4);
}
}
_setSize(cubeSize) {
this._lodMax = Math.floor(Math.log2(cubeSize));
this._cubeSize = Math.pow(2, this._lodMax);
}
_dispose() {
if (this._blurMaterial !== null) this._blurMaterial.dispose();
if (this._pingPongRenderTarget !== null) this._pingPongRenderTarget.dispose();
for (let i = 0; i < this._lodPlanes.length; i++) {
this._lodPlanes[i].dispose();
}
}
_cleanup(outputTarget) {
this._renderer.setRenderTarget(_oldTarget, _oldActiveCubeFace, _oldActiveMipmapLevel);
outputTarget.scissorTest = false;
_setViewport(outputTarget, 0, 0, outputTarget.width, outputTarget.height);
}
_fromTexture(texture, renderTarget) {
this._setSizeFromTexture(texture);
_oldTarget = this._renderer.getRenderTarget();
_oldActiveCubeFace = this._renderer.getActiveCubeFace();
_oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();
const cubeUVRenderTarget = renderTarget || this._allocateTargets();
this._textureToCubeUV(texture, cubeUVRenderTarget);
this._applyPMREM(cubeUVRenderTarget);
this._cleanup(cubeUVRenderTarget);
return cubeUVRenderTarget;
}
_allocateTargets() {
const width = 3 * Math.max(this._cubeSize, 16 * 7);
const height = 4 * this._cubeSize;
const params = {
magFilter: _constants.LinearFilter,
minFilter: _constants.LinearFilter,
generateMipmaps: false,
type: _constants.HalfFloatType,
format: _constants.RGBAFormat,
colorSpace: _constants.LinearSRGBColorSpace
//depthBuffer: false
};
const cubeUVRenderTarget = _createRenderTarget(width, height, params);
if (this._pingPongRenderTarget === null || this._pingPongRenderTarget.width !== width || this._pingPongRenderTarget.height !== height) {
if (this._pingPongRenderTarget !== null) {
this._dispose();
}
this._pingPongRenderTarget = _createRenderTarget(width, height, params);
const {
_lodMax
} = this;
({
sizeLods: this._sizeLods,
lodPlanes: this._lodPlanes,
sigmas: this._sigmas,
lodMeshes: this._lodMeshes
} = _createPlanes(_lodMax));
this._blurMaterial = _getBlurShader(_lodMax, width, height);
}
return cubeUVRenderTarget;
}
async _compileMaterial(material) {
const tmpMesh = new _Mesh.Mesh(this._lodPlanes[0], material);
await this._renderer.compile(tmpMesh, _flatCamera);
}
_sceneToCubeUV(scene, near, far, cubeUVRenderTarget, position) {
const cubeCamera = _cubeCamera;
cubeCamera.near = near;
cubeCamera.far = far;
// px, py, pz, nx, ny, nz
const upSign = [1, 1, 1, 1, -1, 1];
const forwardSign = [1, -1, 1, -1, 1, -1];
const renderer = this._renderer;
const originalAutoClear = renderer.autoClear;
renderer.getClearColor(_clearColor);
renderer.autoClear = false;
let backgroundBox = this._backgroundBox;
if (backgroundBox === null) {
const backgroundMaterial = new _MeshBasicMaterial.MeshBasicMaterial({
name: 'PMREM.Background',
side: _constants.BackSide,
depthWrite: false,
depthTest: false
});
backgroundBox = new _Mesh.Mesh(new _BoxGeometry.BoxGeometry(), backgroundMaterial);
}
let useSolidColor = false;
const background = scene.background;
if (background) {
if (background.isColor) {
backgroundBox.material.color.copy(background);
scene.background = null;
useSolidColor = true;
}
} else {
backgroundBox.material.color.copy(_clearColor);
useSolidColor = true;
}
renderer.setRenderTarget(cubeUVRenderTarget);
renderer.clear();
if (useSolidColor) {
renderer.render(backgroundBox, cubeCamera);
}
for (let i = 0; i < 6; i++) {
const col = i % 3;
if (col === 0) {
cubeCamera.up.set(0, upSign[i], 0);
cubeCamera.position.set(position.x, position.y, position.z);
cubeCamera.lookAt(position.x + forwardSign[i], position.y, position.z);
} else if (col === 1) {
cubeCamera.up.set(0, 0, upSign[i]);
cubeCamera.position.set(position.x, position.y, position.z);
cubeCamera.lookAt(position.x, position.y + forwardSign[i], position.z);
} else {
cubeCamera.up.set(0, upSign[i], 0);
cubeCamera.position.set(position.x, position.y, position.z);
cubeCamera.lookAt(position.x, position.y, position.z + forwardSign[i]);
}
const size = this._cubeSize;
_setViewport(cubeUVRenderTarget, col * size, i > 2 ? size : 0, size, size);
renderer.render(scene, cubeCamera);
}
renderer.autoClear = originalAutoClear;
scene.background = background;
}
_textureToCubeUV(texture, cubeUVRenderTarget) {
const renderer = this._renderer;
const isCubeTexture = texture.mapping === _constants.CubeReflectionMapping || texture.mapping === _constants.CubeRefractionMapping;
if (isCubeTexture) {
if (this._cubemapMaterial === null) {
this._cubemapMaterial = _getCubemapMaterial(texture);
}
} else {
if (this._equirectMaterial === null) {
this._equirectMaterial = _getEquirectMaterial(texture);
}
}
const material = isCubeTexture ? this._cubemapMaterial : this._equirectMaterial;
material.fragmentNode.value = texture;
const mesh = this._lodMeshes[0];
mesh.material = material;
const size = this._cubeSize;
_setViewport(cubeUVRenderTarget, 0, 0, 3 * size, 2 * size);
renderer.setRenderTarget(cubeUVRenderTarget);
renderer.render(mesh, _flatCamera);
}
_applyPMREM(cubeUVRenderTarget) {
const renderer = this._renderer;
const autoClear = renderer.autoClear;
renderer.autoClear = false;
const n = this._lodPlanes.length;
for (let i = 1; i < n; i++) {
const sigma = Math.sqrt(this._sigmas[i] * this._sigmas[i] - this._sigmas[i - 1] * this._sigmas[i - 1]);
const poleAxis = _axisDirections[(n - i - 1) % _axisDirections.length];
this._blur(cubeUVRenderTarget, i - 1, i, sigma, poleAxis);
}
renderer.autoClear = autoClear;
}
/**
* This is a two-pass Gaussian blur for a cubemap. Normally this is done
* vertically and horizontally, but this breaks down on a cube. Here we apply
* the blur latitudinally (around the poles), and then longitudinally (towards
* the poles) to approximate the orthogonally-separable blur. It is least
* accurate at the poles, but still does a decent job.
*
* @private
* @param {RenderTarget} cubeUVRenderTarget - The cubemap render target.
* @param {number} lodIn - The input level-of-detail.
* @param {number} lodOut - The output level-of-detail.
* @param {number} sigma - The blur radius in radians.
* @param {Vector3} [poleAxis] - The pole axis.
*/
_blur(cubeUVRenderTarget, lodIn, lodOut, sigma, poleAxis) {
const pingPongRenderTarget = this._pingPongRenderTarget;
this._halfBlur(cubeUVRenderTarget, pingPongRenderTarget, lodIn, lodOut, sigma, 'latitudinal', poleAxis);
this._halfBlur(pingPongRenderTarget, cubeUVRenderTarget, lodOut, lodOut, sigma, 'longitudinal', poleAxis);
}
_halfBlur(targetIn, targetOut, lodIn, lodOut, sigmaRadians, direction, poleAxis) {
const renderer = this._renderer;
const blurMaterial = this._blurMaterial;
if (direction !== 'latitudinal' && direction !== 'longitudinal') {
console.error('blur direction must be either latitudinal or longitudinal!');
}
// Number of standard deviations at which to cut off the discrete approximation.
const STANDARD_DEVIATIONS = 3;
const blurMesh = this._lodMeshes[lodOut];
blurMesh.material = blurMaterial;
const blurUniforms = _uniformsMap.get(blurMaterial);
const pixels = this._sizeLods[lodIn] - 1;
const radiansPerPixel = isFinite(sigmaRadians) ? Math.PI / (2 * pixels) : 2 * Math.PI / (2 * MAX_SAMPLES - 1);
const sigmaPixels = sigmaRadians / radiansPerPixel;
const samples = isFinite(sigmaRadians) ? 1 + Math.floor(STANDARD_DEVIATIONS * sigmaPixels) : MAX_SAMPLES;
if (samples > MAX_SAMPLES) {
console.warn(`sigmaRadians, ${sigmaRadians}, is too large and will clip, as it requested ${samples} samples when the maximum is set to ${MAX_SAMPLES}`);
}
const weights = [];
let sum = 0;
for (let i = 0; i < MAX_SAMPLES; ++i) {
const x = i / sigmaPixels;
const weight = Math.exp(-x * x / 2);
weights.push(weight);
if (i === 0) {
sum += weight;
} else if (i < samples) {
sum += 2 * weight;
}
}
for (let i = 0; i < weights.length; i++) {
weights[i] = weights[i] / sum;
}
targetIn.texture.frame = (targetIn.texture.frame || 0) + 1;
blurUniforms.envMap.value = targetIn.texture;
blurUniforms.samples.value = samples;
blurUniforms.weights.array = weights;
blurUniforms.latitudinal.value = direction === 'latitudinal' ? 1 : 0;
if (poleAxis) {
blurUniforms.poleAxis.value = poleAxis;
}
const {
_lodMax
} = this;
blurUniforms.dTheta.value = radiansPerPixel;
blurUniforms.mipInt.value = _lodMax - lodIn;
const outputSize = this._sizeLods[lodOut];
const x = 3 * outputSize * (lodOut > _lodMax - LOD_MIN ? lodOut - _lodMax + LOD_MIN : 0);
const y = 4 * (this._cubeSize - outputSize);
_setViewport(targetOut, x, y, 3 * outputSize, 2 * outputSize);
renderer.setRenderTarget(targetOut);
renderer.render(blurMesh, _flatCamera);
}
}
function _createPlanes(lodMax) {
const lodPlanes = [];
const sizeLods = [];
const sigmas = [];
const lodMeshes = [];
let lod = lodMax;
const totalLods = lodMax - LOD_MIN + 1 + EXTRA_LOD_SIGMA.length;
for (let i = 0; i < totalLods; i++) {
const sizeLod = Math.pow(2, lod);
sizeLods.push(sizeLod);
let sigma = 1.0 / sizeLod;
if (i > lodMax - LOD_MIN) {
sigma = EXTRA_LOD_SIGMA[i - lodMax + LOD_MIN - 1];
} else if (i === 0) {
sigma = 0;
}
sigmas.push(sigma);
const texelSize = 1.0 / (sizeLod - 2);
const min = -texelSize;
const max = 1 + texelSize;
const uv1 = [min, min, max, min, max, max, min, min, max, max, min, max];
const cubeFaces = 6;
const vertices = 6;
const positionSize = 3;
const uvSize = 2;
const faceIndexSize = 1;
const position = new Float32Array(positionSize * vertices * cubeFaces);
const uv = new Float32Array(uvSize * vertices * cubeFaces);
const faceIndex = new Float32Array(faceIndexSize * vertices * cubeFaces);
for (let face = 0; face < cubeFaces; face++) {
const x = face % 3 * 2 / 3 - 1;
const y = face > 2 ? 0 : -1;
const coordinates = [x, y, 0, x + 2 / 3, y, 0, x + 2 / 3, y + 1, 0, x, y, 0, x + 2 / 3, y + 1, 0, x, y + 1, 0];
const faceIdx = _faceLib[face];
position.set(coordinates, positionSize * vertices * faceIdx);
uv.set(uv1, uvSize * vertices * faceIdx);
const fill = [faceIdx, faceIdx, faceIdx, faceIdx, faceIdx, faceIdx];
faceIndex.set(fill, faceIndexSize * vertices * faceIdx);
}
const planes = new _BufferGeometry.BufferGeometry();
planes.setAttribute('position', new _BufferAttribute.BufferAttribute(position, positionSize));
planes.setAttribute('uv', new _BufferAttribute.BufferAttribute(uv, uvSize));
planes.setAttribute('faceIndex', new _BufferAttribute.BufferAttribute(faceIndex, faceIndexSize));
lodPlanes.push(planes);
lodMeshes.push(new _Mesh.Mesh(planes, null));
if (lod > LOD_MIN) {
lod--;
}
}
return {
lodPlanes,
sizeLods,
sigmas,
lodMeshes
};
}
function _createRenderTarget(width, height, params) {
const cubeUVRenderTarget = new _RenderTarget.RenderTarget(width, height, params);
cubeUVRenderTarget.texture.mapping = _constants.CubeUVReflectionMapping;
cubeUVRenderTarget.texture.name = 'PMREM.cubeUv';
cubeUVRenderTarget.texture.isPMREMTexture = true;
cubeUVRenderTarget.scissorTest = true;
return cubeUVRenderTarget;
}
function _setViewport(target, x, y, width, height) {
target.viewport.set(x, y, width, height);
target.scissor.set(x, y, width, height);
}
function _getMaterial(type) {
const material = new _NodeMaterial.default();
material.depthTest = false;
material.depthWrite = false;
material.blending = _constants.NoBlending;
material.name = `PMREM_${type}`;
return material;
}
function _getBlurShader(lodMax, width, height) {
const weights = (0, _UniformArrayNode.uniformArray)(new Array(MAX_SAMPLES).fill(0));
const poleAxis = (0, _UniformNode.uniform)(new _Vector.Vector3(0, 1, 0));
const dTheta = (0, _UniformNode.uniform)(0);
const n = (0, _TSLBase.float)(MAX_SAMPLES);
const latitudinal = (0, _UniformNode.uniform)(0); // false, bool
const samples = (0, _UniformNode.uniform)(1); // int
const envMap = (0, _TextureNode.texture)(null);
const mipInt = (0, _UniformNode.uniform)(0); // int
const CUBEUV_TEXEL_WIDTH = (0, _TSLBase.float)(1 / width);
const CUBEUV_TEXEL_HEIGHT = (0, _TSLBase.float)(1 / height);
const CUBEUV_MAX_MIP = (0, _TSLBase.float)(lodMax);
const materialUniforms = {
n,
latitudinal,
weights,
poleAxis,
outputDirection: _outputDirection,
dTheta,
samples,
envMap,
mipInt,
CUBEUV_TEXEL_WIDTH,
CUBEUV_TEXEL_HEIGHT,
CUBEUV_MAX_MIP
};
const material = _getMaterial('blur');
material.fragmentNode = (0, _PMREMUtils.blur)({
...materialUniforms,
latitudinal: latitudinal.equal(1)
});
_uniformsMap.set(material, materialUniforms);
return material;
}
function _getCubemapMaterial(envTexture) {
const material = _getMaterial('cubemap');
material.fragmentNode = (0, _CubeTextureNode.cubeTexture)(envTexture, _outputDirection);
return material;
}
function _getEquirectMaterial(envTexture) {
const material = _getMaterial('equirect');
material.fragmentNode = (0, _TextureNode.texture)(envTexture, (0, _EquirectUVNode.equirectUV)(_outputDirection), 0);
return material;
}
var _default = exports.default = PMREMGenerator;