@lampdotdev/lamp 0.0.0-stage → 0.35.0

package/Resources/WebLibraries/three/addons/helpers/PositionalAudioHelper.js

@@ -0,0 +1,169 @@
+import {
+	BufferGeometry,
+	BufferAttribute,
+	LineBasicMaterial,
+	Line,
+	MathUtils
+} from 'three';
+
+/**
+ * This helper displays the directional cone of a positional audio.
+ *
+ * `PositionalAudioHelper` must be added as a child of the positional audio.
+ *
+ * ```js
+ * const positionalAudio = new THREE.PositionalAudio( listener );
+ * positionalAudio.setDirectionalCone( 180, 230, 0.1 );
+ * scene.add( positionalAudio );
+ *
+ * const helper = new PositionalAudioHelper( positionalAudio );
+ * positionalAudio.add( helper );
+ * ```
+ *
+ * @augments Line
+ * @three_import import { PositionalAudioHelper } from 'three/addons/helpers/PositionalAudioHelper.js';
+ */
+class PositionalAudioHelper extends Line {
+
+	/**
+	 * Constructs a new positional audio helper.
+	 *
+	 * @param {PositionalAudio} audio - The audio to visualize.
+	 * @param {number} [range=1] - The range of the directional cone.
+	 * @param {number} [divisionsInnerAngle=16] - The number of divisions of the inner part of the directional cone.
+	 * @param {number} [divisionsOuterAngle=2] The number of divisions of the outer part of the directional cone.
+	 */
+	constructor( audio, range = 1, divisionsInnerAngle = 16, divisionsOuterAngle = 2 ) {
+
+		const geometry = new BufferGeometry();
+		const divisions = divisionsInnerAngle + divisionsOuterAngle * 2;
+		const positions = new Float32Array( ( divisions * 3 + 3 ) * 3 );
+		geometry.setAttribute( 'position', new BufferAttribute( positions, 3 ) );
+
+		const materialInnerAngle = new LineBasicMaterial( { color: 0x00ff00 } );
+		const materialOuterAngle = new LineBasicMaterial( { color: 0xffff00 } );
+
+		super( geometry, [ materialOuterAngle, materialInnerAngle ] );
+
+		/**
+		 * The audio to visualize.
+		 *
+		 * @type {PositionalAudio}
+		 */
+		this.audio = audio;
+
+		/**
+		 * The range of the directional cone.
+		 *
+		 * @type {number}
+		 * @default 1
+		 */
+		this.range = range;
+
+		/**
+		 * The number of divisions of the inner part of the directional cone.
+		 *
+		 * @type {number}
+		 * @default 16
+		 */
+		this.divisionsInnerAngle = divisionsInnerAngle;
+
+		/**
+		 * The number of divisions of the outer part of the directional cone.
+		 *
+		 * @type {number}
+		 * @default 2
+		 */
+		this.divisionsOuterAngle = divisionsOuterAngle;
+
+		this.type = 'PositionalAudioHelper';
+
+		this.update();
+
+	}
+
+	/**
+	 * Updates the helper. This method must be called whenever the directional cone
+	 * of the positional audio is changed.
+	 */
+	update() {
+
+		const audio = this.audio;
+		const range = this.range;
+		const divisionsInnerAngle = this.divisionsInnerAngle;
+		const divisionsOuterAngle = this.divisionsOuterAngle;
+
+		const coneInnerAngle = MathUtils.degToRad( audio.panner.coneInnerAngle );
+		const coneOuterAngle = MathUtils.degToRad( audio.panner.coneOuterAngle );
+
+		const halfConeInnerAngle = coneInnerAngle / 2;
+		const halfConeOuterAngle = coneOuterAngle / 2;
+
+		let start = 0;
+		let count = 0;
+		let i;
+		let stride;
+
+		const geometry = this.geometry;
+		const positionAttribute = geometry.attributes.position;
+
+		geometry.clearGroups();
+
+		//
+
+		function generateSegment( from, to, divisions, materialIndex ) {
+
+			const step = ( to - from ) / divisions;
+
+			positionAttribute.setXYZ( start, 0, 0, 0 );
+			count ++;
+
+			for ( i = from; i < to; i += step ) {
+
+				stride = start + count;
+
+				positionAttribute.setXYZ( stride, Math.sin( i ) * range, 0, Math.cos( i ) * range );
+				positionAttribute.setXYZ( stride + 1, Math.sin( Math.min( i + step, to ) ) * range, 0, Math.cos( Math.min( i + step, to ) ) * range );
+				positionAttribute.setXYZ( stride + 2, 0, 0, 0 );
+
+				count += 3;
+
+			}
+
+			geometry.addGroup( start, count, materialIndex );
+
+			start += count;
+			count = 0;
+
+		}
+
+		//
+
+		generateSegment( - halfConeOuterAngle, - halfConeInnerAngle, divisionsOuterAngle, 0 );
+		generateSegment( - halfConeInnerAngle, halfConeInnerAngle, divisionsInnerAngle, 1 );
+		generateSegment( halfConeInnerAngle, halfConeOuterAngle, divisionsOuterAngle, 0 );
+
+		//
+
+		positionAttribute.needsUpdate = true;
+
+		if ( coneInnerAngle === coneOuterAngle ) this.material[ 0 ].visible = false;
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+
+		this.geometry.dispose();
+		this.material[ 0 ].dispose();
+		this.material[ 1 ].dispose();
+
+	}
+
+}
+
+
+export { PositionalAudioHelper };

