Math.js

import { Box3 } from './Box3.js';
import { Sphere } from './Sphere.js';
import { Vector3 } from './Vector3.js';

/**
 * Copyright © 2010-2021 three.js authors
 */

var _lut = [];

for ( var i = 0; i < 256; i ++ ) {

	_lut[ i ] = ( i < 16 ? '0' : '' ) + ( i ).toString( 16 );

}

var _Math = {

	DEG2RAD: Math.PI / 180,
	RAD2DEG: 180 / Math.PI,

	generateUUID: function () {

		// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136

		var d0 = Math.random() * 0xffffffff | 0;
		var d1 = Math.random() * 0xffffffff | 0;
		var d2 = Math.random() * 0xffffffff | 0;
		var d3 = Math.random() * 0xffffffff | 0;
		var uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
			_lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
			_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
			_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];

		// .toUpperCase() here flattens concatenated strings to save heap memory space.
		return uuid.toUpperCase();

	},

	clamp: function ( value, min, max ) {

		return Math.max( min, Math.min( max, value ) );

	},

	// compute euclidian modulo of m % n
	// https://en.wikipedia.org/wiki/Modulo_operation

	euclideanModulo: function ( n, m ) {

		return ( ( n % m ) + m ) % m;

	},

	// Linear mapping from range <a1, a2> to range <b1, b2>

	mapLinear: function ( x, a1, a2, b1, b2 ) {

		return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );

	},

	// https://en.wikipedia.org/wiki/Linear_interpolation

	lerp: function ( x, y, t ) {

		return ( 1 - t ) * x + t * y;

	},

	// http://en.wikipedia.org/wiki/Smoothstep

	smoothstep: function ( x, min, max ) {

		if ( x <= min ) return 0;
		if ( x >= max ) return 1;

		x = ( x - min ) / ( max - min );

		return x * x * ( 3 - 2 * x );

	},

	smootherstep: function ( x, min, max ) {

		if ( x <= min ) return 0;
		if ( x >= max ) return 1;

		x = ( x - min ) / ( max - min );

		return x * x * x * ( x * ( x * 6 - 15 ) + 10 );

	},

	// Random integer from <low, high> interval

	randInt: function ( low, high ) {

		return low + Math.floor( Math.random() * ( high - low + 1 ) );

	},

	// Random float from <low, high> interval

	randFloat: function ( low, high ) {

		return low + Math.random() * ( high - low );

	},

	// Random float from <-range/2, range/2> interval

	randFloatSpread: function ( range ) {

		return range * ( 0.5 - Math.random() );

	},

	degToRad: function ( degrees ) {

		return degrees * _Math.DEG2RAD;

	},

	radToDeg: function ( radians ) {

		return radians * _Math.RAD2DEG;

	},

	isPowerOfTwo: function ( value ) {

		return ( value & ( value - 1 ) ) === 0 && value !== 0;

	},

	ceilPowerOfTwo: function ( value ) {

		return Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );

	},

	floorPowerOfTwo: function ( value ) {

		return Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );

	},

	computeSpheresBoundingSphere: function (spheres) {
		// List of the sphere "axis extrema"
		let sphereAxisExtrema = [];

		for (let i = 0; i < spheres.length; i++) {
			// Bounding box
			let box = spheres[i].getBoundingBox();

			// Lower box (x, y, z)
			let boxMin = box.min;
			// Higher box (x, y, z)
			let boxMax = box.max;

			let center = spheres[i].center;

			// Generate 6 edge points of the sphere
			for (let j = 0; j < 3; j++) {
				sphereAxisExtrema.push(...center.toArray());
				sphereAxisExtrema[sphereAxisExtrema.length - (3 - j)] = boxMin.getComponent(j);

				sphereAxisExtrema.push(...center.toArray());
				sphereAxisExtrema[sphereAxisExtrema.length - (3 - j)] = boxMax.getComponent(j);
			}
		}

		// AABB bounding sphere method
		let boxAll = new Box3();
		let sphereAll = new Sphere();
		let vector = new Vector3();

		// Set initial bounding sphere based on the bounding box
		boxAll.setFromArray(sphereAxisExtrema);
		boxAll.center(sphereAll.center);

		// Optimize sphere radius
		let maxRadiusSq = 0;

		for (let i = 0; i < sphereAxisExtrema.length; i += 3) {
			vector.fromArray(sphereAxisExtrema, i);
			maxRadiusSq = Math.max(maxRadiusSq, sphereAll.center.distanceToSquared(vector));
		}

		sphereAll.radius = Math.sqrt(maxRadiusSq);

		if (isNaN(sphereAll.radius)) {
			console.error('Geometry error: Bounding sphere radius is NaN.');
		}

		return sphereAll;
	}
};


export { _Math };