@lampdotdev/lamp 0.0.0-stage → 0.35.0

package/Resources/WebLibraries/three/addons/utils/CameraUtils.js

@@ -0,0 +1,82 @@
+import {
+	MathUtils,
+	Quaternion,
+	Vector3
+} from 'three';
+
+/**
+ * @module CameraUtils
+ * @three_import import * as CameraUtils from 'three/addons/utils/CameraUtils.js';
+ */
+
+const _va = /*@__PURE__*/ new Vector3(), // from pe to pa
+	_vb = /*@__PURE__*/ new Vector3(), // from pe to pb
+	_vc = /*@__PURE__*/ new Vector3(), // from pe to pc
+	_vr = /*@__PURE__*/ new Vector3(), // right axis of screen
+	_vu = /*@__PURE__*/ new Vector3(), // up axis of screen
+	_vn = /*@__PURE__*/ new Vector3(), // normal vector of screen
+	_vec = /*@__PURE__*/ new Vector3(), // temporary vector
+	_quat = /*@__PURE__*/ new Quaternion(); // temporary quaternion
+
+
+/**
+ * Set projection matrix and the orientation of a perspective camera
+ * to exactly frame the corners of an arbitrary rectangle.
+ * NOTE: This function ignores the standard parameters;
+ * do not call `updateProjectionMatrix()` after this.
+ *
+ * @param {PerspectiveCamera} camera - The camera.
+ * @param {Vector3} bottomLeftCorner - The bottom-left corner point.
+ * @param {Vector3} bottomRightCorner - The bottom-right corner point.
+ * @param {Vector3} topLeftCorner - The top-left corner point.
+ * @param {boolean} [estimateViewFrustum=false] - If set to `true`, the function tries to estimate the camera's FOV.
+ */
+function frameCorners( camera, bottomLeftCorner, bottomRightCorner, topLeftCorner, estimateViewFrustum = false ) {
+
+	const pa = bottomLeftCorner, pb = bottomRightCorner, pc = topLeftCorner;
+	const pe = camera.position; // eye position
+	const n = camera.near; // distance of near clipping plane
+	const f = camera.far; //distance of far clipping plane
+
+	_vr.copy( pb ).sub( pa ).normalize();
+	_vu.copy( pc ).sub( pa ).normalize();
+	_vn.crossVectors( _vr, _vu ).normalize();
+
+	_va.copy( pa ).sub( pe ); // from pe to pa
+	_vb.copy( pb ).sub( pe ); // from pe to pb
+	_vc.copy( pc ).sub( pe ); // from pe to pc
+
+	const d = - _va.dot( _vn );	// distance from eye to screen
+	const l = _vr.dot( _va ) * n / d; // distance to left screen edge
+	const r = _vr.dot( _vb ) * n / d; // distance to right screen edge
+	const b = _vu.dot( _va ) * n / d; // distance to bottom screen edge
+	const t = _vu.dot( _vc ) * n / d; // distance to top screen edge
+
+	// Set the camera rotation to match the focal plane to the corners' plane
+	_quat.setFromUnitVectors( _vec.set( 0, 1, 0 ), _vu );
+	camera.quaternion.setFromUnitVectors( _vec.set( 0, 0, 1 ).applyQuaternion( _quat ), _vn ).multiply( _quat );
+
+	// Set the off-axis projection matrix to match the corners
+	camera.projectionMatrix.set( 2.0 * n / ( r - l ), 0.0,
+		( r + l ) / ( r - l ), 0.0, 0.0,
+		2.0 * n / ( t - b ),
+		( t + b ) / ( t - b ), 0.0, 0.0, 0.0,
+		( f + n ) / ( n - f ),
+		2.0 * f * n / ( n - f ), 0.0, 0.0, - 1.0, 0.0 );
+	camera.projectionMatrixInverse.copy( camera.projectionMatrix ).invert();
+
+	// FoV estimation to fix frustum culling
+	if ( estimateViewFrustum ) {
+
+		// Set fieldOfView to a conservative estimate
+		// to make frustum tall/wide enough to encompass it
+		camera.fov =
+			MathUtils.RAD2DEG / Math.min( 1.0, camera.aspect ) *
+			Math.atan( ( _vec.copy( pb ).sub( pa ).length() +
+							( _vec.copy( pc ).sub( pa ).length() ) ) / _va.length() );
+
+	}
+
+}
+
+export { frameCorners };

package/Resources/WebLibraries/three/addons/utils/ColorUtils.js

