Max, width, height ) { const shaderMaterial = new ShaderMaterial( { name: 'SphericalGaussianBlur', defines: { 'SAMPLES': BLUR_SAMPLES, 'CUBEUV_TEXEL_WIDTH': 1.0 / width, 'CUBEUV_TEXEL_HEIGHT': 1.0 / height, 'CUBEUV_MAX_MIP': `${lodMax}.0`, }, uniforms: { 'envMap': { value: null }, 'sigma': { value: 0 }, 'mipInt': { value: 0 }, }, vertexShader: _getCommonVertexShader(), fragmentShader: /* glsl */` precision highp float; precision highp int; varying vec3 vOutputDirection; uniform sampler2D envMap; uniform float sigma; uniform float mipInt; #define ENVMAP_TYPE_CUBE_UV #include #define PI 3.14159265359 #define GOLDEN_ANGLE 2.39996322973 void main() { if ( sigma == 0.0 ) { gl_FragColor = vec4( bilinearCubeUV( envMap, vOutputDirection, mipInt ), 1.0 ); return; } vec3 outputDirection = normalize( vOutputDirection ); vec3 up = abs( outputDirection.z ) < 0.999 ? vec3( 0.0, 0.0, 1.0 ) : vec3( 1.0, 0.0, 0.0 ); vec3 tangent = normalize( cross( up, outputDirection ) ); vec3 bitangent = cross( outputDirection, tangent ); // Truncate the kernel at three standard deviations or at the antipode. float thetaMax = min( 3.0 * sigma, PI ); float truncation = 1.0 - exp( - 0.5 * thetaMax * thetaMax / ( sigma * sigma ) ); vec3 accumColor = vec3( 0.0 ); float accumWeight = 0.0; for ( int i = 0; i < SAMPLES; i ++ ) { // Stratified inverse-CDF sampling of the Gaussian, placed on a golden-angle spiral. float stratum = ( float( i ) + 0.5 ) / float( SAMPLES ); float theta = sigma * sqrt( - 2.0 * log( 1.0 - stratum * truncation ) ); float phi = float( i ) * GOLDEN_ANGLE; vec3 offset = cos( phi ) * tangent + sin( phi ) * bitangent; vec3 sampleDirection = cos( theta ) * outputDirection + sin( theta ) * offset; // Correct the planar sample density to solid angle. float weight = sin( theta ) / theta; accumColor += weight * bilinearCubeUV( envMap, sampleDirection, mipInt ); accumWeight += weight; } gl_FragColor = vec4( accumColor / accumWeight, 1.0 ); } `, blending: NoBlending, depthTest: false, depthWrite: false } ); return shaderMaterial; } function _getEquirectMaterial() { return new ShaderMaterial( { name: 'EquirectangularToCubeUV', uniforms: { 'envMap': { value: null } }, vertexShader: _getCommonVertexShader(), fragmentShader: /* glsl */` precision mediump float; precision mediump int; varying vec3 vOutputDirection; uniform sampler2D envMap; #include void main() { vec3 outputDirection = normalize( vOutputDirection ); vec2 uv = equirectUv( outputDirection ); gl_FragColor = vec4( texture2D ( envMap, uv ).rgb, 1.0 ); } `, blending: NoBlending, depthTest: false, depthWrite: false } ); } function _getCubemapMaterial() { return new ShaderMaterial( { name: 'CubemapToCubeUV', uniforms: { 'envMap': { value: null }, 'flipEnvMap': { value: -1 } }, vertexShader: _getCommonVertexShader(), fragmentShader: /* glsl */` precision mediump float; precision mediump int; uniform float flipEnvMap; varying vec3 vOutputDirection; uniform samplerCube envMap; void main() { gl_FragColor = textureCube( envMap, vec3( flipEnvMap * vOutputDirection.x, vOutputDirection.yz ) ); } `, blending: NoBlending, depthTest: false, depthWrite: false } ); } function _getCommonVertexShader() { return /* glsl */` precision mediump float; precision mediump int; attribute vec3 outputDirection; varying vec3 vOutputDirection; void main() { vOutputDirection = outputDirection; gl_Position = vec4( position, 1.0 ); } `; } /** * A cube render target used in context of {@link WebGLRenderer}. * * @augments WebGLRenderTarget */ class WebGLCubeRenderTarget extends 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( images ); this._setTextureOptions( options ); // 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