@lampdotdev/lamp 0.0.0-stage → 0.36.2-nightly.16

package/Resources/WebLibraries/three/addons/objects/WaterMesh.js

@@ -0,0 +1,194 @@
+import {
+	Color,
+	Mesh,
+	Vector3,
+	NodeMaterial
+} from 'three/webgpu';
+
+import { Fn, add, cameraPosition, div, normalize, positionWorld, sub, time, texture, vec2, max, dot, reflect, pow, length, float, uniform, reflector, mul, mix } from 'three/tsl';
+
+/**
+ * A basic flat, reflective water effect.
+ *
+ * Note that this class can only be used with {@link WebGPURenderer}.
+ * When using {@link WebGLRenderer}, use {@link Water}.
+ *
+ * References:
+ *
+ * - [Flat mirror for three.js](https://github.com/Slayvin)
+ * - [An implementation of water shader based on the flat mirror](https://home.adelphi.edu/~stemkoski/)
+ * - [Water shader explanations in WebGL](http://29a.ch/slides/2012/webglwater/ )
+ *
+ * @augments Mesh
+ * @three_import import { WaterMesh } from 'three/addons/objects/WaterMesh.js';
+ */
+class WaterMesh extends Mesh {
+
+	/**
+	 * Constructs a new water mesh.
+	 *
+	 * @param {BufferGeometry} geometry - The water mesh's geometry.
+	 * @param {WaterMesh~Options} [options] - The configuration options.
+	 */
+	constructor( geometry, options ) {
+
+		const material = new NodeMaterial();
+
+		super( geometry, material );
+
+		/**
+		 * This flag can be used for type testing.
+		 *
+		 * @type {boolean}
+		 * @readonly
+		 * @default true
+		 */
+		this.isWaterMesh = true;
+
+		/**
+		 * The effect's resolution scale.
+		 *
+		 * @type {number}
+		 * @default 0.5
+		 */
+		this.resolutionScale = options.resolutionScale !== undefined ? options.resolutionScale : 0.5;
+
+		// Uniforms
+
+		/**
+		 * The water's normal map.
+		 *
+		 * @type {TextureNode}
+		 */
+		this.waterNormals = texture( options.waterNormals );
+
+		/**
+		 * The alpha value.
+		 *
+		 * @type {UniformNode<float>}
+		 * @default 1
+		 */
+		this.alpha = uniform( options.alpha !== undefined ? options.alpha : 1.0 );
+
+		/**
+		 * The size value.
+		 *
+		 * @type {UniformNode<float>}
+		 * @default 1
+		 */
+		this.size = uniform( options.size !== undefined ? options.size : 1.0 );
+
+		/**
+		 * The sun color.
+		 *
+		 * @type {UniformNode<color>}
+		 * @default 0xffffff
+		 */
+		this.sunColor = uniform( new Color( options.sunColor !== undefined ? options.sunColor : 0xffffff ) );
+
+		/**
+		 * The sun direction.
+		 *
+		 * @type {UniformNode<vec3>}
+		 * @default (0.70707,0.70707,0.0)
+		 */
+		this.sunDirection = uniform( options.sunDirection !== undefined ? options.sunDirection : new Vector3( 0.70707, 0.70707, 0.0 ) );
+
+		/**
+		 * The water color.
+		 *
+		 * @type {UniformNode<color>}
+		 * @default 0x7f7f7f
+		 */
+		this.waterColor = uniform( new Color( options.waterColor !== undefined ? options.waterColor : 0x7f7f7f ) );
+
+		/**
+		 * The distortion scale.
+		 *
+		 * @type {UniformNode<float>}
+		 * @default 20
+		 */
+		this.distortionScale = uniform( options.distortionScale !== undefined ? options.distortionScale : 20.0 );
+
+		// TSL
+
+		const getNoise = Fn( ( [ uv ] ) => {
+
+			const offset = time;
+
+			const uv0 = add( div( uv, 103 ), vec2( div( offset, 17 ), div( offset, 29 ) ) ).toVar();
+			const uv1 = div( uv, 107 ).sub( vec2( div( offset, - 19 ), div( offset, 31 ) ) ).toVar();
+			const uv2 = add( div( uv, vec2( 8907.0, 9803.0 ) ), vec2( div( offset, 101 ), div( offset, 97 ) ) ).toVar();
+			const uv3 = sub( div( uv, vec2( 1091.0, 1027.0 ) ), vec2( div( offset, 109 ), div( offset, - 113 ) ) ).toVar();
+
+			const sample0 = this.waterNormals.sample( uv0 );
+			const sample1 = this.waterNormals.sample( uv1 );
+			const sample2 = this.waterNormals.sample( uv2 );
+			const sample3 = this.waterNormals.sample( uv3 );
+
+			const noise = sample0.add( sample1 ).add( sample2 ).add( sample3 );
+
+			return noise.mul( 0.5 ).sub( 1 );
+
+		} );
+
+		const noise = getNoise( positionWorld.xz.mul( this.size ) );
+		const surfaceNormal = normalize( noise.xzy.mul( 1.5, 1.0, 1.5 ) );
+
+		const worldToEye = cameraPosition.sub( positionWorld );
+		const eyeDirection = normalize( worldToEye );
+
+		const reflection = normalize( reflect( this.sunDirection.negate(), surfaceNormal ) );
+		const direction = max( 0.0, dot( eyeDirection, reflection ) );
+		const specularLight = pow( direction, 100 ).mul( this.sunColor ).mul( 2.0 );
+		const diffuseLight = max( dot( this.sunDirection, surfaceNormal ), 0.0 ).mul( this.sunColor ).mul( 0.5 );
+
+		const distance = length( worldToEye );
+
+		const distortion = surfaceNormal.xz.mul( float( 0.001 ).add( float( 1.0 ).div( distance ) ) ).mul( this.distortionScale );
+
+		// Material
+
+		material.transparent = true;
+
+		material.opacityNode = this.alpha;
+
+		material.receivedShadowPositionNode = positionWorld.add( distortion );
+
+		material.colorNode = Fn( () => {
+
+			const mirrorSampler = reflector();
+			mirrorSampler.uvNode = mirrorSampler.uvNode.add( distortion );
+			mirrorSampler.reflector.resolutionScale = this.resolutionScale;
+
+			this.add( mirrorSampler.target );
+
+			const theta = max( dot( eyeDirection, surfaceNormal ), 0.0 );
+			const rf0 = float( 0.02 );
+			const reflectance = mul( pow( float( 1.0 ).sub( theta ), 5.0 ), float( 1.0 ).sub( rf0 ) ).add( rf0 );
+			const scatter = max( 0.0, dot( surfaceNormal, eyeDirection ) ).mul( this.waterColor );
+			const albedo = mix( this.sunColor.mul( diffuseLight ).mul( 0.3 ).add( scatter ), mirrorSampler.rgb.add( specularLight ), reflectance );
+
+			return albedo;
+
+		} )();
+
+	}
+
+}
+
+/**
+ * Constructor options of `WaterMesh`.
+ *
+ * @typedef {Object} WaterMesh~Options
+ * @property {number} [resolutionScale=0.5] - The resolution scale.
+ * @property {?Texture} [waterNormals=null] - The water's normal map.
+ * @property {number} [alpha=1] - The alpha value.
+ * @property {number} [size=1] - The size value.
+ * @property {number|Color|string} [sunColor=0xffffff] - The sun color.
+ * @property {Vector3} [sunDirection=(0.70707,0.70707,0.0)] - The sun direction.
+ * @property {number|Color|string} [waterColor=0x7F7F7F] - The water color.
+ * @property {number} [distortionScale=20] - The distortion scale.
+ **/
+
+export { WaterMesh };