@@ -0,0 +1,76 @@
+import { MathUtils, SRGBColorSpace } from 'three';
+
+/**
+ * @module ColorUtils
+ * @three_import import * as ColorUtils from 'three/addons/utils/ColorUtils.js';
+ */
+
+/**
+ * Sets the given color from a color temperature in Kelvin.
+ *
+ * Converts a correlated color temperature (CTT) to an approximate sRGB color
+ * using Tanner Helland's algorithm. Useful for physically-based lighting
+ * setups — e.g. candle flame (~1900K), tungsten bulb (~3200K), daylight
+ * (~6500K), or clear blue sky (~10000K). Values outside [1000, 40000] are
+ * clamped.
+ *
+ * Reference: https://tannerhelland.com/2012/09/18/convert-temperature-rgb-algorithm-code.html
+ *
+ * @param {Color} color - The color to set.
+ * @param {number} kelvin - Color temperature in Kelvin. Clamped to [1000, 40000].
+ * @return {Color} The updated color.
+ */
+function setKelvin( color, kelvin ) {
+
+	// Algorithm by Tanner Helland (2012). Inputs are divided by 100.
+	const temp = MathUtils.clamp( kelvin, 1000, 40000 ) / 100;
+
+	let r, g, b;
+
+	// Red channel
+	if ( temp <= 66 ) {
+
+		r = 255;
+
+	} else {
+
+		r = 329.698727446 * Math.pow( temp - 60, - 0.1332047592 );
+
+	}
+
+	// Green channel
+	if ( temp <= 66 ) {
+
+		g = 99.4708025861 * Math.log( temp ) - 161.1195681661;
+
+	} else {
+
+		g = 288.1221695283 * Math.pow( temp - 60, - 0.0755148492 );
+
+	}
+
+	// Blue channel
+	if ( temp >= 66 ) {
+
+		b = 255;
+
+	} else if ( temp <= 19 ) {
+
+		b = 0;
+
+	} else {
+
+		b = 138.5177312231 * Math.log( temp - 10 ) - 305.0447927307;
+
+	}
+
+	return color.setRGB(
+		MathUtils.clamp( r, 0, 255 ) / 255,
+		MathUtils.clamp( g, 0, 255 ) / 255,
+		MathUtils.clamp( b, 0, 255 ) / 255,
+		SRGBColorSpace
+	);
+
+}
+
+export { setKelvin };

package/Resources/WebLibraries/three/addons/utils/GaussianSplatUtils.js