package/Resources/WebLibraries/three/addons/helpers/RapierHelper.js

@@ -0,0 +1,59 @@
+import { LineSegments, LineBasicMaterial, BufferAttribute } from 'three';
+/**
+ * This class displays all Rapier Colliders in outline.
+ *
+ * @augments LineSegments
+ * @three_import import { RapierHelper } from 'three/addons/helpers/RapierHelper.js';
+ */
+class RapierHelper extends LineSegments {
+
+	/**
+	 * Constructs a new Rapier debug helper.
+	 *
+	 * @param {RAPIER.world} world - The Rapier world to visualize.
+	 */
+	constructor( world ) {
+
+		super();
+
+		/**
+		 * The Rapier world to visualize.
+		 *
+		 * @type {RAPIER.world}
+		 */
+		this.world = world;
+
+		this.material = new LineBasicMaterial( { vertexColors: true } );
+		this.frustumCulled = false;
+
+	}
+
+	/**
+	 * Call this in the render loop to update the outlines.
+	 */
+	update() {
+
+		const { vertices, colors } = this.world.debugRender();
+
+		this.geometry.deleteAttribute( 'position' );
+		this.geometry.deleteAttribute( 'color' );
+
+		this.geometry.setAttribute( 'position', new BufferAttribute( vertices, 3 ) );
+		this.geometry.setAttribute( 'color', new BufferAttribute( colors, 4 ) );
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+export { RapierHelper };

package/Resources/WebLibraries/three/addons/helpers/RectAreaLightHelper.js

@@ -0,0 +1,118 @@
+import {
+	BackSide,
+	BufferGeometry,
+	Float32BufferAttribute,
+	Line,
+	LineBasicMaterial,
+	Mesh,
+	MeshBasicMaterial
+} from 'three';
+
+/**
+ * Creates a visual aid for rect area lights.
+ *
+ * `RectAreaLightHelper` must be added as a child of the light.
+ *
+ * ```js
+ * const light = new THREE.RectAreaLight( 0xffffbb, 1.0, 5, 5 );
+ * const helper = new RectAreaLightHelper( light );
+ * light.add( helper );
+ * ```
+ *
+ * @augments Line
+ * @three_import import { RectAreaLightHelper } from 'three/addons/helpers/RectAreaLightHelper.js';
+ */
+class RectAreaLightHelper extends Line {
+
+	/**
+	 * Constructs a new rect area light helper.
+	 *
+	 * @param {RectAreaLight} light - The light to visualize.
+	 * @param {number|Color|string} [color] - The helper's color.
+	 * If this is not the set, the helper will take the color of the light.
+	 */
+	constructor( light, color ) {
+
+		const positions = [ 1, 1, 0, - 1, 1, 0, - 1, - 1, 0, 1, - 1, 0, 1, 1, 0 ];
+
+		const geometry = new BufferGeometry();
+		geometry.setAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );
+		geometry.computeBoundingSphere();
+
+		const material = new LineBasicMaterial( { fog: false } );
+
+		super( geometry, material );
+
+		/**
+		 * The light to visualize.
+		 *
+		 * @type {RectAreaLight}
+		 */
+		this.light = light;
+
+		/**
+		 * The helper's color. If `undefined`, the helper will take the color of the light.
+		 *
+		 * @type {number|Color|string|undefined}
+		 */
+		this.color = color;
+
+		this.type = 'RectAreaLightHelper';
+
+		//
+
+		const positions2 = [ 1, 1, 0, - 1, 1, 0, - 1, - 1, 0, 1, 1, 0, - 1, - 1, 0, 1, - 1, 0 ];
+
+		const geometry2 = new BufferGeometry();
+		geometry2.setAttribute( 'position', new Float32BufferAttribute( positions2, 3 ) );
+		geometry2.computeBoundingSphere();
+
+		this.add( new Mesh( geometry2, new MeshBasicMaterial( { side: BackSide, fog: false } ) ) );
+
+	}
+
+	updateMatrixWorld() {
+
+		this.scale.set( 0.5 * this.light.width, 0.5 * this.light.height, 1 );
+
+		if ( this.color !== undefined ) {
+
+			this.material.color.set( this.color );
+			this.children[ 0 ].material.color.set( this.color );
+
+		} else {
+
+			this.material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
+
+			// prevent hue shift
+			const c = this.material.color;
+			const max = Math.max( c.r, c.g, c.b );
+			if ( max > 1 ) c.multiplyScalar( 1 / max );
+
+			this.children[ 0 ].material.color.copy( this.material.color );
+
+		}
+
+		// ignore world scale on light
+		this.matrixWorld.extractRotation( this.light.matrixWorld ).scale( this.scale ).copyPosition( this.light.matrixWorld );
+
+		this.children[ 0 ].matrixWorld.copy( this.matrixWorld );
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+		this.children[ 0 ].geometry.dispose();
+		this.children[ 0 ].material.dispose();
+
+	}
+
+}
+
+export { RectAreaLightHelper };

package/Resources/WebLibraries/three/addons/helpers/TextureHelper.js

@@ -0,0 +1,265 @@
+import {
+	BoxGeometry,
+	BufferAttribute,
+	DoubleSide,
+	Mesh,
+	PlaneGeometry,
+	ShaderMaterial,
+	Vector3,
+} from 'three';
+import { mergeGeometries } from '../utils/BufferGeometryUtils.js';
+
+/**
+ * A helper that can be used to display any type of texture for
+ * debugging purposes. Depending on the type of texture (2D, 3D, Array),
+ * the helper becomes a plane or box mesh.
+ *
+ * This helper can only be used with {@link WebGLRenderer}.
+ * When using {@link WebGPURenderer}, import from `TextureHelperGPU.js`.
+ *
+ * @augments Mesh
+ * @three_import import { TextureHelper } from 'three/addons/helpers/TextureHelper.js';
+ */
+class TextureHelper extends Mesh {
+
+	/**
+	 * Constructs a new texture helper.
+	 *
+	 * @param {Texture} texture - The texture to visualize.
+	 * @param {number} [width=1] - The helper's width.
+	 * @param {number} [height=1] - The helper's height.
+	 * @param {number} [depth=1] - The helper's depth.
+	 */
+	constructor( texture, width = 1, height = 1, depth = 1 ) {
+
+		const material = new ShaderMaterial( {
+
+			type: 'TextureHelperMaterial',
+
+			side: DoubleSide,
+			transparent: true,
+
+			uniforms: {
+
+				map: { value: texture },
+				alpha: { value: getAlpha( texture ) },
+
+			},
+
+			vertexShader: [
+
+				'attribute vec3 uvw;',
+
+				'varying vec3 vUvw;',
+
+				'void main() {',
+
+				'	vUvw = uvw;',
+
+				'	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',
+
+				'}',
+
+			].join( '\n' ),
+
+			fragmentShader: [
+
+				'precision highp float;',
+
+				'precision highp sampler2DArray;',
+
+				'precision highp sampler3D;',
+
+				'uniform {samplerType} map;',
+
+				'uniform float alpha;',
+
+				'varying vec3 vUvw;',
+
+				'vec4 textureHelper( in sampler2D map ) { return texture( map, vUvw.xy ); }',
+
+				'vec4 textureHelper( in sampler2DArray map ) { return texture( map, vUvw ); }',
+
+				'vec4 textureHelper( in sampler3D map ) { return texture( map, vUvw ); }',
+
+				'vec4 textureHelper( in samplerCube map ) { return texture( map, vUvw ); }',
+
+				'void main() {',
+
+				'	gl_FragColor = linearToOutputTexel( vec4( textureHelper( map ).xyz, alpha ) );',
+
+				'}'
+
+			].join( '\n' ).replace( '{samplerType}', getSamplerType( texture ) )
+
+		} );
+
+		const geometry = texture.isCubeTexture
+			? createCubeGeometry( width, height, depth )
+			: createSliceGeometry( texture, width, height, depth );
+
+		super( geometry, material );
+
+		/**
+		 * The texture to visualize.
+		 *
+		 * @type {Texture}
+		 */
+		this.texture = texture;
+		this.type = 'TextureHelper';
+
+	}
+
+	/**
+	 * Frees the GPU-related resources allocated by this instance. Call this
+	 * method whenever this instance is no longer used in your app.
+	 */
+	dispose() {
+
+		this.geometry.dispose();
+		this.material.dispose();
+
+	}
+
+}
+
+function getSamplerType( texture ) {
+
+	if ( texture.isCubeTexture ) {
+
+		return 'samplerCube';
+
+	} else if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
+
+		return 'sampler2DArray';
+
+	} else if ( texture.isData3DTexture || texture.isCompressed3DTexture ) {
+
+		return 'sampler3D';
+
+	} else {
+
+		return 'sampler2D';
+
+	}
+
+}
+
+function getImageCount( texture ) {
+
+	if ( texture.isCubeTexture ) {
+
+		return 6;
+
+	} else if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
+
+		return texture.image.depth;
+
+	} else if ( texture.isData3DTexture || texture.isCompressed3DTexture ) {
+
+		return texture.image.depth;
+
+	} else {
+
+		return 1;
+
+	}
+
+}
+
+function getAlpha( texture ) {
+
+	if ( texture.isCubeTexture ) {
+
+		return 1;
+
+	} else if ( texture.isDataArrayTexture || texture.isCompressedArrayTexture ) {
+
+		return Math.max( 1 / texture.image.depth, 0.25 );
+
+	} else if ( texture.isData3DTexture || texture.isCompressed3DTexture ) {
+
+		return Math.max( 1 / texture.image.depth, 0.25 );
+
+	} else {
+
+		return 1;
+
+	}
+
+}
+
+function createCubeGeometry( width, height, depth ) {
+
+	const geometry = new BoxGeometry( width, height, depth );
+
+	const position = geometry.attributes.position;
+	const uv = geometry.attributes.uv;
+	const uvw = new BufferAttribute( new Float32Array( uv.count * 3 ), 3 );
+
+	const _direction = new Vector3();
+
+	for ( let j = 0, jl = uv.count; j < jl; ++ j ) {
+
+		_direction.fromBufferAttribute( position, j ).normalize();
+
+		const u = _direction.x;
+		const v = _direction.y;
+		const w = _direction.z;
+
+		uvw.setXYZ( j, u, v, w );
+
+	}
+
+	geometry.deleteAttribute( 'uv' );
+	geometry.setAttribute( 'uvw', uvw );
+
+	return geometry;
+
+}
+
+function createSliceGeometry( texture, width, height, depth ) {
+
+	const sliceCount = getImageCount( texture );
+
+	const geometries = [];
+
+	for ( let i = 0; i < sliceCount; ++ i ) {
+
+		const geometry = new PlaneGeometry( width, height );
+
+		if ( sliceCount > 1 ) {
+
+			geometry.translate( 0, 0, depth * ( i / ( sliceCount - 1 ) - 0.5 ) );
+
+		}
+
+		const uv = geometry.attributes.uv;
+		const uvw = new BufferAttribute( new Float32Array( uv.count * 3 ), 3 );
+
+		for ( let j = 0, jl = uv.count; j < jl; ++ j ) {
+
+			const u = uv.getX( j );
+			const v = texture.flipY ? uv.getY( j ) : 1 - uv.getY( j );
+			const w = sliceCount === 1
+				? 1
+				: texture.isDataArrayTexture || texture.isCompressedArrayTexture
+					? i
+					: i / ( sliceCount - 1 );
+
+			uvw.setXYZ( j, u, v, w );
+
+		}
+
+		geometry.deleteAttribute( 'uv' );
+		geometry.setAttribute( 'uvw', uvw );
+
+		geometries.push( geometry );
+
+	}
+
+	return mergeGeometries( geometries );
+
+}
+
+export { TextureHelper };