package/Resources/WebLibraries/three/addons/postprocessing/AfterimagePass.js

@@ -0,0 +1,187 @@
+import {
+	HalfFloatType,
+	NearestFilter,
+	NoBlending,
+	ShaderMaterial,
+	UniformsUtils,
+	WebGLRenderTarget
+} from 'three';
+import { Pass, FullScreenQuad } from './Pass.js';
+import { CopyShader } from '../shaders/CopyShader.js';
+import { AfterimageShader } from '../shaders/AfterimageShader.js';
+
+/**
+ * Pass for a basic after image effect.
+ *
+ * ```js
+ * const afterimagePass = new AfterimagePass( 0.9 );
+ * composer.addPass( afterimagePass );
+ * ```
+ *
+ * @augments Pass
+ * @three_import import { AfterimagePass } from 'three/addons/postprocessing/AfterimagePass.js';
+ */
+class AfterimagePass extends Pass {
+
+	/**
+	 * Constructs a new after image pass.
+	 *
+	 * @param {number} [damp=0.96] - The damping intensity. A higher value means a stronger after image effect.
+	 */
+	constructor( damp = 0.96 ) {
+
+		super();
+
+		/**
+		 * The pass uniforms. Use this object if you want to update the
+		 * `damp` value at runtime.
+		 * ```js
+		 * pass.uniforms.damp.value = 0.9;
+		 * ```
+		 *
+		 * @type {Object}
+		 */
+		this.uniforms = UniformsUtils.clone( AfterimageShader.uniforms );
+
+		this.damp = damp;
+
+		/**
+		 * The composition material.
+		 *
+		 * @type {ShaderMaterial}
+		 */
+		this.compFsMaterial = new ShaderMaterial( {
+
+			uniforms: this.uniforms,
+			vertexShader: AfterimageShader.vertexShader,
+			fragmentShader: AfterimageShader.fragmentShader
+
+		} );
+
+		/**
+		 * The copy material.
+		 *
+		 * @type {ShaderMaterial}
+		 */
+		this.copyFsMaterial = new ShaderMaterial( {
+			uniforms: UniformsUtils.clone( CopyShader.uniforms ),
+			vertexShader: CopyShader.vertexShader,
+			fragmentShader: CopyShader.fragmentShader,
+			blending: NoBlending,
+			depthTest: false,
+			depthWrite: false
+		} );
+
+		// internals
+
+		this._textureComp = new WebGLRenderTarget( window.innerWidth, window.innerHeight, {
+			magFilter: NearestFilter,
+			type: HalfFloatType,
+			depthBuffer: false
+		} );
+
+		this._textureOld = new WebGLRenderTarget( window.innerWidth, window.innerHeight, {
+			magFilter: NearestFilter,
+			type: HalfFloatType,
+			depthBuffer: false
+		} );
+
+		this._compFsQuad = new FullScreenQuad( this.compFsMaterial );
+		this._copyFsQuad = new FullScreenQuad( this.copyFsMaterial );
+
+	}
+
+	/**
+	 * The damping intensity, from 0.0 to 1.0. A higher value means a stronger after image effect.
+	 *
+	 * @type {number}
+	 */
+	get damp() {
+
+		return this.uniforms[ 'damp' ].value;
+
+	}
+
+	set damp( value ) {
+
+		this.uniforms[ 'damp' ].value = value;
+
+	}
+
+	/**
+	 * Performs the after image pass.
+	 *
+	 * @param {WebGLRenderer} renderer - The renderer.
+	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
+	 * destination for the pass.
+	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
+	 * previous pass from this buffer.
+	 * @param {number} deltaTime - The delta time in seconds.
+	 * @param {boolean} maskActive - Whether masking is active or not.
+	 */
+	render( renderer, writeBuffer, readBuffer/*, deltaTime, maskActive*/ ) {
+
+		this.uniforms[ 'tOld' ].value = this._textureOld.texture;
+		this.uniforms[ 'tNew' ].value = readBuffer.texture;
+
+		renderer.setRenderTarget( this._textureComp );
+		this._compFsQuad.render( renderer );
+
+		this._copyFsQuad.material.uniforms.tDiffuse.value = this._textureComp.texture;
+
+		if ( this.renderToScreen ) {
+
+			renderer.setRenderTarget( null );
+			this._copyFsQuad.render( renderer );
+
+		} else {
+
+			renderer.setRenderTarget( writeBuffer );
+
+			if ( this.clear ) renderer.clear();
+
+			this._copyFsQuad.render( renderer );
+
+		}
+
+		// Swap buffers.
+		const temp = this._textureOld;
+		this._textureOld = this._textureComp;
+		this._textureComp = temp;
+		// Now textureOld contains the latest image, ready for the next frame.
+
+	}
+
+	/**
+	 * Sets the size of the pass.
+	 *
+	 * @param {number} width - The width to set.
+	 * @param {number} height - The height to set.
+	 */
+	setSize( width, height ) {
+
+		this._textureComp.setSize( width, height );
+		this._textureOld.setSize( width, height );
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever the pass is no longer used in your app.
+	 */
+	dispose() {
+
+		this._textureComp.dispose();
+		this._textureOld.dispose();
+
+		this.compFsMaterial.dispose();
+		this.copyFsMaterial.dispose();
+
+		this._compFsQuad.dispose();
+		this._copyFsQuad.dispose();
+
+	}
+
+}
+
+export { AfterimagePass };

package/Resources/WebLibraries/three/addons/postprocessing/BloomPass.js

@@ -0,0 +1,274 @@
+import {
+	AdditiveBlending,
+	HalfFloatType,
+	ShaderMaterial,
+	UniformsUtils,
+	Vector2,
+	WebGLRenderTarget
+} from 'three';
+import { Pass, FullScreenQuad } from './Pass.js';
+import { ConvolutionShader } from '../shaders/ConvolutionShader.js';
+
+/**
+ * A pass for a basic Bloom effect.
+ *
+ * {@link UnrealBloomPass} produces a more advanced Bloom but is also
+ * more expensive.
+ *
+ * ```js
+ * const effectBloom = new BloomPass( 0.75 );
+ * composer.addPass( effectBloom );
+ * ```
+ *
+ * @augments Pass
+ * @three_import import { BloomPass } from 'three/addons/postprocessing/BloomPass.js';
+ */
+class BloomPass extends Pass {
+
+	/**
+	 * Constructs a new Bloom pass.
+	 *
+	 * @param {number} [strength=1] - The Bloom strength.
+	 * @param {number} [kernelSize=25] - The kernel size.
+	 * @param {number} [sigma=4] - The sigma.
+	 */
+	constructor( strength = 1, kernelSize = 25, sigma = 4 ) {
+
+		super();
+
+		// combine material
+
+		/**
+		 * The combine pass uniforms.
+		 *
+		 * @type {Object}
+		 */
+		this.combineUniforms = UniformsUtils.clone( CombineShader.uniforms );
+		this.combineUniforms[ 'strength' ].value = strength;
+
+		/**
+		 * The combine pass material.
+		 *
+		 * @type {ShaderMaterial}
+		 */
+		this.materialCombine = new ShaderMaterial( {
+
+			name: CombineShader.name,
+			uniforms: this.combineUniforms,
+			vertexShader: CombineShader.vertexShader,
+			fragmentShader: CombineShader.fragmentShader,
+			blending: AdditiveBlending,
+			transparent: true
+
+		} );
+
+		// convolution material
+
+		const convolutionShader = ConvolutionShader;
+
+		/**
+		 * The convolution pass uniforms.
+		 *
+		 * @type {Object}
+		 */
+		this.convolutionUniforms = UniformsUtils.clone( convolutionShader.uniforms );
+
+		this.convolutionUniforms[ 'uImageIncrement' ].value = BloomPass.blurX;
+		this.convolutionUniforms[ 'cKernel' ].value = buildKernel( sigma );
+
+		/**
+		 * The convolution pass material.
+		 *
+		 * @type {ShaderMaterial}
+		 */
+		this.materialConvolution = new ShaderMaterial( {
+
+			name: convolutionShader.name,
+			uniforms: this.convolutionUniforms,
+			vertexShader: convolutionShader.vertexShader,
+			fragmentShader: convolutionShader.fragmentShader,
+			defines: {
+				'KERNEL_SIZE_FLOAT': kernelSize.toFixed( 1 ),
+				'KERNEL_SIZE_INT': kernelSize.toFixed( 0 )
+			}
+
+		} );
+
+		/**
+		 * Overwritten to disable the swap.
+		 *
+		 * @type {boolean}
+		 * @default false
+		 */
+		this.needsSwap = false;
+
+		// internals
+
+		this._renderTargetX = new WebGLRenderTarget( 1, 1, { type: HalfFloatType, depthBuffer: false } ); // will be resized later
+		this._renderTargetX.texture.name = 'BloomPass.x';
+		this._renderTargetY = new WebGLRenderTarget( 1, 1, { type: HalfFloatType, depthBuffer: false } ); // will be resized later
+		this._renderTargetY.texture.name = 'BloomPass.y';
+
+		this._fsQuad = new FullScreenQuad( null );
+
+	}
+
+	/**
+	 * Performs the Bloom pass.
+	 *
+	 * @param {WebGLRenderer} renderer - The renderer.
+	 * @param {WebGLRenderTarget} writeBuffer - The write buffer. This buffer is intended as the rendering
+	 * destination for the pass.
+	 * @param {WebGLRenderTarget} readBuffer - The read buffer. The pass can access the result from the
+	 * previous pass from this buffer.
+	 * @param {number} deltaTime - The delta time in seconds.
+	 * @param {boolean} maskActive - Whether masking is active or not.
+	 */
+	render( renderer, writeBuffer, readBuffer, deltaTime, maskActive ) {
+
+		if ( maskActive ) renderer.state.buffers.stencil.setTest( false );
+
+		// Render quad with blurred scene into texture (convolution pass 1)
+
+		this._fsQuad.material = this.materialConvolution;
+
+		this.convolutionUniforms[ 'tDiffuse' ].value = readBuffer.texture;
+		this.convolutionUniforms[ 'uImageIncrement' ].value = BloomPass.blurX;
+
+		renderer.setRenderTarget( this._renderTargetX );
+		renderer.clear();
+		this._fsQuad.render( renderer );
+
+
+		// Render quad with blurred scene into texture (convolution pass 2)
+
+		this.convolutionUniforms[ 'tDiffuse' ].value = this._renderTargetX.texture;
+		this.convolutionUniforms[ 'uImageIncrement' ].value = BloomPass.blurY;
+
+		renderer.setRenderTarget( this._renderTargetY );
+		renderer.clear();
+		this._fsQuad.render( renderer );
+
+		// Render original scene with superimposed blur to texture
+
+		this._fsQuad.material = this.materialCombine;
+
+		this.combineUniforms[ 'tDiffuse' ].value = this._renderTargetY.texture;
+
+		if ( maskActive ) renderer.state.buffers.stencil.setTest( true );
+
+		renderer.setRenderTarget( readBuffer );
+		if ( this.clear ) renderer.clear();
+		this._fsQuad.render( renderer );
+
+	}
+
+	/**
+	 * Sets the size of the pass.
+	 *
+	 * @param {number} width - The width to set.
+	 * @param {number} height - The height to set.
+	 */
+	setSize( width, height ) {
+
+		this._renderTargetX.setSize( width, height );
+		this._renderTargetY.setSize( width, height );
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever the pass is no longer used in your app.
+	 */
+	dispose() {
+
+		this._renderTargetX.dispose();
+		this._renderTargetY.dispose();
+
+		this.materialCombine.dispose();
+		this.materialConvolution.dispose();
+
+		this._fsQuad.dispose();
+
+	}
+
+}
+
+const CombineShader = {
+
+	name: 'CombineShader',
+
+	uniforms: {
+
+		'tDiffuse': { value: null },
+		'strength': { value: 1.0 }
+
+	},
+
+	vertexShader: /* glsl */`
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+		}`,
+
+	fragmentShader: /* glsl */`
+
+		uniform float strength;
+
+		uniform sampler2D tDiffuse;
+
+		varying vec2 vUv;
+
+		void main() {
+
+			vec4 texel = texture2D( tDiffuse, vUv );
+			gl_FragColor = strength * texel;
+
+		}`
+
+};
+
+BloomPass.blurX = new Vector2( 0.001953125, 0.0 );
+BloomPass.blurY = new Vector2( 0.0, 0.001953125 );
+
+
+function gauss( x, sigma ) {
+
+	return Math.exp( - ( x * x ) / ( 2.0 * sigma * sigma ) );
+
+}
+
+function buildKernel( sigma ) {
+
+	// We loop off the sqrt(2 * pi) * sigma term, since we're going to normalize anyway.
+
+	const kMaxKernelSize = 25;
+	let kernelSize = 2 * Math.ceil( sigma * 3.0 ) + 1;
+
+	if ( kernelSize > kMaxKernelSize ) kernelSize = kMaxKernelSize;
+
+	const halfWidth = ( kernelSize - 1 ) * 0.5;
+
+	const values = new Array( kernelSize );
+	let sum = 0.0;
+	for ( let i = 0; i < kernelSize; ++ i ) {
+
+		values[ i ] = gauss( i - halfWidth, sigma );
+		sum += values[ i ];
+
+	}
+
+	// normalize the kernel
+
+	for ( let i = 0; i < kernelSize; ++ i ) values[ i ] /= sum;
+
+	return values;
+
+}
+
+export { BloomPass };