@@ -0,0 +1,229 @@
+import {
+	BufferAttribute,
+	BufferGeometry,
+	Matrix3,
+	Matrix4,
+	Quaternion,
+	Vector3
+} from 'three';
+
+const SH_C0 = 0.2820947917738781;
+const SH_BAND_COMPONENTS = [ 0, 9, 15, 21 ];
+// GPU upload packs four clamped-byte coefficients per uint32 word.
+const SH_BAND_WORDS = [ 0, 3, 4, 6 ];
+
+const _covarianceMatrix = new Matrix3();
+const _covarianceMatrixTranspose = new Matrix3();
+const _rotationScaleMatrix = new Matrix4();
+const _quaternion = new Quaternion();
+const _scale = new Vector3();
+const _zero = new Vector3();
+
+function sigmoid( value ) {
+
+	return 1 / ( 1 + Math.exp( - value ) );
+
+}
+
+// The target is expected to be a Uint8ClampedArray, which clamps and rounds
+// assigned values natively.
+function writeColorBytes( target, offset, r, g, b, a ) {
+
+	target[ offset ] = r;
+	target[ offset + 1 ] = g;
+	target[ offset + 2 ] = b;
+	target[ offset + 3 ] = a;
+
+}
+
+function sh0ToLinear( coefficient ) {
+
+	return coefficient * SH_C0 + 0.5;
+
+}
+
+function linearToSH0( color ) {
+
+	return ( color - 0.5 ) / SH_C0;
+
+}
+
+function writeColorBytesFromSH0( target, offset, r, g, b, a ) {
+
+	writeColorBytes(
+		target,
+		offset,
+		sh0ToLinear( r ) * 255,
+		sh0ToLinear( g ) * 255,
+		sh0ToLinear( b ) * 255,
+		a * 255
+	);
+
+}
+
+function writeCovariance( target, offset, sx, sy, sz, qx, qy, qz, qw ) {
+
+	_quaternion.set( qx, qy, qz, qw ).normalize();
+	_scale.set( sx, sy, sz );
+	_rotationScaleMatrix.compose( _zero, _quaternion, _scale );
+
+	_covarianceMatrix.setFromMatrix4( _rotationScaleMatrix );
+	_covarianceMatrixTranspose.copy( _covarianceMatrix ).transpose();
+	_covarianceMatrix.multiply( _covarianceMatrixTranspose );
+
+	const elements = _covarianceMatrix.elements;
+
+	target[ offset ] = elements[ 0 ];
+	target[ offset + 1 ] = elements[ 3 ];
+	target[ offset + 2 ] = elements[ 6 ];
+	target[ offset + 3 ] = elements[ 4 ];
+	target[ offset + 4 ] = elements[ 7 ];
+	target[ offset + 5 ] = elements[ 8 ];
+
+}
+
+function createPackedSphericalHarmonicsBand( count, degree ) {
+
+	const packed = new Uint32Array( count * SH_BAND_WORDS[ degree ] );
+	packed.fill( 0x80808080 );
+
+	return {
+		packed,
+		bytes: new Uint8ClampedArray( packed.buffer )
+	};
+
+}
+
+function createSphericalHarmonicsAttribute( values, count, degree ) {
+
+	const words = SH_BAND_WORDS[ degree ];
+
+	if ( values instanceof Uint32Array === false ) {
+
+		throw new Error( `THREE.createGaussianSplatGeometry: sphericalHarmonics${ degree } must use packed uint32 words.` );
+
+	}
+
+	if ( values.length !== count * words ) {
+
+		throw new Error( `THREE.createGaussianSplatGeometry: Invalid sphericalHarmonics${ degree } packed length.` );
+
+	}
+
+	return new BufferAttribute( values, words );
+
+}
+
+function getSphericalHarmonicsDegree( geometry ) {
+
+	if ( geometry === undefined || geometry.isBufferGeometry !== true ) return 0;
+
+	let degree = 0;
+
+	for ( let i = 1; i <= 3; i ++ ) {
+
+		const attribute = geometry.getAttribute( `sphericalHarmonics${ i }` );
+
+		if ( attribute === undefined ) break;
+
+		if ( attribute.itemSize !== SH_BAND_WORDS[ i ] ) {
+
+			throw new Error( `THREE.getSphericalHarmonicsDegree: Invalid sphericalHarmonics${ i } itemSize.` );
+
+		}
+
+		if ( attribute.array instanceof Uint32Array === false ) {
+
+			throw new Error( `THREE.getSphericalHarmonicsDegree: sphericalHarmonics${ i } must use packed uint32 words.` );
+
+		}
+
+		degree = i;
+
+	}
+
+	for ( let i = degree + 1; i <= 3; i ++ ) {
+
+		if ( geometry.getAttribute( `sphericalHarmonics${ i }` ) !== undefined ) {
+
+			throw new Error( 'THREE.getSphericalHarmonicsDegree: Spherical harmonics attributes must be contiguous.' );
+
+		}
+
+	}
+
+	const position = geometry.getAttribute( 'position' );
+
+	if ( position !== undefined ) {
+
+		for ( let i = 1; i <= degree; i ++ ) {
+
+			if ( geometry.getAttribute( `sphericalHarmonics${ i }` ).count !== position.count ) {
+
+				throw new Error( 'THREE.getSphericalHarmonicsDegree: Spherical harmonics attribute counts must match position.' );
+
+			}
+
+		}
+
+	}
+
+	return degree;
+
+}
+
+/**
+ * Creates Gaussian splat geometry from packed attribute arrays. Higher-order
+ * spherical harmonics must be supplied as packed `Uint32Array` words
+ * (`SH_BAND_WORDS[ degree ]` words per splat, four clamped-byte coefficients
+ * per word using `( value - 128 ) / 128`).
+ *
+ * @param {Float32Array} centers - Splat centers.
+ * @param {Float32Array} covariances - Splat covariance matrices.
+ * @param {Uint8Array|Uint8ClampedArray} colors - RGBA colors.
+ * @param {Object} [sphericalHarmonics={}] - Optional packed SH band arrays.
+ * @return {BufferGeometry} The Gaussian splat geometry.
+ */
+function createGaussianSplatGeometry( centers, covariances, colors, sphericalHarmonics = {} ) {
+
+	const geometry = new BufferGeometry();
+	geometry.setAttribute( 'position', new BufferAttribute( centers, 3 ) );
+	geometry.setAttribute( 'covariance', new BufferAttribute( covariances, 6 ) );
+	geometry.setAttribute( 'color', new BufferAttribute( colors, 4, true ) );
+
+	const count = centers.length / 3;
+
+	for ( let i = 1; i <= 3; i ++ ) {
+
+		const values = sphericalHarmonics[ `sh${ i }` ] || sphericalHarmonics[ `sphericalHarmonics${ i }` ];
+
+		if ( values !== undefined ) {
+
+			geometry.setAttribute( `sphericalHarmonics${ i }`, createSphericalHarmonicsAttribute( values, count, i ) );
+
+		}
+
+	}
+
+	getSphericalHarmonicsDegree( geometry );
+	geometry.computeBoundingBox();
+	geometry.computeBoundingSphere();
+
+	return geometry;
+
+}
+
+export {
+	SH_BAND_COMPONENTS,
+	SH_BAND_WORDS,
+	SH_C0,
+	createGaussianSplatGeometry,
+	createPackedSphericalHarmonicsBand,
+	getSphericalHarmonicsDegree,
+	linearToSH0,
+	sh0ToLinear,
+	sigmoid,
+	writeColorBytes,
+	writeColorBytesFromSH0,
+	writeCovariance
+};