super-three 0.135.0 → 0.136.0

package/examples/jsm/renderers/nodes/display/ColorSpaceNode.js

@@ -1,9 +1,10 @@
 import TempNode from '../core/Node.js';
-import { ShaderNode, vec3, pow, mul, add, mix, join, lessThanEqual } from '../ShaderNode.js';
+import { ShaderNode,
+	vec3,
+	pow, mul, add, sub, mix, join,
+	lessThanEqual } from '../ShaderNode.js';
 
-import { LinearEncoding,
-	sRGBEncoding/*, RGBEEncoding, RGBM7Encoding, RGBM16Encoding,
-	RGBDEncoding, GammaEncoding*/ } from 'three';
+import { LinearEncoding, sRGBEncoding } from 'three';
 
 export const LinearToLinear = new ShaderNode( ( inputs ) => {
 
@@ -27,12 +28,29 @@ export const sRGBToLinear = new ShaderNode( ( inputs ) => {
 
 } );
 
+export const LinearTosRGB = new ShaderNode( ( inputs ) => {
+
+	const { value } = inputs;
+
+	const rgb = value.rgb;
+
+	const a = sub( mul( pow( value.rgb, vec3( 0.41666 ) ), 1.055 ), vec3( 0.055 ) );
+	const b = mul( rgb, 12.92 );
+	const factor = vec3( lessThanEqual( rgb, vec3( 0.0031308 ) ) );
+
+	const rgbResult = mix( a, b, factor );
+
+	return join( rgbResult.r, rgbResult.g, rgbResult.b, value.a );
+
+} );
+
 const EncodingLib = {
 	LinearToLinear,
-	sRGBToLinear
+	sRGBToLinear,
+	LinearTosRGB
 };
 
-function getEncodingComponents ( encoding ) {
+function getEncodingComponents( encoding ) {
 
 	switch ( encoding ) {
 
@@ -40,18 +58,7 @@ function getEncodingComponents ( encoding ) {
 			return [ 'Linear' ];
 		case sRGBEncoding:
 			return [ 'sRGB' ];
-/*
-		case RGBEEncoding:
-			return [ 'RGBE' ];
-		case RGBM7Encoding:
-			return [ 'RGBM', new FloatNode( 7.0 ).setConst( true ) ];
-		case RGBM16Encoding:
-			return [ 'RGBM', new FloatNode( 16.0 ).setConst( true ) ];
-		case RGBDEncoding:
-			return [ 'RGBD', new FloatNode( 256.0 ).setConst( true ) ];
-		case GammaEncoding:
-			return [ 'Gamma', new CodeNode( 'float( GAMMA_FACTOR )' ) ];
-*/
+
 	}
 
 }
@@ -62,19 +69,7 @@ class ColorSpaceNode extends TempNode {
 
 	static SRGB_TO_LINEAR = 'sRGBToLinear';
 	static LINEAR_TO_SRGB = 'LinearTosRGB';
-/*
-	static GAMMA_TO_LINEAR = 'GammaToLinear';
-	static LINEAR_TO_GAMMA = 'LinearToGamma';
-
-	static RGBE_TO_LINEAR = 'RGBEToLinear';
-	static LINEAR_TO_RGBE = 'LinearToRGBE';
-
-	static RGBM_TO_LINEAR = 'RGBMToLinear';
-	static LINEAR_TO_RGBM = 'LinearToRGBM';
 
-	static RGBD_TO_LINEAR = 'RGBDToLinear';
-	static LINEAR_TO_RGBD = 'LinearToRGBD';
-*/
 	constructor( method, node ) {
 
 		super( 'vec4' );
@@ -117,7 +112,7 @@ class ColorSpaceNode extends TempNode {
 
 		if ( method !== ColorSpaceNode.LINEAR_TO_LINEAR ) {
 
-			const encodingFunctionNode = EncodingLib[ method ];			
+			const encodingFunctionNode = EncodingLib[ method ];
 			const factor = this.factor;
 
 			return encodingFunctionNode( {

package/examples/jsm/renderers/nodes/functions/BSDFs.js

@@ -75,7 +75,7 @@ export const D_GGX = new ShaderNode( ( inputs ) => {
 
 
 // GGX Distribution, Schlick Fresnel, GGX_SmithCorrelated Visibility
-export const BRDF_Specular_GGX = new ShaderNode( ( inputs ) => {
+export const BRDF_GGX = new ShaderNode( ( inputs ) => {
 
 	const { lightDirection, f0, f90, roughness } = inputs;
 
@@ -109,7 +109,7 @@ export const RE_Direct_Physical = new ShaderNode( ( inputs ) => {
 
 	addTo( directDiffuse, mul( irradiance, BRDF_Lambert( { diffuseColor } ) ) );
 
-	addTo( directSpecular, mul( irradiance, BRDF_Specular_GGX( { lightDirection, f0: specularColor, f90: 1, roughness } ) ) );
+	addTo( directSpecular, mul( irradiance, BRDF_GGX( { lightDirection, f0: specularColor, f90: 1, roughness } ) ) );
 
 } );
 

package/examples/jsm/renderers/nodes/functions/PhysicalMaterialFunctions.js

@@ -0,0 +1,27 @@
+import { ShaderNode,
+	add, max, min, abs, dFdx, dFdy,
+	normalGeometry
+} from '../ShaderNode.js';
+
+export const getGeometryRoughness = new ShaderNode( () => {
+
+	const dxy = max( abs( dFdx( normalGeometry ) ), abs( dFdy( normalGeometry ) ) );
+	const geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );
+
+	return geometryRoughness;
+
+} );
+
+export const getRoughness = new ShaderNode( ( inputs ) => {
+
+	const { roughness } = inputs;
+
+	const geometryRoughness = getGeometryRoughness();
+
+	let roughnessFactor = max( roughness, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.
+	roughnessFactor = add( roughnessFactor, geometryRoughness );
+	roughnessFactor = min( roughnessFactor, 1.0 );
+
+	return roughnessFactor;
+
+} );

package/examples/jsm/renderers/nodes/inputs/TextureNode.js

@@ -21,7 +21,7 @@ class TextureNode extends InputNode {
 
 		if ( ! texture || texture.isTexture !== true ) {
 
-			throw new Error( `TextureNode: Need a three.js texture.` );
+			throw new Error( 'TextureNode: Need a three.js texture.' );
 
 		}
 

package/examples/jsm/renderers/nodes/math/MathNode.js

@@ -127,7 +127,9 @@ class MathNode extends TempNode {
 		const b = this.bNode;
 		const c = this.cNode;
 
-		if ( builder.renderer.isWebGLRenderer === true && ( method === MathNode.DFDX || method === MathNode.DFDY ) && output === 'vec3' ) {
+		const isWebGL = builder.renderer.isWebGLRenderer === true;
+
+		if ( isWebGL && ( method === MathNode.DFDX || method === MathNode.DFDY ) && output === 'vec3' ) {
 
 			// Workaround for Adreno 3XX dFd*( vec3 ) bug. See #9988
 
@@ -185,11 +187,11 @@ class MathNode extends TempNode {
 			} else if ( method === MathNode.STEP ) {
 
 				params.push(
-					b.build( builder, builder.getTypeLength( a.getNodeType( builder ) ) === 1 ? 'float' : inputType ),
+					a.build( builder, builder.getTypeLength( a.getNodeType( builder ) ) === 1 ? 'float' : inputType ),
 					b.build( builder, inputType )
 				);
 
-			} else if ( method === MathNode.MIN || method === MathNode.MAX || method === MathNode.MOD ) {
+			} else if ( ( isWebGL && ( method === MathNode.MIN || method === MathNode.MAX ) ) || method === MathNode.MOD ) {
 
 				params.push(
 					a.build( builder, inputType ),

package/examples/jsm/renderers/nodes/math/OperatorNode.js

@@ -149,11 +149,11 @@ class OperatorNode extends TempNode {
 
 			} else if ( op === '>' && outputLength > 1 ) {
 
-				return `greaterThan( ${a}, ${b} )`;
+				return `${ builder.getMethod( 'greaterThan' ) }( ${a}, ${b} )`;
 
 			} else if ( op === '<=' && outputLength > 1 ) {
 
-				return `lessThanEqual( ${a}, ${b} )`;
+				return `${ builder.getMethod( 'lessThanEqual' ) }( ${a}, ${b} )`;
 
 			} else {
 

package/examples/jsm/renderers/nodes/utils/TimerNode.js

@@ -3,7 +3,7 @@ import { NodeUpdateType } from '../core/constants.js';
 
 class TimerNode extends FloatNode {
 
-	static LOCAL = 'local';	
+	static LOCAL = 'local';
 	static GLOBAL = 'global';
 	static DELTA = 'delta';
 

package/examples/jsm/renderers/webgl/nodes/WebGLNodeBuilder.js

@@ -116,15 +116,15 @@ class WebGLNodeBuilder extends NodeBuilder {
 
 		}
 
-		if ( material.sizeNode && material.sizeNode.isNode ) {
+		if ( material.positionNode && material.positionNode.isNode ) {
 
-			this.addSlot( 'vertex', new SlotNode( material.sizeNode, 'SIZE', 'float' ) );
+			this.addSlot( 'vertex', new SlotNode( material.positionNode, 'POSITION', 'vec3' ) );
 
 		}
 
-		if ( material.positionNode && material.positionNode.isNode ) {
+		if ( material.sizeNode && material.sizeNode.isNode ) {
 
-			this.addSlot( 'vertex', new SlotNode( material.positionNode, 'POSITION', 'vec3' ) );
+			this.addSlot( 'vertex', new SlotNode( material.sizeNode, 'SIZE', 'float' ) );
 
 		}
 
@@ -216,7 +216,7 @@ class WebGLNodeBuilder extends NodeBuilder {
 
 	}
 
-	getVarys( shaderStage ) {
+	getVarys( /* shaderStage */ ) {
 
 		let snippet = '';
 
@@ -285,7 +285,7 @@ class WebGLNodeBuilder extends NodeBuilder {
 	}
 
 	getTextureEncodingFromMap( map ) {
-/*
+
 		const isWebGL2 = this.renderer.capabilities.isWebGL2;
 
 		if ( isWebGL2 && map && map.isTexture && map.format === RGBAFormat && map.type === UnsignedByteType && map.encoding === sRGBEncoding ) {
@@ -293,7 +293,7 @@ class WebGLNodeBuilder extends NodeBuilder {
 			return LinearEncoding; // disable inline decode for sRGB textures in WebGL 2
 
 		}
-*/
+
 		return super.getTextureEncodingFromMap( map );
 
 	}
@@ -376,8 +376,8 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 		this.parseInclude( 'fragment', 'lights_physical_fragment' );
 
 		const colorSlot = this.getSlot( 'fragment', 'COLOR' );
-		const normalSlot = this.getSlot( 'fragment', 'NORMAL' );
 		const opacityNode = this.getSlot( 'fragment', 'OPACITY' );
+		const normalSlot = this.getSlot( 'fragment', 'NORMAL' );
 		const emissiveNode = this.getSlot( 'fragment', 'EMISSIVE' );
 		const roughnessNode = this.getSlot( 'fragment', 'ROUGHNESS' );
 		const metalnessNode = this.getSlot( 'fragment', 'METALNESS' );
@@ -397,22 +397,22 @@ ${this.shader[ getShaderStageProperty( shaderStage ) ]}
 
 		}
 
-		if ( normalSlot !== undefined ) {
+		if ( opacityNode !== undefined ) {
 
 			this.addCodeAfterInclude(
 				'fragment',
-				'normal_fragment_begin',
-				`${normalSlot.code}\n\tnormal = ${normalSlot.result};`
+				'alphatest_fragment',
+				`${opacityNode.code}\n\tdiffuseColor.a = ${opacityNode.result};`
 			);
 
 		}
 
-		if ( opacityNode !== undefined ) {
+		if ( normalSlot !== undefined ) {
 
 			this.addCodeAfterInclude(
 				'fragment',
-				'alphamap_fragment',
-				`${opacityNode.code}\n\tdiffuseColor.a = ${opacityNode.result};`
+				'normal_fragment_begin',
+				`${normalSlot.code}\n\tnormal = ${normalSlot.result};`
 			);
 
 		}

package/examples/jsm/renderers/webgpu/WebGPUBindings.js

@@ -49,6 +49,12 @@ class WebGPUBindings {
 
 	}
 
+	remove( object ) {
+
+		this.uniformsData.delete( object );
+
+	}
+
 	getForCompute( param ) {
 
 		let data = this.uniformsData.get( param );
@@ -108,12 +114,7 @@ class WebGPUBindings {
 
 				if ( needsBufferWrite === true ) {
 
-					this.device.queue.writeBuffer(
-						bufferGPU,
-						0,
-						buffer,
-						0
-					);
+					this.device.queue.writeBuffer( bufferGPU, 0, buffer, 0 );
 
 				}
 

package/examples/jsm/renderers/webgpu/WebGPURenderPipeline.js

@@ -706,7 +706,7 @@ class WebGPURenderPipeline {
 		const nodeAttributes = nodeBuilder.attributes;
 		const attributes = [];
 
-		for ( let slot = 0; slot < nodeAttributes.length; slot++ ) {
+		for ( let slot = 0; slot < nodeAttributes.length; slot ++ ) {
 
 			const nodeAttribute = nodeAttributes[ slot ];
 

package/examples/jsm/renderers/webgpu/WebGPURenderPipelines.js

@@ -3,13 +3,13 @@ import WebGPUProgrammableStage from './WebGPUProgrammableStage.js';
 
 class WebGPURenderPipelines {
 
-	constructor( renderer, properties, device, sampleCount, nodes ) {
+	constructor( renderer, device, sampleCount, nodes, bindings = null ) {
 
 		this.renderer = renderer;
-		this.properties = properties;
 		this.device = device;
 		this.sampleCount = sampleCount;
 		this.nodes = nodes;
+		this.bindings = bindings;
 
 		this.pipelines = [];
 		this.objectCache = new WeakMap();
@@ -24,10 +24,7 @@ class WebGPURenderPipelines {
 	get( object ) {
 
 		const device = this.device;
-		const properties = this.properties;
-
 		const material = object.material;
-		const materialProperties = properties.get( material );
 
 		const cache = this._getCache( object );
 
@@ -35,6 +32,14 @@ class WebGPURenderPipelines {
 
 		if ( this._needsUpdate( object, cache ) ) {
 
+			// release previous cache
+
+			if ( cache.currentPipeline !== undefined ) {
+
+				this._releaseObject( object );
+
+			}
+
 			// get shader
 
 			const nodeBuilder = this.nodes.get( object );
@@ -64,37 +69,15 @@ class WebGPURenderPipelines {
 			currentPipeline = this._acquirePipeline( stageVertex, stageFragment, object, nodeBuilder );
 			cache.currentPipeline = currentPipeline;
 
-			// keep track of all pipelines which are used by a material
-
-			let materialPipelines = materialProperties.pipelines;
-
-			if ( materialPipelines === undefined ) {
-
-				materialPipelines = new Set();
-				materialProperties.pipelines = materialPipelines;
-
-			}
-
-			if ( materialPipelines.has( currentPipeline ) === false ) {
+			// keep track of all used times
 
-				materialPipelines.add( currentPipeline );
+			currentPipeline.usedTimes ++;
+			stageVertex.usedTimes ++;
+			stageFragment.usedTimes ++;
 
-				currentPipeline.usedTimes ++;
-				stageVertex.usedTimes ++;
-				stageFragment.usedTimes ++;
+			// events
 
-			}
-
-			// dispose
-
-			if ( materialProperties.disposeCallback === undefined ) {
-
-				const disposeCallback = onMaterialDispose.bind( this );
-				materialProperties.disposeCallback = disposeCallback;
-
-				material.addEventListener( 'dispose', disposeCallback );
-
-			}
+			material.addEventListener( 'dispose', cache.dispose );
 
 		} else {
 
@@ -182,7 +165,20 @@ class WebGPURenderPipelines {
 
 		if ( cache === undefined ) {
 
-			cache = {};
+			cache = {
+
+				dispose: () => {
+
+					this._releaseObject( object );
+
+					this.objectCache.delete( object );
+
+					object.material.removeEventListener( 'dispose', cache.dispose );
+
+				}
+
+			};
+
 			this.objectCache.set( object, cache );
 
 		}
@@ -191,6 +187,18 @@ class WebGPURenderPipelines {
 
 	}
 
+	_releaseObject( object ) {
+
+		const cache = this.objectCache.get( object );
+
+		this._releasePipeline( cache.currentPipeline );
+		delete cache.currentPipeline;
+
+		this.nodes.remove( object );
+		this.bindings.remove( object );
+
+	}
+
 	_releasePipeline( pipeline ) {
 
 		if ( -- pipeline.usedTimes === 0 ) {
@@ -282,31 +290,4 @@ class WebGPURenderPipelines {
 
 }
 
-function onMaterialDispose( event ) {
-
-	const properties = this.properties;
-
-	const material = event.target;
-	const materialProperties = properties.get( material );
-
-	material.removeEventListener( 'dispose', materialProperties.disposeCallback );
-
-	properties.remove( material );
-
-	// remove references to pipelines
-
-	const pipelines = materialProperties.pipelines;
-
-	if ( pipelines !== undefined ) {
-
-		for ( const pipeline of pipelines ) {
-
-			this._releasePipeline( pipeline );
-
-		}
-
-	}
-
-}
-
 export default WebGPURenderPipelines;

package/examples/jsm/renderers/webgpu/WebGPURenderer.js

@@ -183,9 +183,9 @@ class WebGPURenderer {
 		this._textures = new WebGPUTextures( device, this._properties, this._info );
 		this._objects = new WebGPUObjects( this._geometries, this._info );
 		this._nodes = new WebGPUNodes( this );
-		this._renderPipelines = new WebGPURenderPipelines( this, this._properties, device, parameters.sampleCount, this._nodes );
 		this._computePipelines = new WebGPUComputePipelines( device );
-		this._bindings = new WebGPUBindings( device, this._info, this._properties, this._textures, this._renderPipelines, this._computePipelines, this._attributes, this._nodes );
+		this._renderPipelines = new WebGPURenderPipelines( this, device, parameters.sampleCount, this._nodes );
+		this._bindings = this._renderPipelines.bindings = new WebGPUBindings( device, this._info, this._properties, this._textures, this._renderPipelines, this._computePipelines, this._attributes, this._nodes );
 		this._renderLists = new WebGPURenderLists();
 		this._background = new WebGPUBackground( this );
 

package/examples/jsm/renderers/webgpu/WebGPUTextureUtils.js

@@ -29,7 +29,6 @@ class WebGPUTextureUtils {
 		this.device = device;
 
 		const mipmapVertexSource = `
-[[ block ]]
 struct VarysStruct {
 
 	[[ builtin( position ) ]] Position: vec4<f32>;

package/examples/jsm/renderers/webgpu/nodes/WebGPUNodeBuilder.js

@@ -1,3 +1,5 @@
+import { LinearEncoding } from 'three';
+
 import WebGPUNodeUniformsGroup from './WebGPUNodeUniformsGroup.js';
 import {
 	FloatNodeUniform, Vector2NodeUniform, Vector3NodeUniform, Vector4NodeUniform,
@@ -19,9 +21,12 @@ import PositionNode from '../../nodes/accessors/PositionNode.js';
 import NormalNode from '../../nodes/accessors/NormalNode.js';
 import ModelViewProjectionNode from '../../nodes/accessors/ModelViewProjectionNode.js';
 import SkinningNode from '../../nodes/accessors/SkinningNode.js';
+import ColorSpaceNode from '../../nodes/display/ColorSpaceNode.js';
 import LightContextNode from '../../nodes/lights/LightContextNode.js';
 import OperatorNode from '../../nodes/math/OperatorNode.js';
 import WGSLNodeParser from '../../nodes/parsers/WGSLNodeParser.js';
+import { vec4 } from '../../nodes/ShaderNode.js';
+import { getRoughness } from '../../nodes/functions/PhysicalMaterialFunctions.js';
 
 const wgslTypeLib = {
 	float: 'f32',
@@ -30,6 +35,7 @@ const wgslTypeLib = {
 	vec3: 'vec3<f32>',
 	vec4: 'vec4<f32>',
 	uvec4: 'vec4<u32>',
+	bvec3: 'vec3<bool>',
 	mat3: 'mat3x3<f32>',
 	mat4: 'mat4x4<f32>'
 };
@@ -40,6 +46,13 @@ const wgslMethods = {
 };
 
 const wgslPolyfill = {
+	lessThanEqual: new CodeNode( `
+fn lessThanEqual( a : vec3<f32>, b : vec3<f32> ) -> vec3<bool> {
+
+	return vec3<bool>( a.x <= b.x, a.y <= b.y, a.z <= b.z );
+
+}
+` ),
 	mod: new CodeNode( `
 fn mod( x : f32, y : f32 ) -> f32 {
 
@@ -135,7 +148,9 @@ class WebGPUNodeBuilder extends NodeBuilder {
 
 			}
 
-			colorNode = this.addFlow( 'fragment', new VarNode( colorNode, 'DiffuseColor', 'vec4' ) );
+			colorNode = this.addFlow( 'fragment', new VarNode( colorNode, 'Color', 'vec4' ) );
+
+			this.addFlow( 'fragment', new VarNode( colorNode, 'DiffuseColor', 'vec4' ) );
 
 			// OPACITY
 
@@ -211,11 +226,13 @@ class WebGPUNodeBuilder extends NodeBuilder {
 
 				}
 
+				roughnessNode = getRoughness( { roughness: roughnessNode } );
+
 				this.addFlow( 'fragment', new VarNode( roughnessNode, 'Roughness', 'float' ) );
 
 				// SPECULAR_TINT
 
-				this.addFlow( 'fragment', new VarNode( new ExpressionNode( 'mix( vec3<f32>( 0.04 ), DiffuseColor.rgb, Metalness )', 'vec3' ), 'SpecularColor', 'color' ) );
+				this.addFlow( 'fragment', new VarNode( new ExpressionNode( 'mix( vec3<f32>( 0.04 ), Color.rgb, Metalness )', 'vec3' ), 'SpecularColor', 'color' ) );
 
 				// NORMAL_VIEW
 
@@ -249,6 +266,15 @@ class WebGPUNodeBuilder extends NodeBuilder {
 
 			// RESULT
 
+			const outputEncoding = this.renderer.outputEncoding;
+
+			if ( outputEncoding !== LinearEncoding ) {
+
+				outputNode = new ColorSpaceNode( ColorSpaceNode.LINEAR_TO_LINEAR, vec4( outputNode ) );
+				outputNode.fromEncoding( outputEncoding );
+
+			}
+
 			this.addFlow( 'fragment', new VarNode( outputNode, 'Output', 'vec4' ) );
 
 		}
@@ -267,7 +293,7 @@ class WebGPUNodeBuilder extends NodeBuilder {
 
 	}
 
-	getTexture( textureProperty, uvSnippet, biasSnippet = null, shaderStage = this.shaderStage ) {
+	getTexture( textureProperty, uvSnippet, biasSnippet, shaderStage = this.shaderStage ) {
 
 		if ( shaderStage === 'fragment' ) {
 
@@ -757,7 +783,7 @@ fn main( ${shaderData.varys} ) -> [[ location( 0 ) ]] vec4<f32> {
 
 	_getWGSLStruct( name, vars ) {
 
-		return `[[ block ]]
+		return `
 struct ${name} {
 \n${vars}
 };`;

package/examples/jsm/shaders/ConvolutionShader.js

@@ -5,7 +5,6 @@ import {
 /**
  * Convolution shader
  * ported from o3d sample to WebGL / GLSL
- * http://o3d.googlecode.com/svn/trunk/samples/convolution.html
  */
 
 const ConvolutionShader = {

package/examples/jsm/shaders/FXAAShader.js

@@ -4,7 +4,7 @@ import {
 
 /**
  * NVIDIA FXAA by Timothy Lottes
- * http://timothylottes.blogspot.com/2011/06/fxaa3-source-released.html
+ * https://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf
  * - WebGL port by @supereggbert
  * http://www.glge.org/demos/fxaa/
  */

package/examples/jsm/shaders/FilmShader.js

@@ -2,7 +2,7 @@
  * Film grain & scanlines shader
  *
  * - ported from HLSL to WebGL / GLSL
- * http://www.truevision3d.com/forums/showcase/staticnoise_colorblackwhite_scanline_shaders-t18698.0.html
+ * https://web.archive.org/web/20210226214859/http://www.truevision3d.com/forums/showcase/staticnoise_colorblackwhite_scanline_shaders-t18698.0.html
  *
  * Screen Space Static Postprocessor
  *

package/examples/jsm/shaders/GammaCorrectionShader.js

@@ -32,7 +32,7 @@ const GammaCorrectionShader = {
 
 			vec4 tex = texture2D( tDiffuse, vUv );
 
-			gl_FragColor = LinearTosRGB( tex ); // optional: LinearToGamma( tex, float( GAMMA_FACTOR ) );
+			gl_FragColor = LinearTosRGB( tex );
 
 		}`
 

package/examples/jsm/shaders/HorizontalBlurShader.js

@@ -1,7 +1,6 @@
 /**
  * Two pass Gaussian blur filter (horizontal and vertical blur shaders)
- * - described in http://www.gamerendering.com/2008/10/11/gaussian-blur-filter-shader/
- *   and used in http://www.cake23.de/traveling-wavefronts-lit-up.html
+ * - see http://www.cake23.de/traveling-wavefronts-lit-up.html
  *
  * - 9 samples per pass
  * - standard deviation 2.7

package/examples/jsm/shaders/SSRShader.js

@@ -175,7 +175,7 @@ var SSRShader = {
 				vec3 vP=getViewPosition( uv, d, cW );
 
 				#ifdef PERSPECTIVE_CAMERA
-					// https://www.comp.nus.edu.sg/~lowkl/publications/lowk_persp_interp_techrep.pdf
+					// https://comp.nus.edu.sg/~lowkl/publications/lowk_persp_interp_techrep.pdf
 					float recipVPZ=1./viewPosition.z;
 					float viewReflectRayZ=1./(recipVPZ+s*(1./d1viewPosition.z-recipVPZ));
 				#else

package/examples/jsm/shaders/SSRrShader.js

@@ -190,7 +190,7 @@ const SSRrShader = {
 				vec3 vP=getViewPosition( uv, d, cW );
 
 				#ifdef PERSPECTIVE_CAMERA
-					// https://www.comp.nus.edu.sg/~lowkl/publications/lowk_persp_interp_techrep.pdf
+					// https://comp.nus.edu.sg/~lowkl/publications/lowk_persp_interp_techrep.pdf
 					float recipVPZ=1./viewPosition.z;
 					float viewRefractRayZ=1./(recipVPZ+s*(1./d1viewPosition.z-recipVPZ));
 					float sD=surfDist*cW;