three
Version:
JavaScript 3D library
952 lines (656 loc) • 27.8 kB
JavaScript
import NodeMaterial from '../../../materials/nodes/NodeMaterial.js';
import { sphericalGaussianBlur, ggxConvolution } from '../../../nodes/pmrem/PMREMUtils.js';
import { equirectUV } from '../../../nodes/utils/EquirectUV.js';
import { uniform } from '../../../nodes/core/UniformNode.js';
import { texture } from '../../../nodes/accessors/TextureNode.js';
import { cubeTexture } from '../../../nodes/accessors/CubeTextureNode.js';
import { float, int, uint } from '../../../nodes/tsl/TSLBase.js';
import { attribute } from '../../../nodes/core/AttributeNode.js';
import { OrthographicCamera } from '../../../cameras/OrthographicCamera.js';
import { Color } from '../../../math/Color.js';
import { Vector3 } from '../../../math/Vector3.js';
import { BufferGeometry } from '../../../core/BufferGeometry.js';
import { BufferAttribute } from '../../../core/BufferAttribute.js';
import { RenderTarget } from '../../../core/RenderTarget.js';
import { Mesh } from '../../../objects/Mesh.js';
import { PerspectiveCamera } from '../../../cameras/PerspectiveCamera.js';
import { MeshBasicMaterial } from '../../../materials/MeshBasicMaterial.js';
import { BoxGeometry } from '../../../geometries/BoxGeometry.js';
import {
CubeReflectionMapping,
CubeRefractionMapping,
CubeUVReflectionMapping,
LinearFilter,
NoBlending,
RGBAFormat,
HalfFloatType,
BackSide,
LinearSRGBColorSpace
} from '../../../constants.js';
import { warnOnce } from '../../../utils.js';
const LOD_MIN = 4;
// The number of extra mips.
// Used for scene blur in fromScene() method.
const EXTRA_LODS = 6;
// The number of spiral samples per blur pass.
// Used for scene blur in fromScene() method.
const BLUR_SAMPLES = 20;
// GGX VNDF importance sampling configuration
const GGX_SAMPLES = 256;
const _flatCamera = /*@__PURE__*/ new OrthographicCamera( - 1, 1, 1, - 1, 0, 1 );
const _cubeCamera = /*@__PURE__*/ new PerspectiveCamera( 90, 1 );
const _clearColor = /*@__PURE__*/ new Color();
let _oldTarget = null;
let _oldActiveCubeFace = 0;
let _oldActiveMipmapLevel = 0;
const _origin = /*@__PURE__*/ new Vector3();
const _direction = /*@__PURE__*/ new Vector3();
// maps blur materials to their uniforms dictionary
const _uniformsMap = new WeakMap();
// WebGPU Face indices
const _faceLib = [
3, 1, 5,
0, 4, 2
];
const _outputDirection = /*@__PURE__*/ attribute( 'outputDirection' ).normalize();
/**
* 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.
*
* The prefiltering uses GGX VNDF (Visible Normal Distribution Function)
* importance sampling based on "Sampling the GGX Distribution of Visible Normals"
* (Heitz, 2018) to generate environment maps that accurately match the GGX BRDF
* used in material rendering for physically-based image-based lighting.
*/
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._sizeLods = [];
this._lodMeshes = [];
this._blurMaterial = null;
this._ggxMaterial = 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.position=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#fromScene}
*/
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 ) {
throw new Error( 'THREE.PMREMGenerator: .fromScene() called before the backend is initialized. Use "await renderer.init();" before using this method.' );
}
_oldTarget = this._renderer.getRenderTarget();
_oldActiveCubeFace = this._renderer.getActiveCubeFace();
_oldActiveMipmapLevel = this._renderer.getActiveMipmapLevel();
const cubeUVRenderTarget = renderTarget || this._allocateTarget( true );
this._init( cubeUVRenderTarget );
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).
*
* @deprecated
* @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 = {} ) {
warnOnce( 'PMREMGenerator: ".fromSceneAsync()" is deprecated. Use "await renderer.init()" instead.' ); // @deprecated r181
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. The minimum supported input image size
* is 64 x 32.
*
* @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 ) {
throw new Error( 'THREE.PMREMGenerator: .fromEquirectangular() called before the backend is initialized. Use "await renderer.init();" before using this method.' );
}
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.
*
* @deprecated
* @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 ) {
warnOnce( 'PMREMGenerator: ".fromEquirectangularAsync()" is deprecated. Use "await renderer.init()" instead.' ); // @deprecated r181
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. The minimum supported input cube
* size is 16 x 16 per face.
*
* @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 ) {
throw new Error( 'THREE.PMREMGenerator: .fromCubemap() called before the backend is initialized. Use "await renderer.init();" before using this method.' );
}
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.
*
* @deprecated
* @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 ) {
warnOnce( 'PMREMGenerator: ".fromCubemapAsync()" is deprecated. Use "await renderer.init()" instead.' ); // @deprecated r181
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 === CubeReflectionMapping || texture.mapping === 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._ggxMaterial !== null ) this._ggxMaterial.dispose();
if ( this._pingPongRenderTarget !== null ) this._pingPongRenderTarget.dispose();
for ( let i = 0; i < this._lodMeshes.length; i ++ ) {
this._lodMeshes[ i ].geometry.dispose();
}
}
_cleanup( outputTarget ) {
this._renderer.setRenderTarget( _oldTarget, _oldActiveCubeFace, _oldActiveMipmapLevel );
outputTarget.scissorTest = false;
this._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._allocateTarget( false );
this._init( cubeUVRenderTarget );
this._textureToCubeUV( texture, cubeUVRenderTarget );
this._applyPMREM( cubeUVRenderTarget );
this._cleanup( cubeUVRenderTarget );
return cubeUVRenderTarget;
}
_allocateTarget( depthBuffer ) {
const width = 3 * Math.max( this._cubeSize, 16 * 7 );
const height = 4 * this._cubeSize;
const cubeUVRenderTarget = _createRenderTarget( width, height, depthBuffer );
return cubeUVRenderTarget;
}
_init( renderTarget ) {
if ( this._pingPongRenderTarget === null || this._pingPongRenderTarget.width !== renderTarget.width || this._pingPongRenderTarget.height !== renderTarget.height ) {
if ( this._pingPongRenderTarget !== null ) {
this._dispose();
}
this._pingPongRenderTarget = _createRenderTarget( renderTarget.width, renderTarget.height );
const { _lodMax } = this;
( { lodMeshes: this._lodMeshes, sizeLods: this._sizeLods } = _createPlanes( _lodMax ) );
this._blurMaterial = _getBlurShader( _lodMax, renderTarget.width, renderTarget.height );
this._ggxMaterial = _getGGXShader( _lodMax, renderTarget.width, renderTarget.height );
}
}
async _compileMaterial( material ) {
const mesh = new Mesh( new BufferGeometry(), material );
await this._renderer.compile( mesh, _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;
if ( this._backgroundBox === null ) {
this._backgroundBox = new Mesh(
new BoxGeometry(),
new MeshBasicMaterial( {
name: 'PMREM.Background',
side: BackSide,
depthWrite: false,
depthTest: false,
} )
);
}
const backgroundBox = this._backgroundBox;
const backgroundMaterial = backgroundBox.material;
let useSolidColor = false;
const background = scene.background;
if ( background ) {
if ( background.isColor ) {
backgroundMaterial.color.copy( background );
scene.background = null;
useSolidColor = true;
}
} else {
backgroundMaterial.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;
this._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 === CubeReflectionMapping || texture.mapping === 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;
this._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._lodMeshes.length;
// Use GGX VNDF importance sampling
for ( let i = 1; i < n; i ++ ) {
this._applyGGXFilter( cubeUVRenderTarget, i - 1, i );
}
renderer.autoClear = autoClear;
}
/**
* Applies GGX VNDF importance sampling filter to generate a prefiltered environment map.
* Uses Monte Carlo integration with VNDF importance sampling to accurately represent the
* GGX BRDF for physically-based rendering. Reads from the previous LOD level and
* applies incremental roughness filtering to avoid over-blurring.
*
* @private
* @param {RenderTarget} cubeUVRenderTarget
* @param {number} lodIn - Source LOD level to read from
* @param {number} lodOut - Target LOD level to write to
*/
_applyGGXFilter( cubeUVRenderTarget, lodIn, lodOut ) {
const renderer = this._renderer;
const pingPongRenderTarget = this._pingPongRenderTarget;
const ggxMaterial = this._ggxMaterial;
const ggxMesh = this._lodMeshes[ lodOut ];
ggxMesh.material = ggxMaterial;
const ggxUniforms = _uniformsMap.get( ggxMaterial );
// Calculate incremental roughness between LOD levels
const targetRoughness = lodOut / ( this._lodMeshes.length - 1 );
const sourceRoughness = lodIn / ( this._lodMeshes.length - 1 );
const incrementalRoughness = Math.sqrt( targetRoughness * targetRoughness - sourceRoughness * sourceRoughness );
// Apply blur strength mapping for better quality across the roughness range
const blurStrength = targetRoughness * 1.25;
const adjustedRoughness = incrementalRoughness * blurStrength;
// Calculate viewport position based on output LOD level
const { _lodMax } = this;
const outputSize = this._sizeLods[ lodOut ];
const x = 3 * outputSize * ( lodOut > _lodMax - LOD_MIN ? lodOut - _lodMax + LOD_MIN : 0 );
const y = 4 * ( this._cubeSize - outputSize );
// Read from previous LOD with incremental roughness
cubeUVRenderTarget.texture.frame = ( cubeUVRenderTarget.texture.frame || 0 ) + 1;
ggxUniforms.envMap.value = cubeUVRenderTarget.texture;
ggxUniforms.roughness.value = adjustedRoughness;
ggxUniforms.mipInt.value = _lodMax - lodIn; // Sample from input LOD
this._setViewport( pingPongRenderTarget, x, y, 3 * outputSize, 2 * outputSize );
renderer.setRenderTarget( pingPongRenderTarget );
renderer.render( ggxMesh, _flatCamera );
// Copy from pingPong back to cubeUV (simple direct copy)
pingPongRenderTarget.texture.frame = ( pingPongRenderTarget.texture.frame || 0 ) + 1;
ggxUniforms.envMap.value = pingPongRenderTarget.texture;
ggxUniforms.roughness.value = 0.0; // Direct copy
ggxUniforms.mipInt.value = _lodMax - lodOut; // Read from the level we just wrote
this._setViewport( cubeUVRenderTarget, x, y, 3 * outputSize, 2 * outputSize );
renderer.setRenderTarget( cubeUVRenderTarget );
renderer.render( ggxMesh, _flatCamera );
}
/**
* This is a two-pass Gaussian blur for a cubemap. Each pass importance-samples
* the Gaussian along a spiral kernel (Golden Angle), which distributes samples
* isotropically on the sphere (no pole artifacts).
*
* Used for initial scene blur in fromScene() method when sigma > 0.
*
* @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.
*/
_blur( cubeUVRenderTarget, lodIn, lodOut, sigma ) {
const pingPongRenderTarget = this._pingPongRenderTarget;
// Two passes of sigma / sqrt( 2 ) compose to a blur of sigma while squaring
// the effective sample count. Sigmas beyond PI are visually indistinguishable
// from a uniform blur, so clamp to keep the shader math finite.
const blurSigma = Math.min( sigma, Math.PI ) / Math.SQRT2;
this._blurPass( cubeUVRenderTarget, pingPongRenderTarget, lodIn, lodOut, blurSigma );
this._blurPass( pingPongRenderTarget, cubeUVRenderTarget, lodOut, lodOut, blurSigma );
}
_blurPass( targetIn, targetOut, lodIn, lodOut, sigmaRadians ) {
const renderer = this._renderer;
const blurMaterial = this._blurMaterial;
const blurMesh = this._lodMeshes[ lodOut ];
blurMesh.material = blurMaterial;
const blurUniforms = _uniformsMap.get( blurMaterial );
targetIn.texture.frame = ( targetIn.texture.frame || 0 ) + 1;
blurUniforms.envMap.value = targetIn.texture;
blurUniforms.sigma.value = sigmaRadians;
blurUniforms.mipInt.value = this._lodMax - lodIn;
const outputSize = this._sizeLods[ lodOut ];
const x = 3 * outputSize * ( lodOut > this._lodMax - LOD_MIN ? lodOut - this._lodMax + LOD_MIN : 0 );
const y = 4 * ( this._cubeSize - outputSize );
this._setViewport( targetOut, x, y, 3 * outputSize, 2 * outputSize );
renderer.setRenderTarget( targetOut );
renderer.render( blurMesh, _flatCamera );
}
_setViewport( target, x, y, width, height ) {
if ( this._renderer.isWebGLRenderer ) {
target.viewport.set( x, target.height - height - y, width, height );
target.scissor.set( x, target.height - height - y, width, height );
} else {
target.viewport.set( x, y, width, height );
target.scissor.set( x, y, width, height );
}
}
}
function _createPlanes( lodMax ) {
const sizeLods = [];
const lodMeshes = [];
let lod = lodMax;
const totalLods = lodMax - LOD_MIN + 1 + EXTRA_LODS;
for ( let i = 0; i < totalLods; i ++ ) {
const sizeLod = Math.pow( 2, lod );
sizeLods.push( sizeLod );
// UVs overshoot the face by one texel to bake the CubeUV border into the directions.
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 position = new Float32Array( positionSize * vertices * cubeFaces );
const outputDirection = new Float32Array( positionSize * 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 );
for ( let vertex = 0; vertex < vertices; vertex ++ ) {
const u = uv1[ vertex * 2 ] * 2 - 1;
const v = uv1[ vertex * 2 + 1 ] * 2 - 1;
// RH coordinate system; PMREM face-indexing convention
if ( faceIdx === 0 ) {
_direction.set( 1, v, u ); // pos x
} else if ( faceIdx === 1 ) {
_direction.set( - u, 1, - v ); // pos y
} else if ( faceIdx === 2 ) {
_direction.set( - u, v, 1 ); // pos z
} else if ( faceIdx === 3 ) {
_direction.set( - 1, v, - u ); // neg x
} else if ( faceIdx === 4 ) {
_direction.set( - u, - 1, v ); // neg y
} else {
_direction.set( u, v, - 1 ); // neg z
}
_direction.toArray( outputDirection, ( faceIdx * vertices + vertex ) * positionSize );
}
}
const planes = new BufferGeometry();
planes.setAttribute( 'position', new BufferAttribute( position, positionSize ) );
planes.setAttribute( 'outputDirection', new BufferAttribute( outputDirection, positionSize ) );
lodMeshes.push( new Mesh( planes, null ) );
if ( lod > LOD_MIN ) {
lod --;
}
}
return { lodMeshes, sizeLods };
}
function _createRenderTarget( width, height, depthBuffer ) {
const params = {
magFilter: LinearFilter,
minFilter: LinearFilter,
generateMipmaps: false,
type: HalfFloatType,
format: RGBAFormat,
colorSpace: LinearSRGBColorSpace,
depthBuffer
};
const cubeUVRenderTarget = new RenderTarget( width, height, params );
cubeUVRenderTarget.texture.mapping = CubeUVReflectionMapping;
cubeUVRenderTarget.texture.name = 'PMREM.cubeUv';
cubeUVRenderTarget.texture.isPMREMTexture = true;
cubeUVRenderTarget.scissorTest = true;
return cubeUVRenderTarget;
}
function _getMaterial( type ) {
const material = new NodeMaterial();
material.depthTest = false;
material.depthWrite = false;
material.blending = NoBlending;
material.name = `PMREM_${ type }`;
return material;
}
function _getBlurShader( lodMax, width, height ) {
const envMap = texture();
const sigma = uniform( 0 );
const mipInt = uniform( 0 ); // int
const CUBEUV_TEXEL_WIDTH = float( 1 / width );
const CUBEUV_TEXEL_HEIGHT = float( 1 / height );
const CUBEUV_MAX_MIP = float( lodMax );
const materialUniforms = {
envMap,
sigma,
mipInt,
CUBEUV_TEXEL_WIDTH,
CUBEUV_TEXEL_HEIGHT,
CUBEUV_MAX_MIP
};
const material = _getMaterial( 'blur' );
material.fragmentNode = sphericalGaussianBlur( {
...materialUniforms,
outputDirection: _outputDirection,
SAMPLES: int( BLUR_SAMPLES )
} );
_uniformsMap.set( material, materialUniforms );
return material;
}
function _getGGXShader( lodMax, width, height ) {
const envMap = texture();
const roughness = uniform( 0 );
const mipInt = uniform( 0 );
const CUBEUV_TEXEL_WIDTH = float( 1 / width );
const CUBEUV_TEXEL_HEIGHT = float( 1 / height );
const CUBEUV_MAX_MIP = float( lodMax );
const materialUniforms = {
envMap,
roughness,
mipInt,
CUBEUV_TEXEL_WIDTH,
CUBEUV_TEXEL_HEIGHT,
CUBEUV_MAX_MIP
};
const material = _getMaterial( 'ggx' );
material.fragmentNode = ggxConvolution( {
...materialUniforms,
N_immutable: _outputDirection,
GGX_SAMPLES: uint( GGX_SAMPLES )
} );
_uniformsMap.set( material, materialUniforms );
return material;
}
function _getCubemapMaterial( envTexture ) {
const material = _getMaterial( 'cubemap' );
material.fragmentNode = cubeTexture( envTexture, _outputDirection );
return material;
}
function _getEquirectMaterial( envTexture ) {
const material = _getMaterial( 'equirect' );
material.fragmentNode = texture( envTexture, equirectUV( _outputDirection ), 0 );
return material;
}
export default PMREMGenerator;