knso/Webklar.com
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

main repo

Browse Source
This commit is contained in:
Basilosaurusrex
2025-11-24 18:09:40 +01:00
parent b636ee5e70
commit f027651f9b
34146 changed files with 4436636 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
node_modules/three/examples/jsm/math/Capsule.js generated vendored Normal file
View File

@@ -0,0 +1,159 @@
import {
Vector3
} from 'three';
/**
* A capsule is essentially a cylinder with hemispherical caps at both ends.
* It can be thought of as a swept sphere, where a sphere is moved along a line segment.
*
* Capsules are often used as bounding volumes (next to AABBs and bounding spheres).
*
* @three_import import { Capsule } from 'three/addons/math/Capsule.js';
*/
class Capsule {
/**
* Constructs a new capsule.
*
* @param {Vector3} [start] - The start vector.
* @param {Vector3} [end] - The end vector.
* @param {number} [radius=1] - The capsule's radius.
*/
constructor( start = new Vector3( 0, 0, 0 ), end = new Vector3( 0, 1, 0 ), radius = 1 ) {
/**
* The start vector.
*
* @type {Vector3}
*/
this.start = start;
/**
* The end vector.
*
* @type {Vector3}
*/
this.end = end;
/**
* The capsule's radius.
*
* @type {number}
* @default 1
*/
this.radius = radius;
}
/**
* Returns a new capsule with copied values from this instance.
*
* @return {Capsule} A clone of this instance.
*/
clone() {
return new this.constructor().copy( this );
}
/**
* Sets the capsule components to the given values.
* Please note that this method only copies the values from the given objects.
*
* @param {Vector3} start - The start vector.
* @param {Vector3} end - The end vector
* @param {number} radius - The capsule's radius.
* @return {Capsule} A reference to this capsule.
*/
set( start, end, radius ) {
this.start.copy( start );
this.end.copy( end );
this.radius = radius;
return this;
}
/**
* Copies the values of the given capsule to this instance.
*
* @param {Capsule} capsule - The capsule to copy.
* @return {Capsule} A reference to this capsule.
*/
copy( capsule ) {
this.start.copy( capsule.start );
this.end.copy( capsule.end );
this.radius = capsule.radius;
return this;
}
/**
* Returns the center point of this capsule.
*
* @param {Vector3} target - The target vector that is used to store the method's result.
* @return {Vector3} The center point.
*/
getCenter( target ) {
return target.copy( this.end ).add( this.start ).multiplyScalar( 0.5 );
}
/**
* Adds the given offset to this capsule, effectively moving it in 3D space.
*
* @param {Vector3} v - The offset that should be used to translate the capsule.
* @return {Capsule} A reference to this capsule.
*/
translate( v ) {
this.start.add( v );
this.end.add( v );
return this;
}
/**
* Returns `true` if the given bounding box intersects with this capsule.
*
* @param {Box3} box - The bounding box to test.
* @return {boolean} Whether the given bounding box intersects with this capsule.
*/
intersectsBox( box ) {
return (
checkAABBAxis(
this.start.x, this.start.y, this.end.x, this.end.y,
box.min.x, box.max.x, box.min.y, box.max.y,
this.radius ) &&
checkAABBAxis(
this.start.x, this.start.z, this.end.x, this.end.z,
box.min.x, box.max.x, box.min.z, box.max.z,
this.radius ) &&
checkAABBAxis(
this.start.y, this.start.z, this.end.y, this.end.z,
box.min.y, box.max.y, box.min.z, box.max.z,
this.radius )
);
}
}
function checkAABBAxis( p1x, p1y, p2x, p2y, minx, maxx, miny, maxy, radius ) {
return (
( minx - p1x < radius || minx - p2x < radius ) &&
( p1x - maxx < radius || p2x - maxx < radius ) &&
( miny - p1y < radius || miny - p2y < radius ) &&
( p1y - maxy < radius || p2y - maxy < radius )
);
}
export { Capsule };

58
node_modules/three/examples/jsm/math/ColorConverter.js generated vendored Normal file
View File

@@ -0,0 +1,58 @@
import { MathUtils } from 'three';
const _hsl = {};
/**
* A utility class with helper functions for color conversion.
*
* @hideconstructor
* @three_import import { ColorConverter } from 'three/addons/math/ColorConverter.js';
*/
class ColorConverter {
/**
* Sets the given HSV color definition to the given color object.
*
* @param {Color} color - The color to set.
* @param {number} h - The hue.
* @param {number} s - The saturation.
* @param {number} v - The value.
* @return {Color} The update color.
*/
static setHSV( color, h, s, v ) {
// https://gist.github.com/xpansive/1337890#file-index-js
h = MathUtils.euclideanModulo( h, 1 );
s = MathUtils.clamp( s, 0, 1 );
v = MathUtils.clamp( v, 0, 1 );
return color.setHSL( h, ( s * v ) / ( ( h = ( 2 - s ) * v ) < 1 ? h : ( 2 - h ) ), h * 0.5 );
}
/**
* Returns a HSV color representation of the given color object.
*
* @param {Color} color - The color to get HSV values from.
* @param {{h:number,s:number,v:number}} target - The target object that is used to store the method's result.
* @return {{h:number,s:number,v:number}} The HSV color.
*/
static getHSV( color, target ) {
color.getHSL( _hsl );
// based on https://gist.github.com/xpansive/1337890#file-index-js
_hsl.s *= ( _hsl.l < 0.5 ) ? _hsl.l : ( 1 - _hsl.l );
target.h = _hsl.h;
target.s = 2 * _hsl.s / ( _hsl.l + _hsl.s );
target.v = _hsl.l + _hsl.s;
return target;
}
}
export { ColorConverter };

147
node_modules/three/examples/jsm/math/ColorSpaces.js generated vendored Normal file
View File

@@ -0,0 +1,147 @@
import { LinearTransfer, Matrix3, SRGBTransfer, SRGBColorSpace, ColorManagement } from 'three';
/** @module ColorSpaces */
// Reference: http://www.russellcottrell.com/photo/matrixCalculator.htm
const P3_PRIMARIES = [ 0.680, 0.320, 0.265, 0.690, 0.150, 0.060 ];
const P3_LUMINANCE_COEFFICIENTS = [ 0.2289, 0.6917, 0.0793 ];
const REC2020_PRIMARIES = [ 0.708, 0.292, 0.170, 0.797, 0.131, 0.046 ];
const REC2020_LUMINANCE_COEFFICIENTS = [ 0.2627, 0.6780, 0.0593 ];
const D65 = [ 0.3127, 0.3290 ];
/******************************************************************************
* Display P3 definitions
*/
const LINEAR_DISPLAY_P3_TO_XYZ = /*@__PURE__*/ new Matrix3().set(
0.4865709, 0.2656677, 0.1982173,
0.2289746, 0.6917385, 0.0792869,
0.0000000, 0.0451134, 1.0439444
);
const XYZ_TO_LINEAR_DISPLAY_P3 = /*@__PURE__*/ new Matrix3().set(
2.4934969, - 0.9313836, - 0.4027108,
- 0.8294890, 1.7626641, 0.0236247,
0.0358458, - 0.0761724, 0.9568845
);
/**
* Display-P3 color space.
*
* @type {string}
* @constant
*/
export const DisplayP3ColorSpace = 'display-p3';
/**
* Display-P3-Linear color space.
*
* @type {string}
* @constant
*/
export const LinearDisplayP3ColorSpace = 'display-p3-linear';
/**
* Implementation object for the Display-P3 color space.
*
* @type {module:ColorSpaces~ColorSpaceImpl}
* @constant
*/
export const DisplayP3ColorSpaceImpl = {
primaries: P3_PRIMARIES,
whitePoint: D65,
transfer: SRGBTransfer,
toXYZ: LINEAR_DISPLAY_P3_TO_XYZ,
fromXYZ: XYZ_TO_LINEAR_DISPLAY_P3,
luminanceCoefficients: P3_LUMINANCE_COEFFICIENTS,
outputColorSpaceConfig: { drawingBufferColorSpace: DisplayP3ColorSpace }
};
/**
* Implementation object for the Display-P3-Linear color space.
*
* @type {module:ColorSpaces~ColorSpaceImpl}
* @constant
*/
export const LinearDisplayP3ColorSpaceImpl = {
primaries: P3_PRIMARIES,
whitePoint: D65,
transfer: LinearTransfer,
toXYZ: LINEAR_DISPLAY_P3_TO_XYZ,
fromXYZ: XYZ_TO_LINEAR_DISPLAY_P3,
luminanceCoefficients: P3_LUMINANCE_COEFFICIENTS,
workingColorSpaceConfig: { unpackColorSpace: DisplayP3ColorSpace },
outputColorSpaceConfig: { drawingBufferColorSpace: DisplayP3ColorSpace }
};
/******************************************************************************
* Rec. 2020 definitions
*/
const LINEAR_REC2020_TO_XYZ = /*@__PURE__*/ new Matrix3().set(
0.6369580, 0.1446169, 0.1688810,
0.2627002, 0.6779981, 0.0593017,
0.0000000, 0.0280727, 1.0609851
);
const XYZ_TO_LINEAR_REC2020 = /*@__PURE__*/ new Matrix3().set(
1.7166512, - 0.3556708, - 0.2533663,
- 0.6666844, 1.6164812, 0.0157685,
0.0176399, - 0.0427706, 0.9421031
);
/**
* Rec2020-Linear color space.
*
* @type {string}
* @constant
*/
export const LinearRec2020ColorSpace = 'rec2020-linear';
/**
* Implementation object for the Rec2020-Linear color space.
*
* @type {module:ColorSpaces~ColorSpaceImpl}
* @constant
*/
export const LinearRec2020ColorSpaceImpl = {
primaries: REC2020_PRIMARIES,
whitePoint: D65,
transfer: LinearTransfer,
toXYZ: LINEAR_REC2020_TO_XYZ,
fromXYZ: XYZ_TO_LINEAR_REC2020,
luminanceCoefficients: REC2020_LUMINANCE_COEFFICIENTS,
};
/**
* Extended-sRGB color space.
*
* @type {string}
* @constant
*/
export const ExtendedSRGBColorSpace = 'extended-srgb';
/**
* Implementation object for the Extended-sRGB color space.
*
* @type {module:ColorSpaces~ColorSpaceImpl}
* @constant
*/
export const ExtendedSRGBColorSpaceImpl = {
...ColorManagement.spaces[ SRGBColorSpace ],
outputColorSpaceConfig: { drawingBufferColorSpace: SRGBColorSpace, toneMappingMode: 'extended' }
};
/**
* An object holding the color space implementation.
*
* @typedef {Object} module:ColorSpaces~ColorSpaceImpl
* @property {Array<number>} primaries - The primaries.
* @property {Array<number>} whitePoint - The white point.
* @property {Matrix3} toXYZ - A color space conversion matrix, converting to CIE XYZ.
* @property {Matrix3} fromXYZ - A color space conversion matrix, converting from CIE XYZ.
* @property {Array<number>} luminanceCoefficients - The luminance coefficients.
* @property {{unpackColorSpace:string}} [workingColorSpaceConfig] - The working color space config.
* @property {{drawingBufferColorSpace:string}} [outputColorSpaceConfig] - The drawing buffer color space config.
**/

1695
node_modules/three/examples/jsm/math/ConvexHull.js generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

88
node_modules/three/examples/jsm/math/ImprovedNoise.js generated vendored Normal file
View File

@@ -0,0 +1,88 @@
import { MathUtils } from 'three';
const { lerp } = MathUtils;
const _p = [ 151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10,
23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87,
174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211,
133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208,
89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217, 226, 250, 124, 123, 5,
202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213, 119,
248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232,
178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249,
14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205,
93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180 ];
for ( let i = 0; i < 256; i ++ ) {
_p[ 256 + i ] = _p[ i ];
}
function fade( t ) {
return t * t * t * ( t * ( t * 6 - 15 ) + 10 );
}
function grad( hash, x, y, z ) {
const h = hash & 15;
const u = h < 8 ? x : y, v = h < 4 ? y : h == 12 || h == 14 ? x : z;
return ( ( h & 1 ) == 0 ? u : - u ) + ( ( h & 2 ) == 0 ? v : - v );
}
/**
* A utility class providing a 3D noise function.
*
* The code is based on [IMPROVED NOISE]{@link https://cs.nyu.edu/~perlin/noise/}
* by Ken Perlin, 2002.
*
* @three_import import { ImprovedNoise } from 'three/addons/math/ImprovedNoise.js';
*/
class ImprovedNoise {
/**
* Returns a noise value for the given parameters.
*
* @param {number} x - The x coordinate.
* @param {number} y - The y coordinate.
* @param {number} z - The z coordinate.
* @return {number} The noise value.
*/
noise( x, y, z ) {
const floorX = Math.floor( x ), floorY = Math.floor( y ), floorZ = Math.floor( z );
const X = floorX & 255, Y = floorY & 255, Z = floorZ & 255;
x -= floorX;
y -= floorY;
z -= floorZ;
const xMinus1 = x - 1, yMinus1 = y - 1, zMinus1 = z - 1;
const u = fade( x ), v = fade( y ), w = fade( z );
const A = _p[ X ] + Y, AA = _p[ A ] + Z, AB = _p[ A + 1 ] + Z, B = _p[ X + 1 ] + Y, BA = _p[ B ] + Z, BB = _p[ B + 1 ] + Z;
return lerp(
lerp(
lerp( grad( _p[ AA ], x, y, z ), grad( _p[ BA ], xMinus1, y, z ), u ),
lerp( grad( _p[ AB ], x, yMinus1, z ), grad( _p[ BB ], xMinus1, yMinus1, z ), u ),
v
),
lerp(
lerp( grad( _p[ AA + 1 ], x, y, zMinus1 ), grad( _p[ BA + 1 ], xMinus1, y, zMinus1 ), u ),
lerp( grad( _p[ AB + 1 ], x, yMinus1, zMinus1 ), grad( _p[ BB + 1 ], xMinus1, yMinus1, zMinus1 ), u ),
v
),
w
);
}
}
export { ImprovedNoise };

317
node_modules/three/examples/jsm/math/Lut.js generated vendored Normal file
View File

@@ -0,0 +1,317 @@
import {
Color,
LinearSRGBColorSpace,
MathUtils
} from 'three';
/**
* Represents a lookup table for colormaps. It is used to determine the color
* values from a range of data values.
*
* ```js
* const lut = new Lut( 'rainbow', 512 );
* const color = lut.getColor( 0.5 );
* ```
*
* @three_import import { Lut } from 'three/addons/math/Lut.js';
*/
class Lut {
/**
* Constructs a new Lut.
*
* @param {('rainbow'|'cooltowarm'|'blackbody'|'grayscale')} [colormap='rainbow'] - Sets a colormap from predefined list of colormaps.
* @param {number} [count=32] - Sets the number of colors used to represent the data array.
*/
constructor( colormap, count = 32 ) {
/**
* This flag can be used for type testing.
*
* @type {boolean}
* @readonly
* @default true
*/
this.isLut = true;
/**
* The lookup table for the selected color map
*
* @type {Array<Color>}
*/
this.lut = [];
/**
* The currently selected color map.
*
* @type {Array<Array<number>>}
*/
this.map = [];
/**
* The number of colors of the current selected color map.
*
* @type {number}
* @default 32
*/
this.n = 0;
/**
* The minimum value to be represented with the lookup table.
*
* @type {number}
* @default 0
*/
this.minV = 0;
/**
* The maximum value to be represented with the lookup table.
*
* @type {number}
* @default 1
*/
this.maxV = 1;
this.setColorMap( colormap, count );
}
/**
* Sets the given LUT.
*
* @param {Lut} value - The LUT to set.
* @return {Lut} A reference to this LUT.
*/
set( value ) {
if ( value.isLut === true ) {
this.copy( value );
}
return this;
}
/**
* Sets the minimum value to be represented with this LUT.
*
* @param {number} min - The minimum value to be represented with the lookup table.
* @return {Lut} A reference to this LUT.
*/
setMin( min ) {
this.minV = min;
return this;
}
/**
* Sets the maximum value to be represented with this LUT.
*
* @param {number} max - The maximum value to be represented with the lookup table.
* @return {Lut} A reference to this LUT.
*/
setMax( max ) {
this.maxV = max;
return this;
}
/**
* Configure the lookup table for the given color map and number of colors.
*
* @param {string} colormap - The name of the color map.
* @param {number} [count=32] - The number of colors.
* @return {Lut} A reference to this LUT.
*/
setColorMap( colormap, count = 32 ) {
this.map = ColorMapKeywords[ colormap ] || ColorMapKeywords.rainbow;
this.n = count;
const step = 1.0 / this.n;
const minColor = new Color();
const maxColor = new Color();
this.lut.length = 0;
// sample at 0
this.lut.push( new Color( this.map[ 0 ][ 1 ] ) );
// sample at 1/n, ..., (n-1)/n
for ( let i = 1; i < count; i ++ ) {
const alpha = i * step;
for ( let j = 0; j < this.map.length - 1; j ++ ) {
if ( alpha > this.map[ j ][ 0 ] && alpha <= this.map[ j + 1 ][ 0 ] ) {
const min = this.map[ j ][ 0 ];
const max = this.map[ j + 1 ][ 0 ];
minColor.setHex( this.map[ j ][ 1 ], LinearSRGBColorSpace );
maxColor.setHex( this.map[ j + 1 ][ 1 ], LinearSRGBColorSpace );
const color = new Color().lerpColors( minColor, maxColor, ( alpha - min ) / ( max - min ) );
this.lut.push( color );
}
}
}
// sample at 1
this.lut.push( new Color( this.map[ this.map.length - 1 ][ 1 ] ) );
return this;
}
/**
* Copies the given lut.
*
* @param {Lut} lut - The LUT to copy.
* @return {Lut} A reference to this LUT.
*/
copy( lut ) {
this.lut = lut.lut;
this.map = lut.map;
this.n = lut.n;
this.minV = lut.minV;
this.maxV = lut.maxV;
return this;
}
/**
* Returns an instance of Color for the given data value.
*
* @param {number} alpha - The value to lookup.
* @return {Color} The color from the LUT.
*/
getColor( alpha ) {
alpha = MathUtils.clamp( alpha, this.minV, this.maxV );
alpha = ( alpha - this.minV ) / ( this.maxV - this.minV );
const colorPosition = Math.round( alpha * this.n );
return this.lut[ colorPosition ];
}
/**
* Adds a color map to this Lut instance.
*
* @param {string} name - The name of the color map.
* @param {Array<Array<number>>} arrayOfColors - An array of color values. Each value is an array
* holding a threshold and the actual color value as a hexadecimal number.
* @return {Lut} A reference to this LUT.
*/
addColorMap( name, arrayOfColors ) {
ColorMapKeywords[ name ] = arrayOfColors;
return this;
}
/**
* Creates a canvas in order to visualize the lookup table as a texture.
*
* @return {HTMLCanvasElement} The created canvas.
*/
createCanvas() {
const canvas = document.createElement( 'canvas' );
canvas.width = 1;
canvas.height = this.n;
this.updateCanvas( canvas );
return canvas;
}
/**
* Updates the given canvas with the Lut's data.
*
* @param {HTMLCanvasElement} canvas - The canvas to update.
* @return {HTMLCanvasElement} The updated canvas.
*/
updateCanvas( canvas ) {
const ctx = canvas.getContext( '2d', { alpha: false } );
const imageData = ctx.getImageData( 0, 0, 1, this.n );
const data = imageData.data;
let k = 0;
const step = 1.0 / this.n;
const minColor = new Color();
const maxColor = new Color();
const finalColor = new Color();
for ( let i = 1; i >= 0; i -= step ) {
for ( let j = this.map.length - 1; j >= 0; j -- ) {
if ( i < this.map[ j ][ 0 ] && i >= this.map[ j - 1 ][ 0 ] ) {
const min = this.map[ j - 1 ][ 0 ];
const max = this.map[ j ][ 0 ];
minColor.setHex( this.map[ j - 1 ][ 1 ], LinearSRGBColorSpace );
maxColor.setHex( this.map[ j ][ 1 ], LinearSRGBColorSpace );
finalColor.lerpColors( minColor, maxColor, ( i - min ) / ( max - min ) );
data[ k * 4 ] = Math.round( finalColor.r * 255 );
data[ k * 4 + 1 ] = Math.round( finalColor.g * 255 );
data[ k * 4 + 2 ] = Math.round( finalColor.b * 255 );
data[ k * 4 + 3 ] = 255;
k += 1;
}
}
}
ctx.putImageData( imageData, 0, 0 );
return canvas;
}
}
const ColorMapKeywords = {
'rainbow': [[ 0.0, 0x0000FF ], [ 0.2, 0x00FFFF ], [ 0.5, 0x00FF00 ], [ 0.8, 0xFFFF00 ], [ 1.0, 0xFF0000 ]],
'cooltowarm': [[ 0.0, 0x3C4EC2 ], [ 0.2, 0x9BBCFF ], [ 0.5, 0xDCDCDC ], [ 0.8, 0xF6A385 ], [ 1.0, 0xB40426 ]],
'blackbody': [[ 0.0, 0x000000 ], [ 0.2, 0x780000 ], [ 0.5, 0xE63200 ], [ 0.8, 0xFFFF00 ], [ 1.0, 0xFFFFFF ]],
'grayscale': [[ 0.0, 0x000000 ], [ 0.2, 0x404040 ], [ 0.5, 0x7F7F80 ], [ 0.8, 0xBFBFBF ], [ 1.0, 0xFFFFFF ]]
};
export { Lut, ColorMapKeywords };

315
node_modules/three/examples/jsm/math/MeshSurfaceSampler.js generated vendored Normal file
View File

@@ -0,0 +1,315 @@
import {
Triangle,
Vector2,
Vector3
} from 'three';
const _face = new Triangle();
const _color = new Vector3();
const _uva = new Vector2(), _uvb = new Vector2(), _uvc = new Vector2();
/**
* Utility class for sampling weighted random points on the surface of a mesh.
*
* Building the sampler is a one-time O(n) operation. Once built, any number of
* random samples may be selected in O(logn) time. Memory usage is O(n).
*
* References:
* - {@link http://www.joesfer.com/?p=84}
* - {@link https://stackoverflow.com/a/4322940/1314762}
*
* ```js
* const sampler = new MeshSurfaceSampler( surfaceMesh )
* .setWeightAttribute( 'color' )
* .build();
*
* const mesh = new THREE.InstancedMesh( sampleGeometry, sampleMaterial, 100 );
*
* const position = new THREE.Vector3();
* const matrix = new THREE.Matrix4();
*
* // Sample randomly from the surface, creating an instance of the sample geometry at each sample point.
*
* for ( let i = 0; i < 100; i ++ ) {
*
* sampler.sample( position );
* matrix.makeTranslation( position.x, position.y, position.z );
* mesh.setMatrixAt( i, matrix );
*
* }
*
* scene.add( mesh );
* ```
*
* @three_import import { MeshSurfaceSampler } from 'three/addons/math/MeshSurfaceSampler.js';
*/
class MeshSurfaceSampler {
/**
* Constructs a mesh surface sampler.
*
* @param {Mesh} mesh - Surface mesh from which to sample.
*/
constructor( mesh ) {
this.geometry = mesh.geometry;
this.randomFunction = Math.random;
this.indexAttribute = this.geometry.index;
this.positionAttribute = this.geometry.getAttribute( 'position' );
this.normalAttribute = this.geometry.getAttribute( 'normal' );
this.colorAttribute = this.geometry.getAttribute( 'color' );
this.uvAttribute = this.geometry.getAttribute( 'uv' );
this.weightAttribute = null;
this.distribution = null;
}
/**
* Specifies a vertex attribute to be used as a weight when sampling from the surface.
* Faces with higher weights are more likely to be sampled, and those with weights of
* zero will not be sampled at all. For vector attributes, only .x is used in sampling.
*
* If no weight attribute is selected, sampling is randomly distributed by area.
*
* @param {string} name - The attribute name.
* @return {MeshSurfaceSampler} A reference to this sampler.
*/
setWeightAttribute( name ) {
this.weightAttribute = name ? this.geometry.getAttribute( name ) : null;
return this;
}
/**
* Processes the input geometry and prepares to return samples. Any configuration of the
* geometry or sampler must occur before this method is called. Time complexity is O(n)
* for a surface with n faces.
*
* @return {MeshSurfaceSampler} A reference to this sampler.
*/
build() {
const indexAttribute = this.indexAttribute;
const positionAttribute = this.positionAttribute;
const weightAttribute = this.weightAttribute;
const totalFaces = indexAttribute ? ( indexAttribute.count / 3 ) : ( positionAttribute.count / 3 );
const faceWeights = new Float32Array( totalFaces );
// Accumulate weights for each mesh face.
for ( let i = 0; i < totalFaces; i ++ ) {
let faceWeight = 1;
let i0 = 3 * i;
let i1 = 3 * i + 1;
let i2 = 3 * i + 2;
if ( indexAttribute ) {
i0 = indexAttribute.getX( i0 );
i1 = indexAttribute.getX( i1 );
i2 = indexAttribute.getX( i2 );
}
if ( weightAttribute ) {
faceWeight = weightAttribute.getX( i0 )
+ weightAttribute.getX( i1 )
+ weightAttribute.getX( i2 );
}
_face.a.fromBufferAttribute( positionAttribute, i0 );
_face.b.fromBufferAttribute( positionAttribute, i1 );
_face.c.fromBufferAttribute( positionAttribute, i2 );
faceWeight *= _face.getArea();
faceWeights[ i ] = faceWeight;
}
// Store cumulative total face weights in an array, where weight index
// corresponds to face index.
const distribution = new Float32Array( totalFaces );
let cumulativeTotal = 0;
for ( let i = 0; i < totalFaces; i ++ ) {
cumulativeTotal += faceWeights[ i ];
distribution[ i ] = cumulativeTotal;
}
this.distribution = distribution;
return this;
}
/**
* Allows to set a custom random number generator. Default is `Math.random()`.
*
* @param {Function} randomFunction - A random number generator.
* @return {MeshSurfaceSampler} A reference to this sampler.
*/
setRandomGenerator( randomFunction ) {
this.randomFunction = randomFunction;
return this;
}
/**
* Selects a random point on the surface of the input geometry, returning the
* position and optionally the normal vector, color and UV Coordinate at that point.
* Time complexity is O(log n) for a surface with n faces.
*
* @param {Vector3} targetPosition - The target object holding the sampled position.
* @param {Vector3} targetNormal - The target object holding the sampled normal.
* @param {Color} targetColor - The target object holding the sampled color.
* @param {Vector2} targetUV - The target object holding the sampled uv coordinates.
* @return {MeshSurfaceSampler} A reference to this sampler.
*/
sample( targetPosition, targetNormal, targetColor, targetUV ) {
const faceIndex = this._sampleFaceIndex();
return this._sampleFace( faceIndex, targetPosition, targetNormal, targetColor, targetUV );
}
// private
_sampleFaceIndex() {
const cumulativeTotal = this.distribution[ this.distribution.length - 1 ];
return this._binarySearch( this.randomFunction() * cumulativeTotal );
}
_binarySearch( x ) {
const dist = this.distribution;
let start = 0;
let end = dist.length - 1;
let index = - 1;
while ( start <= end ) {
const mid = Math.ceil( ( start + end ) / 2 );
if ( mid === 0 || dist[ mid - 1 ] <= x && dist[ mid ] > x ) {
index = mid;
break;
} else if ( x < dist[ mid ] ) {
end = mid - 1;
} else {
start = mid + 1;
}
}
return index;
}
_sampleFace( faceIndex, targetPosition, targetNormal, targetColor, targetUV ) {
let u = this.randomFunction();
let v = this.randomFunction();
if ( u + v > 1 ) {
u = 1 - u;
v = 1 - v;
}
// get the vertex attribute indices
const indexAttribute = this.indexAttribute;
let i0 = faceIndex * 3;
let i1 = faceIndex * 3 + 1;
let i2 = faceIndex * 3 + 2;
if ( indexAttribute ) {
i0 = indexAttribute.getX( i0 );
i1 = indexAttribute.getX( i1 );
i2 = indexAttribute.getX( i2 );
}
_face.a.fromBufferAttribute( this.positionAttribute, i0 );
_face.b.fromBufferAttribute( this.positionAttribute, i1 );
_face.c.fromBufferAttribute( this.positionAttribute, i2 );
targetPosition
.set( 0, 0, 0 )
.addScaledVector( _face.a, u )
.addScaledVector( _face.b, v )
.addScaledVector( _face.c, 1 - ( u + v ) );
if ( targetNormal !== undefined ) {
if ( this.normalAttribute !== undefined ) {
_face.a.fromBufferAttribute( this.normalAttribute, i0 );
_face.b.fromBufferAttribute( this.normalAttribute, i1 );
_face.c.fromBufferAttribute( this.normalAttribute, i2 );
targetNormal.set( 0, 0, 0 ).addScaledVector( _face.a, u ).addScaledVector( _face.b, v ).addScaledVector( _face.c, 1 - ( u + v ) ).normalize();
} else {
_face.getNormal( targetNormal );
}
}
if ( targetColor !== undefined && this.colorAttribute !== undefined ) {
_face.a.fromBufferAttribute( this.colorAttribute, i0 );
_face.b.fromBufferAttribute( this.colorAttribute, i1 );
_face.c.fromBufferAttribute( this.colorAttribute, i2 );
_color
.set( 0, 0, 0 )
.addScaledVector( _face.a, u )
.addScaledVector( _face.b, v )
.addScaledVector( _face.c, 1 - ( u + v ) );
targetColor.r = _color.x;
targetColor.g = _color.y;
targetColor.b = _color.z;
}
if ( targetUV !== undefined && this.uvAttribute !== undefined ) {
_uva.fromBufferAttribute( this.uvAttribute, i0 );
_uvb.fromBufferAttribute( this.uvAttribute, i1 );
_uvc.fromBufferAttribute( this.uvAttribute, i2 );
targetUV.set( 0, 0 ).addScaledVector( _uva, u ).addScaledVector( _uvb, v ).addScaledVector( _uvc, 1 - ( u + v ) );
}
return this;
}
}
export { MeshSurfaceSampler };

535
node_modules/three/examples/jsm/math/OBB.js generated vendored Normal file
View File

@@ -0,0 +1,535 @@
import {
Box3,
MathUtils,
Matrix4,
Matrix3,
Ray,
Vector3
} from 'three';
// module scope helper variables
const a = {
c: null, // center
u: [ new Vector3(), new Vector3(), new Vector3() ], // basis vectors
e: [] // half width
};
const b = {
c: null, // center
u: [ new Vector3(), new Vector3(), new Vector3() ], // basis vectors
e: [] // half width
};
const R = [[], [], []];
const AbsR = [[], [], []];
const t = [];
const xAxis = new Vector3();
const yAxis = new Vector3();
const zAxis = new Vector3();
const v1 = new Vector3();
const size = new Vector3();
const closestPoint = new Vector3();
const rotationMatrix = new Matrix3();
const aabb = new Box3();
const matrix = new Matrix4();
const inverse = new Matrix4();
const localRay = new Ray();
/**
* Represents an oriented bounding box (OBB) in 3D space.
*
* @three_import import { OBB } from 'three/addons/math/OBB.js';
*/
class OBB {
/**
* Constructs a new OBB.
*
* @param {Vector3} [center] - The center of the OBB.
* @param {Vector3} [halfSize] - Positive halfwidth extents of the OBB along each axis.
* @param {Matrix3} [rotation] - The rotation of the OBB.
*/
constructor( center = new Vector3(), halfSize = new Vector3(), rotation = new Matrix3() ) {
/**
* The center of the OBB.
*
* @type {Vector3}
*/
this.center = center;
/**
* Positive halfwidth extents of the OBB along each axis.
*
* @type {Vector3}
*/
this.halfSize = halfSize;
/**
* The rotation of the OBB.
*
* @type {Matrix3}
*/
this.rotation = rotation;
}
/**
* Sets the OBBs components to the given values.
*
* @param {Vector3} [center] - The center of the OBB.
* @param {Vector3} [halfSize] - Positive halfwidth extents of the OBB along each axis.
* @param {Matrix3} [rotation] - The rotation of the OBB.
* @return {OBB} A reference to this OBB.
*/
set( center, halfSize, rotation ) {
this.center = center;
this.halfSize = halfSize;
this.rotation = rotation;
return this;
}
/**
* Copies the values of the given OBB to this instance.
*
* @param {OBB} obb - The OBB to copy.
* @return {OBB} A reference to this OBB.
*/
copy( obb ) {
this.center.copy( obb.center );
this.halfSize.copy( obb.halfSize );
this.rotation.copy( obb.rotation );
return this;
}
/**
* Returns a new OBB with copied values from this instance.
*
* @return {OBB} A clone of this instance.
*/
clone() {
return new this.constructor().copy( this );
}
/**
* Returns the size of this OBB.
*
* @param {Vector3} target - The target vector that is used to store the method's result.
* @return {Vector3} The size.
*/
getSize( target ) {
return target.copy( this.halfSize ).multiplyScalar( 2 );
}
/**
* Clamps the given point within the bounds of this OBB.
*
* @param {Vector3} point - The point that should be clamped within the bounds of this OBB.
* @param {Vector3} target - The target vector that is used to store the method's result.
* @returns {Vector3} - The clamped point.
*/
clampPoint( point, target ) {
// Reference: Closest Point on OBB to Point in Real-Time Collision Detection
// by Christer Ericson (chapter 5.1.4)
const halfSize = this.halfSize;
v1.subVectors( point, this.center );
this.rotation.extractBasis( xAxis, yAxis, zAxis );
// start at the center position of the OBB
target.copy( this.center );
// project the target onto the OBB axes and walk towards that point
const x = MathUtils.clamp( v1.dot( xAxis ), - halfSize.x, halfSize.x );
target.add( xAxis.multiplyScalar( x ) );
const y = MathUtils.clamp( v1.dot( yAxis ), - halfSize.y, halfSize.y );
target.add( yAxis.multiplyScalar( y ) );
const z = MathUtils.clamp( v1.dot( zAxis ), - halfSize.z, halfSize.z );
target.add( zAxis.multiplyScalar( z ) );
return target;
}
/**
* Returns `true` if the given point lies within this OBB.
*
* @param {Vector3} point - The point to test.
* @returns {boolean} - Whether the given point lies within this OBB or not.
*/
containsPoint( point ) {
v1.subVectors( point, this.center );
this.rotation.extractBasis( xAxis, yAxis, zAxis );
// project v1 onto each axis and check if these points lie inside the OBB
return Math.abs( v1.dot( xAxis ) ) <= this.halfSize.x &&
Math.abs( v1.dot( yAxis ) ) <= this.halfSize.y &&
Math.abs( v1.dot( zAxis ) ) <= this.halfSize.z;
}
/**
* Returns `true` if the given AABB intersects this OBB.
*
* @param {Box3} box3 - The AABB to test.
* @returns {boolean} - Whether the given AABB intersects this OBB or not.
*/
intersectsBox3( box3 ) {
return this.intersectsOBB( obb.fromBox3( box3 ) );
}
/**
* Returns `true` if the given bounding sphere intersects this OBB.
*
* @param {Sphere} sphere - The bounding sphere to test.
* @returns {boolean} - Whether the given bounding sphere intersects this OBB or not.
*/
intersectsSphere( sphere ) {
// find the point on the OBB closest to the sphere center
this.clampPoint( sphere.center, closestPoint );
// if that point is inside the sphere, the OBB and sphere intersect
return closestPoint.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );
}
/**
* Returns `true` if the given OBB intersects this OBB.
*
* @param {OBB} obb - The OBB to test.
* @param {number} [epsilon=Number.EPSILON] - A small value to prevent arithmetic errors.
* @returns {boolean} - Whether the given OBB intersects this OBB or not.
*/
intersectsOBB( obb, epsilon = Number.EPSILON ) {
// Reference: OBB-OBB Intersection in Real-Time Collision Detection
// by Christer Ericson (chapter 4.4.1)
// prepare data structures (the code uses the same nomenclature like the reference)
a.c = this.center;
a.e[ 0 ] = this.halfSize.x;
a.e[ 1 ] = this.halfSize.y;
a.e[ 2 ] = this.halfSize.z;
this.rotation.extractBasis( a.u[ 0 ], a.u[ 1 ], a.u[ 2 ] );
b.c = obb.center;
b.e[ 0 ] = obb.halfSize.x;
b.e[ 1 ] = obb.halfSize.y;
b.e[ 2 ] = obb.halfSize.z;
obb.rotation.extractBasis( b.u[ 0 ], b.u[ 1 ], b.u[ 2 ] );
// compute rotation matrix expressing b in a's coordinate frame
for ( let i = 0; i < 3; i ++ ) {
for ( let j = 0; j < 3; j ++ ) {
R[ i ][ j ] = a.u[ i ].dot( b.u[ j ] );
}
}
// compute translation vector
v1.subVectors( b.c, a.c );
// bring translation into a's coordinate frame
t[ 0 ] = v1.dot( a.u[ 0 ] );
t[ 1 ] = v1.dot( a.u[ 1 ] );
t[ 2 ] = v1.dot( a.u[ 2 ] );
// compute common subexpressions. Add in an epsilon term to
// counteract arithmetic errors when two edges are parallel and
// their cross product is (near) null
for ( let i = 0; i < 3; i ++ ) {
for ( let j = 0; j < 3; j ++ ) {
AbsR[ i ][ j ] = Math.abs( R[ i ][ j ] ) + epsilon;
}
}
let ra, rb;
// test axes L = A0, L = A1, L = A2
for ( let i = 0; i < 3; i ++ ) {
ra = a.e[ i ];
rb = b.e[ 0 ] * AbsR[ i ][ 0 ] + b.e[ 1 ] * AbsR[ i ][ 1 ] + b.e[ 2 ] * AbsR[ i ][ 2 ];
if ( Math.abs( t[ i ] ) > ra + rb ) return false;
}
// test axes L = B0, L = B1, L = B2
for ( let i = 0; i < 3; i ++ ) {
ra = a.e[ 0 ] * AbsR[ 0 ][ i ] + a.e[ 1 ] * AbsR[ 1 ][ i ] + a.e[ 2 ] * AbsR[ 2 ][ i ];
rb = b.e[ i ];
if ( Math.abs( t[ 0 ] * R[ 0 ][ i ] + t[ 1 ] * R[ 1 ][ i ] + t[ 2 ] * R[ 2 ][ i ] ) > ra + rb ) return false;
}
// test axis L = A0 x B0
ra = a.e[ 1 ] * AbsR[ 2 ][ 0 ] + a.e[ 2 ] * AbsR[ 1 ][ 0 ];
rb = b.e[ 1 ] * AbsR[ 0 ][ 2 ] + b.e[ 2 ] * AbsR[ 0 ][ 1 ];
if ( Math.abs( t[ 2 ] * R[ 1 ][ 0 ] - t[ 1 ] * R[ 2 ][ 0 ] ) > ra + rb ) return false;
// test axis L = A0 x B1
ra = a.e[ 1 ] * AbsR[ 2 ][ 1 ] + a.e[ 2 ] * AbsR[ 1 ][ 1 ];
rb = b.e[ 0 ] * AbsR[ 0 ][ 2 ] + b.e[ 2 ] * AbsR[ 0 ][ 0 ];
if ( Math.abs( t[ 2 ] * R[ 1 ][ 1 ] - t[ 1 ] * R[ 2 ][ 1 ] ) > ra + rb ) return false;
// test axis L = A0 x B2
ra = a.e[ 1 ] * AbsR[ 2 ][ 2 ] + a.e[ 2 ] * AbsR[ 1 ][ 2 ];
rb = b.e[ 0 ] * AbsR[ 0 ][ 1 ] + b.e[ 1 ] * AbsR[ 0 ][ 0 ];
if ( Math.abs( t[ 2 ] * R[ 1 ][ 2 ] - t[ 1 ] * R[ 2 ][ 2 ] ) > ra + rb ) return false;
// test axis L = A1 x B0
ra = a.e[ 0 ] * AbsR[ 2 ][ 0 ] + a.e[ 2 ] * AbsR[ 0 ][ 0 ];
rb = b.e[ 1 ] * AbsR[ 1 ][ 2 ] + b.e[ 2 ] * AbsR[ 1 ][ 1 ];
if ( Math.abs( t[ 0 ] * R[ 2 ][ 0 ] - t[ 2 ] * R[ 0 ][ 0 ] ) > ra + rb ) return false;
// test axis L = A1 x B1
ra = a.e[ 0 ] * AbsR[ 2 ][ 1 ] + a.e[ 2 ] * AbsR[ 0 ][ 1 ];
rb = b.e[ 0 ] * AbsR[ 1 ][ 2 ] + b.e[ 2 ] * AbsR[ 1 ][ 0 ];
if ( Math.abs( t[ 0 ] * R[ 2 ][ 1 ] - t[ 2 ] * R[ 0 ][ 1 ] ) > ra + rb ) return false;
// test axis L = A1 x B2
ra = a.e[ 0 ] * AbsR[ 2 ][ 2 ] + a.e[ 2 ] * AbsR[ 0 ][ 2 ];
rb = b.e[ 0 ] * AbsR[ 1 ][ 1 ] + b.e[ 1 ] * AbsR[ 1 ][ 0 ];
if ( Math.abs( t[ 0 ] * R[ 2 ][ 2 ] - t[ 2 ] * R[ 0 ][ 2 ] ) > ra + rb ) return false;
// test axis L = A2 x B0
ra = a.e[ 0 ] * AbsR[ 1 ][ 0 ] + a.e[ 1 ] * AbsR[ 0 ][ 0 ];
rb = b.e[ 1 ] * AbsR[ 2 ][ 2 ] + b.e[ 2 ] * AbsR[ 2 ][ 1 ];
if ( Math.abs( t[ 1 ] * R[ 0 ][ 0 ] - t[ 0 ] * R[ 1 ][ 0 ] ) > ra + rb ) return false;
// test axis L = A2 x B1
ra = a.e[ 0 ] * AbsR[ 1 ][ 1 ] + a.e[ 1 ] * AbsR[ 0 ][ 1 ];
rb = b.e[ 0 ] * AbsR[ 2 ][ 2 ] + b.e[ 2 ] * AbsR[ 2 ][ 0 ];
if ( Math.abs( t[ 1 ] * R[ 0 ][ 1 ] - t[ 0 ] * R[ 1 ][ 1 ] ) > ra + rb ) return false;
// test axis L = A2 x B2
ra = a.e[ 0 ] * AbsR[ 1 ][ 2 ] + a.e[ 1 ] * AbsR[ 0 ][ 2 ];
rb = b.e[ 0 ] * AbsR[ 2 ][ 1 ] + b.e[ 1 ] * AbsR[ 2 ][ 0 ];
if ( Math.abs( t[ 1 ] * R[ 0 ][ 2 ] - t[ 0 ] * R[ 1 ][ 2 ] ) > ra + rb ) return false;
// since no separating axis is found, the OBBs must be intersecting
return true;
}
/**
* Returns `true` if the given plane intersects this OBB.
*
* @param {Plane} plane - The plane to test.
* @returns {boolean} Whether the given plane intersects this OBB or not.
*/
intersectsPlane( plane ) {
// Reference: Testing Box Against Plane in Real-Time Collision Detection
// by Christer Ericson (chapter 5.2.3)
this.rotation.extractBasis( xAxis, yAxis, zAxis );
// compute the projection interval radius of this OBB onto L(t) = this->center + t * p.normal;
const r = this.halfSize.x * Math.abs( plane.normal.dot( xAxis ) ) +
this.halfSize.y * Math.abs( plane.normal.dot( yAxis ) ) +
this.halfSize.z * Math.abs( plane.normal.dot( zAxis ) );
// compute distance of the OBB's center from the plane
const d = plane.normal.dot( this.center ) - plane.constant;
// Intersection occurs when distance d falls within [-r,+r] interval
return Math.abs( d ) <= r;
}
/**
* Performs a ray/OBB intersection test and stores the intersection point
* in the given 3D vector.
*
* @param {Ray} ray - The ray to test.
* @param {Vector3} target - The target vector that is used to store the method's result.
* @return {?Vector3} The intersection point. If no intersection is detected, `null` is returned.
*/
intersectRay( ray, target ) {
// the idea is to perform the intersection test in the local space
// of the OBB.
this.getSize( size );
aabb.setFromCenterAndSize( v1.set( 0, 0, 0 ), size );
// create a 4x4 transformation matrix
matrix.setFromMatrix3( this.rotation );
matrix.setPosition( this.center );
// transform ray to the local space of the OBB
inverse.copy( matrix ).invert();
localRay.copy( ray ).applyMatrix4( inverse );
// perform ray <-> AABB intersection test
if ( localRay.intersectBox( aabb, target ) ) {
// transform the intersection point back to world space
return target.applyMatrix4( matrix );
} else {
return null;
}
}
/**
* Returns `true` if the given ray intersects this OBB.
*
* @param {Ray} ray - The ray to test.
* @returns {boolean} Whether the given ray intersects this OBB or not.
*/
intersectsRay( ray ) {
return this.intersectRay( ray, v1 ) !== null;
}
/**
* Defines an OBB based on the given AABB.
*
* @param {Box3} box3 - The AABB to setup the OBB from.
* @return {OBB} A reference of this OBB.
*/
fromBox3( box3 ) {
box3.getCenter( this.center );
box3.getSize( this.halfSize ).multiplyScalar( 0.5 );
this.rotation.identity();
return this;
}
/**
* Returns `true` if the given OBB is equal to this OBB.
*
* @param {OBB} obb - The OBB to test.
* @returns {boolean} Whether the given OBB is equal to this OBB or not.
*/
equals( obb ) {
return obb.center.equals( this.center ) &&
obb.halfSize.equals( this.halfSize ) &&
obb.rotation.equals( this.rotation );
}
/**
* Applies the given transformation matrix to this OBB. This method can be
* used to transform the bounding volume with the world matrix of a 3D object
* in order to keep both entities in sync.
*
* @param {Matrix4} matrix - The matrix to apply.
* @return {OBB} A reference of this OBB.
*/
applyMatrix4( matrix ) {
const e = matrix.elements;
let sx = v1.set( e[ 0 ], e[ 1 ], e[ 2 ] ).length();
const sy = v1.set( e[ 4 ], e[ 5 ], e[ 6 ] ).length();
const sz = v1.set( e[ 8 ], e[ 9 ], e[ 10 ] ).length();
const det = matrix.determinant();
if ( det < 0 ) sx = - sx;
rotationMatrix.setFromMatrix4( matrix );
const invSX = 1 / sx;
const invSY = 1 / sy;
const invSZ = 1 / sz;
rotationMatrix.elements[ 0 ] *= invSX;
rotationMatrix.elements[ 1 ] *= invSX;
rotationMatrix.elements[ 2 ] *= invSX;
rotationMatrix.elements[ 3 ] *= invSY;
rotationMatrix.elements[ 4 ] *= invSY;
rotationMatrix.elements[ 5 ] *= invSY;
rotationMatrix.elements[ 6 ] *= invSZ;
rotationMatrix.elements[ 7 ] *= invSZ;
rotationMatrix.elements[ 8 ] *= invSZ;
this.rotation.multiply( rotationMatrix );
this.halfSize.x *= sx;
this.halfSize.y *= sy;
this.halfSize.z *= sz;
v1.setFromMatrixPosition( matrix );
this.center.add( v1 );
return this;
}
}
const obb = new OBB();
export { OBB };

692
node_modules/three/examples/jsm/math/Octree.js generated vendored Normal file
View File

@@ -0,0 +1,692 @@
import {
Box3,
Line3,
Plane,
Sphere,
Triangle,
Vector3,
Layers
} from 'three';
import { Capsule } from '../math/Capsule.js';
const _v1 = new Vector3();
const _v2 = new Vector3();
const _point1 = new Vector3();
const _point2 = new Vector3();
const _plane = new Plane();
const _line1 = new Line3();
const _line2 = new Line3();
const _sphere = new Sphere();
const _capsule = new Capsule();
const _temp1 = new Vector3();
const _temp2 = new Vector3();
const _temp3 = new Vector3();
const EPS = 1e-10;
function lineToLineClosestPoints( line1, line2, target1 = null, target2 = null ) {
const r = _temp1.copy( line1.end ).sub( line1.start );
const s = _temp2.copy( line2.end ).sub( line2.start );
const w = _temp3.copy( line2.start ).sub( line1.start );
const a = r.dot( s ),
b = r.dot( r ),
c = s.dot( s ),
d = s.dot( w ),
e = r.dot( w );
let t1, t2;
const divisor = b * c - a * a;
if ( Math.abs( divisor ) < EPS ) {
const d1 = - d / c;
const d2 = ( a - d ) / c;
if ( Math.abs( d1 - 0.5 ) < Math.abs( d2 - 0.5 ) ) {
t1 = 0;
t2 = d1;
} else {
t1 = 1;
t2 = d2;
}
} else {
t1 = ( d * a + e * c ) / divisor;
t2 = ( t1 * a - d ) / c;
}
t2 = Math.max( 0, Math.min( 1, t2 ) );
t1 = Math.max( 0, Math.min( 1, t1 ) );
if ( target1 ) {
target1.copy( r ).multiplyScalar( t1 ).add( line1.start );
}
if ( target2 ) {
target2.copy( s ).multiplyScalar( t2 ).add( line2.start );
}
}
/**
* An octree is a hierarchical tree data structure used to partition a three-dimensional
* space by recursively subdividing it into eight octants.
*
* This particular implementation can have up to sixteen levels and stores up to eight triangles
* in leaf nodes.
*
* `Octree` can be used in games to compute collision between the game world and colliders from
* the player or other dynamic 3D objects.
*
*
* ```js
* const octree = new Octree().fromGraphNode( scene );
* const result = octree.capsuleIntersect( playerCollider ); // collision detection
* ```
*
* @three_import import { Octree } from 'three/addons/math/Octree.js';
*/
class Octree {
/**
* Constructs a new Octree.
*
* @param {Box3} [box] - The base box with enclose the entire Octree.
*/
constructor( box ) {
/**
* The base box with enclose the entire Octree.
*
* @type {Box3}
*/
this.box = box;
/**
* The bounds of the Octree. Compared to {@link Octree#box}, no
* margin is applied.
*
* @type {Box3}
*/
this.bounds = new Box3();
/**
* Can by used for layers configuration for refine testing.
*
* @type {Layers}
*/
this.layers = new Layers();
/**
* The number of triangles a leaf can store before it is split.
*
* @type {number}
* @default 8
*/
this.trianglesPerLeaf = 8;
/**
* The maximum level of the Octree. It defines the maximum
* hierarchical depth of the data structure.
*
* @type {number}
* @default 16
*/
this.maxLevel = 16;
// private
this.subTrees = [];
this.triangles = [];
}
/**
* Adds the given triangle to the Octree. The triangle vertices are clamped if they exceed
* the bounds of the Octree.
*
* @param {Triangle} triangle - The triangle to add.
* @return {Octree} A reference to this Octree.
*/
addTriangle( triangle ) {
this.bounds.min.x = Math.min( this.bounds.min.x, triangle.a.x, triangle.b.x, triangle.c.x );
this.bounds.min.y = Math.min( this.bounds.min.y, triangle.a.y, triangle.b.y, triangle.c.y );
this.bounds.min.z = Math.min( this.bounds.min.z, triangle.a.z, triangle.b.z, triangle.c.z );
this.bounds.max.x = Math.max( this.bounds.max.x, triangle.a.x, triangle.b.x, triangle.c.x );
this.bounds.max.y = Math.max( this.bounds.max.y, triangle.a.y, triangle.b.y, triangle.c.y );
this.bounds.max.z = Math.max( this.bounds.max.z, triangle.a.z, triangle.b.z, triangle.c.z );
this.triangles.push( triangle );
return this;
}
/**
* Prepares {@link Octree#box} for the build.
*
* @return {Octree} A reference to this Octree.
*/
calcBox() {
this.box = this.bounds.clone();
// offset small amount to account for regular grid
this.box.min.x -= 0.01;
this.box.min.y -= 0.01;
this.box.min.z -= 0.01;
return this;
}
/**
* Splits the Octree. This method is used recursively when
* building the Octree.
*
* @param {number} level - The current level.
* @return {Octree} A reference to this Octree.
*/
split( level ) {
if ( ! this.box ) return;
const subTrees = [];
const halfsize = _v2.copy( this.box.max ).sub( this.box.min ).multiplyScalar( 0.5 );
for ( let x = 0; x < 2; x ++ ) {
for ( let y = 0; y < 2; y ++ ) {
for ( let z = 0; z < 2; z ++ ) {
const box = new Box3();
const v = _v1.set( x, y, z );
box.min.copy( this.box.min ).add( v.multiply( halfsize ) );
box.max.copy( box.min ).add( halfsize );
subTrees.push( new Octree( box ) );
}
}
}
let triangle;
while ( triangle = this.triangles.pop() ) {
for ( let i = 0; i < subTrees.length; i ++ ) {
if ( subTrees[ i ].box.intersectsTriangle( triangle ) ) {
subTrees[ i ].triangles.push( triangle );
}
}
}
for ( let i = 0; i < subTrees.length; i ++ ) {
const len = subTrees[ i ].triangles.length;
if ( len > this.trianglesPerLeaf && level < this.maxLevel ) {
subTrees[ i ].split( level + 1 );
}
if ( len !== 0 ) {
this.subTrees.push( subTrees[ i ] );
}
}
return this;
}
/**
* Builds the Octree.
*
* @return {Octree} A reference to this Octree.
*/
build() {
this.calcBox();
this.split( 0 );
return this;
}
/**
* Computes the triangles that potentially intersect with the given ray.
*
* @param {Ray} ray - The ray to test.
* @param {Array<Triangle>} triangles - The target array that holds the triangles.
*/
getRayTriangles( ray, triangles ) {
for ( let i = 0; i < this.subTrees.length; i ++ ) {
const subTree = this.subTrees[ i ];
if ( ! ray.intersectsBox( subTree.box ) ) continue;
if ( subTree.triangles.length > 0 ) {
for ( let j = 0; j < subTree.triangles.length; j ++ ) {
if ( triangles.indexOf( subTree.triangles[ j ] ) === - 1 ) triangles.push( subTree.triangles[ j ] );
}
} else {
subTree.getRayTriangles( ray, triangles );
}
}
}
/**
* Computes the intersection between the given capsule and triangle.
*
* @param {Capsule} capsule - The capsule to test.
* @param {Triangle} triangle - The triangle to test.
* @return {Object|false} The intersection object. If no intersection
* is detected, the method returns `false`.
*/
triangleCapsuleIntersect( capsule, triangle ) {
triangle.getPlane( _plane );
const d1 = _plane.distanceToPoint( capsule.start ) - capsule.radius;
const d2 = _plane.distanceToPoint( capsule.end ) - capsule.radius;
if ( ( d1 > 0 && d2 > 0 ) || ( d1 < - capsule.radius && d2 < - capsule.radius ) ) {
return false;
}
const delta = Math.abs( d1 / ( Math.abs( d1 ) + Math.abs( d2 ) ) );
const intersectPoint = _v1.copy( capsule.start ).lerp( capsule.end, delta );
if ( triangle.containsPoint( intersectPoint ) ) {
return { normal: _plane.normal.clone(), point: intersectPoint.clone(), depth: Math.abs( Math.min( d1, d2 ) ) };
}
const r2 = capsule.radius * capsule.radius;
const line1 = _line1.set( capsule.start, capsule.end );
const lines = [
[ triangle.a, triangle.b ],
[ triangle.b, triangle.c ],
[ triangle.c, triangle.a ]
];
for ( let i = 0; i < lines.length; i ++ ) {
const line2 = _line2.set( lines[ i ][ 0 ], lines[ i ][ 1 ] );
lineToLineClosestPoints( line1, line2, _point1, _point2 );
if ( _point1.distanceToSquared( _point2 ) < r2 ) {
return {
normal: _point1.clone().sub( _point2 ).normalize(),
point: _point2.clone(),
depth: capsule.radius - _point1.distanceTo( _point2 )
};
}
}
return false;
}
/**
* Computes the intersection between the given sphere and triangle.
*
* @param {Sphere} sphere - The sphere to test.
* @param {Triangle} triangle - The triangle to test.
* @return {Object|false} The intersection object. If no intersection
* is detected, the method returns `false`.
*/
triangleSphereIntersect( sphere, triangle ) {
triangle.getPlane( _plane );
if ( ! sphere.intersectsPlane( _plane ) ) return false;
const depth = Math.abs( _plane.distanceToSphere( sphere ) );
const r2 = sphere.radius * sphere.radius - depth * depth;
const plainPoint = _plane.projectPoint( sphere.center, _v1 );
if ( triangle.containsPoint( sphere.center ) ) {
return { normal: _plane.normal.clone(), point: plainPoint.clone(), depth: Math.abs( _plane.distanceToSphere( sphere ) ) };
}
const lines = [
[ triangle.a, triangle.b ],
[ triangle.b, triangle.c ],
[ triangle.c, triangle.a ]
];
for ( let i = 0; i < lines.length; i ++ ) {
_line1.set( lines[ i ][ 0 ], lines[ i ][ 1 ] );
_line1.closestPointToPoint( plainPoint, true, _v2 );
const d = _v2.distanceToSquared( sphere.center );
if ( d < r2 ) {
return { normal: sphere.center.clone().sub( _v2 ).normalize(), point: _v2.clone(), depth: sphere.radius - Math.sqrt( d ) };
}
}
return false;
}
/**
* Computes the triangles that potentially intersect with the given bounding sphere.
*
* @param {Sphere} sphere - The sphere to test.
* @param {Array<Triangle>} triangles - The target array that holds the triangles.
*/
getSphereTriangles( sphere, triangles ) {
for ( let i = 0; i < this.subTrees.length; i ++ ) {
const subTree = this.subTrees[ i ];
if ( ! sphere.intersectsBox( subTree.box ) ) continue;
if ( subTree.triangles.length > 0 ) {
for ( let j = 0; j < subTree.triangles.length; j ++ ) {
if ( triangles.indexOf( subTree.triangles[ j ] ) === - 1 ) triangles.push( subTree.triangles[ j ] );
}
} else {
subTree.getSphereTriangles( sphere, triangles );
}
}
}
/**
* Computes the triangles that potentially intersect with the given capsule.
*
* @param {Capsule} capsule - The capsule to test.
* @param {Array<Triangle>} triangles - The target array that holds the triangles.
*/
getCapsuleTriangles( capsule, triangles ) {
for ( let i = 0; i < this.subTrees.length; i ++ ) {
const subTree = this.subTrees[ i ];
if ( ! capsule.intersectsBox( subTree.box ) ) continue;
if ( subTree.triangles.length > 0 ) {
for ( let j = 0; j < subTree.triangles.length; j ++ ) {
if ( triangles.indexOf( subTree.triangles[ j ] ) === - 1 ) triangles.push( subTree.triangles[ j ] );
}
} else {
subTree.getCapsuleTriangles( capsule, triangles );
}
}
}
/**
* Performs a bounding sphere intersection test with this Octree.
*
* @param {Sphere} sphere - The bounding sphere to test.
* @return {Object|boolean} The intersection object. If no intersection
* is detected, the method returns `false`.
*/
sphereIntersect( sphere ) {
_sphere.copy( sphere );
const triangles = [];
let result, hit = false;
this.getSphereTriangles( sphere, triangles );
for ( let i = 0; i < triangles.length; i ++ ) {
if ( result = this.triangleSphereIntersect( _sphere, triangles[ i ] ) ) {
hit = true;
_sphere.center.add( result.normal.multiplyScalar( result.depth ) );
}
}
if ( hit ) {
const collisionVector = _sphere.center.clone().sub( sphere.center );
const depth = collisionVector.length();
return { normal: collisionVector.normalize(), depth: depth };
}
return false;
}
/**
* Performs a capsule intersection test with this Octree.
*
* @param {Capsule} capsule - The capsule to test.
* @return {Object|boolean} The intersection object. If no intersection
* is detected, the method returns `false`.
*/
capsuleIntersect( capsule ) {
_capsule.copy( capsule );
const triangles = [];
let result, hit = false;
this.getCapsuleTriangles( _capsule, triangles );
for ( let i = 0; i < triangles.length; i ++ ) {
if ( result = this.triangleCapsuleIntersect( _capsule, triangles[ i ] ) ) {
hit = true;
_capsule.translate( result.normal.multiplyScalar( result.depth ) );
}
}
if ( hit ) {
const collisionVector = _capsule.getCenter( new Vector3() ).sub( capsule.getCenter( _v1 ) );
const depth = collisionVector.length();
return { normal: collisionVector.normalize(), depth: depth };
}
return false;
}
/**
* Performs a ray intersection test with this Octree.
*
* @param {Ray} ray - The ray to test.
* @return {Object|boolean} The nearest intersection object. If no intersection
* is detected, the method returns `false`.
*/
rayIntersect( ray ) {
const triangles = [];
let triangle, position, distance = 1e100;
this.getRayTriangles( ray, triangles );
for ( let i = 0; i < triangles.length; i ++ ) {
const result = ray.intersectTriangle( triangles[ i ].a, triangles[ i ].b, triangles[ i ].c, true, _v1 );
if ( result ) {
const newdistance = result.sub( ray.origin ).length();
if ( distance > newdistance ) {
position = result.clone().add( ray.origin );
distance = newdistance;
triangle = triangles[ i ];
}
}
}
return distance < 1e100 ? { distance: distance, triangle: triangle, position: position } : false;
}
/**
* Constructs the Octree from the given 3D object.
*
* @param {Object3D} group - The scene graph node.
* @return {Octree} A reference to this Octree.
*/
fromGraphNode( group ) {
group.updateWorldMatrix( true, true );
group.traverse( ( obj ) => {
if ( obj.isMesh === true ) {
if ( this.layers.test( obj.layers ) ) {
let geometry, isTemp = false;
if ( obj.geometry.index !== null ) {
isTemp = true;
geometry = obj.geometry.toNonIndexed();
} else {
geometry = obj.geometry;
}
const positionAttribute = geometry.getAttribute( 'position' );
for ( let i = 0; i < positionAttribute.count; i += 3 ) {
const v1 = new Vector3().fromBufferAttribute( positionAttribute, i );
const v2 = new Vector3().fromBufferAttribute( positionAttribute, i + 1 );
const v3 = new Vector3().fromBufferAttribute( positionAttribute, i + 2 );
v1.applyMatrix4( obj.matrixWorld );
v2.applyMatrix4( obj.matrixWorld );
v3.applyMatrix4( obj.matrixWorld );
this.addTriangle( new Triangle( v1, v2, v3 ) );
}
if ( isTemp ) {
geometry.dispose();
}
}
}
} );
this.build();
return this;
}
/**
* Clears the Octree by making it empty.
*
* @return {Octree} A reference to this Octree.
*/
clear() {
this.box = null;
this.bounds.makeEmpty();
this.subTrees.length = 0;
this.triangles.length = 0;
return this;
}
}
export { Octree };

470
node_modules/three/examples/jsm/math/SimplexNoise.js generated vendored Normal file
View File

@@ -0,0 +1,470 @@
/**
* A utility class providing noise functions.
*
* The code is based on [Simplex noise demystified]{@link https://web.archive.org/web/20210210162332/http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf}
* by Stefan Gustavson, 2005.
*
* @three_import import { SimplexNoise } from 'three/addons/math/SimplexNoise.js';
*/
class SimplexNoise {
/**
* Constructs a new simplex noise object.
*
* @param {Object} [r=Math] - A math utility class that holds a `random()` method. This makes it
* possible to pass in custom random number generator.
*/
constructor( r = Math ) {
this.grad3 = [[ 1, 1, 0 ], [ - 1, 1, 0 ], [ 1, - 1, 0 ], [ - 1, - 1, 0 ],
[ 1, 0, 1 ], [ - 1, 0, 1 ], [ 1, 0, - 1 ], [ - 1, 0, - 1 ],
[ 0, 1, 1 ], [ 0, - 1, 1 ], [ 0, 1, - 1 ], [ 0, - 1, - 1 ]];
this.grad4 = [[ 0, 1, 1, 1 ], [ 0, 1, 1, - 1 ], [ 0, 1, - 1, 1 ], [ 0, 1, - 1, - 1 ],
[ 0, - 1, 1, 1 ], [ 0, - 1, 1, - 1 ], [ 0, - 1, - 1, 1 ], [ 0, - 1, - 1, - 1 ],
[ 1, 0, 1, 1 ], [ 1, 0, 1, - 1 ], [ 1, 0, - 1, 1 ], [ 1, 0, - 1, - 1 ],
[ - 1, 0, 1, 1 ], [ - 1, 0, 1, - 1 ], [ - 1, 0, - 1, 1 ], [ - 1, 0, - 1, - 1 ],
[ 1, 1, 0, 1 ], [ 1, 1, 0, - 1 ], [ 1, - 1, 0, 1 ], [ 1, - 1, 0, - 1 ],
[ - 1, 1, 0, 1 ], [ - 1, 1, 0, - 1 ], [ - 1, - 1, 0, 1 ], [ - 1, - 1, 0, - 1 ],
[ 1, 1, 1, 0 ], [ 1, 1, - 1, 0 ], [ 1, - 1, 1, 0 ], [ 1, - 1, - 1, 0 ],
[ - 1, 1, 1, 0 ], [ - 1, 1, - 1, 0 ], [ - 1, - 1, 1, 0 ], [ - 1, - 1, - 1, 0 ]];
this.p = [];
for ( let i = 0; i < 256; i ++ ) {
this.p[ i ] = Math.floor( r.random() * 256 );
}
// To remove the need for index wrapping, double the permutation table length
this.perm = [];
for ( let i = 0; i < 512; i ++ ) {
this.perm[ i ] = this.p[ i & 255 ];
}
// A lookup table to traverse the simplex around a given point in 4D.
// Details can be found where this table is used, in the 4D noise method.
this.simplex = [
[ 0, 1, 2, 3 ], [ 0, 1, 3, 2 ], [ 0, 0, 0, 0 ], [ 0, 2, 3, 1 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 1, 2, 3, 0 ],
[ 0, 2, 1, 3 ], [ 0, 0, 0, 0 ], [ 0, 3, 1, 2 ], [ 0, 3, 2, 1 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 1, 3, 2, 0 ],
[ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ],
[ 1, 2, 0, 3 ], [ 0, 0, 0, 0 ], [ 1, 3, 0, 2 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 2, 3, 0, 1 ], [ 2, 3, 1, 0 ],
[ 1, 0, 2, 3 ], [ 1, 0, 3, 2 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 2, 0, 3, 1 ], [ 0, 0, 0, 0 ], [ 2, 1, 3, 0 ],
[ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ],
[ 2, 0, 1, 3 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 3, 0, 1, 2 ], [ 3, 0, 2, 1 ], [ 0, 0, 0, 0 ], [ 3, 1, 2, 0 ],
[ 2, 1, 0, 3 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 3, 1, 0, 2 ], [ 0, 0, 0, 0 ], [ 3, 2, 0, 1 ], [ 3, 2, 1, 0 ]];
}
/**
* A 2D simplex noise method.
*
* @param {number} xin - The x coordinate.
* @param {number} yin - The y coordinate.
* @return {number} The noise value.
*/
noise( xin, yin ) {
let n0; // Noise contributions from the three corners
let n1;
let n2;
// Skew the input space to determine which simplex cell we're in
const F2 = 0.5 * ( Math.sqrt( 3.0 ) - 1.0 );
const s = ( xin + yin ) * F2; // Hairy factor for 2D
const i = Math.floor( xin + s );
const j = Math.floor( yin + s );
const G2 = ( 3.0 - Math.sqrt( 3.0 ) ) / 6.0;
const t = ( i + j ) * G2;
const X0 = i - t; // Unskew the cell origin back to (x,y) space
const Y0 = j - t;
const x0 = xin - X0; // The x,y distances from the cell origin
const y0 = yin - Y0;
// For the 2D case, the simplex shape is an equilateral triangle.
// Determine which simplex we are in.
let i1; // Offsets for second (middle) corner of simplex in (i,j) coords
let j1;
if ( x0 > y0 ) {
i1 = 1; j1 = 0;
// lower triangle, XY order: (0,0)->(1,0)->(1,1)
} else {
i1 = 0; j1 = 1;
} // upper triangle, YX order: (0,0)->(0,1)->(1,1)
// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
// c = (3-sqrt(3))/6
const x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
const y1 = y0 - j1 + G2;
const x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
const y2 = y0 - 1.0 + 2.0 * G2;
// Work out the hashed gradient indices of the three simplex corners
const ii = i & 255;
const jj = j & 255;
const gi0 = this.perm[ ii + this.perm[ jj ] ] % 12;
const gi1 = this.perm[ ii + i1 + this.perm[ jj + j1 ] ] % 12;
const gi2 = this.perm[ ii + 1 + this.perm[ jj + 1 ] ] % 12;
// Calculate the contribution from the three corners
let t0 = 0.5 - x0 * x0 - y0 * y0;
if ( t0 < 0 ) n0 = 0.0;
else {
t0 *= t0;
n0 = t0 * t0 * this._dot( this.grad3[ gi0 ], x0, y0 ); // (x,y) of grad3 used for 2D gradient
}
let t1 = 0.5 - x1 * x1 - y1 * y1;
if ( t1 < 0 ) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * this._dot( this.grad3[ gi1 ], x1, y1 );
}
let t2 = 0.5 - x2 * x2 - y2 * y2;
if ( t2 < 0 ) n2 = 0.0;
else {
t2 *= t2;
n2 = t2 * t2 * this._dot( this.grad3[ gi2 ], x2, y2 );
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to return values in the interval [-1,1].
return 70.0 * ( n0 + n1 + n2 );
}
/**
* A 3D simplex noise method.
*
* @param {number} xin - The x coordinate.
* @param {number} yin - The y coordinate.
* @param {number} zin - The z coordinate.
* @return {number} The noise value.
*/
noise3d( xin, yin, zin ) {
let n0; // Noise contributions from the four corners
let n1;
let n2;
let n3;
// Skew the input space to determine which simplex cell we're in
const F3 = 1.0 / 3.0;
const s = ( xin + yin + zin ) * F3; // Very nice and simple skew factor for 3D
const i = Math.floor( xin + s );
const j = Math.floor( yin + s );
const k = Math.floor( zin + s );
const G3 = 1.0 / 6.0; // Very nice and simple unskew factor, too
const t = ( i + j + k ) * G3;
const X0 = i - t; // Unskew the cell origin back to (x,y,z) space
const Y0 = j - t;
const Z0 = k - t;
const x0 = xin - X0; // The x,y,z distances from the cell origin
const y0 = yin - Y0;
const z0 = zin - Z0;
// For the 3D case, the simplex shape is a slightly irregular tetrahedron.
// Determine which simplex we are in.
let i1; // Offsets for second corner of simplex in (i,j,k) coords
let j1;
let k1;
let i2; // Offsets for third corner of simplex in (i,j,k) coords
let j2;
let k2;
if ( x0 >= y0 ) {
if ( y0 >= z0 ) {
i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0;
// X Y Z order
} else if ( x0 >= z0 ) {
i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1;
// X Z Y order
} else {
i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1;
} // Z X Y order
} else { // x0<y0
if ( y0 < z0 ) {
i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1;
// Z Y X order
} else if ( x0 < z0 ) {
i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1;
// Y Z X order
} else {
i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0;
} // Y X Z order
}
// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
// c = 1/6.
const x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
const y1 = y0 - j1 + G3;
const z1 = z0 - k1 + G3;
const x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
const y2 = y0 - j2 + 2.0 * G3;
const z2 = z0 - k2 + 2.0 * G3;
const x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
const y3 = y0 - 1.0 + 3.0 * G3;
const z3 = z0 - 1.0 + 3.0 * G3;
// Work out the hashed gradient indices of the four simplex corners
const ii = i & 255;
const jj = j & 255;
const kk = k & 255;
const gi0 = this.perm[ ii + this.perm[ jj + this.perm[ kk ] ] ] % 12;
const gi1 = this.perm[ ii + i1 + this.perm[ jj + j1 + this.perm[ kk + k1 ] ] ] % 12;
const gi2 = this.perm[ ii + i2 + this.perm[ jj + j2 + this.perm[ kk + k2 ] ] ] % 12;
const gi3 = this.perm[ ii + 1 + this.perm[ jj + 1 + this.perm[ kk + 1 ] ] ] % 12;
// Calculate the contribution from the four corners
let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
if ( t0 < 0 ) n0 = 0.0;
else {
t0 *= t0;
n0 = t0 * t0 * this._dot3( this.grad3[ gi0 ], x0, y0, z0 );
}
let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
if ( t1 < 0 ) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * this._dot3( this.grad3[ gi1 ], x1, y1, z1 );
}
let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
if ( t2 < 0 ) n2 = 0.0;
else {
t2 *= t2;
n2 = t2 * t2 * this._dot3( this.grad3[ gi2 ], x2, y2, z2 );
}
let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
if ( t3 < 0 ) n3 = 0.0;
else {
t3 *= t3;
n3 = t3 * t3 * this._dot3( this.grad3[ gi3 ], x3, y3, z3 );
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to stay just inside [-1,1]
return 32.0 * ( n0 + n1 + n2 + n3 );
}
/**
* A 4D simplex noise method.
*
* @param {number} x - The x coordinate.
* @param {number} y - The y coordinate.
* @param {number} z - The z coordinate.
* @param {number} w - The w coordinate.
* @return {number} The noise value.
*/
noise4d( x, y, z, w ) {
// For faster and easier lookups
const grad4 = this.grad4;
const simplex = this.simplex;
const perm = this.perm;
// The skewing and unskewing factors are hairy again for the 4D case
const F4 = ( Math.sqrt( 5.0 ) - 1.0 ) / 4.0;
const G4 = ( 5.0 - Math.sqrt( 5.0 ) ) / 20.0;
let n0; // Noise contributions from the five corners
let n1;
let n2;
let n3;
let n4;
// Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
const s = ( x + y + z + w ) * F4; // Factor for 4D skewing
const i = Math.floor( x + s );
const j = Math.floor( y + s );
const k = Math.floor( z + s );
const l = Math.floor( w + s );
const t = ( i + j + k + l ) * G4; // Factor for 4D unskewing
const X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
const Y0 = j - t;
const Z0 = k - t;
const W0 = l - t;
const x0 = x - X0; // The x,y,z,w distances from the cell origin
const y0 = y - Y0;
const z0 = z - Z0;
const w0 = w - W0;
// For the 4D case, the simplex is a 4D shape I won't even try to describe.
// To find out which of the 24 possible simplices we're in, we need to
// determine the magnitude ordering of x0, y0, z0 and w0.
// The method below is a good way of finding the ordering of x,y,z,w and
// then find the correct traversal order for the simplex we’re in.
// First, six pair-wise comparisons are performed between each possible pair
// of the four coordinates, and the results are used to add up binary bits
// for an integer index.
const c1 = ( x0 > y0 ) ? 32 : 0;
const c2 = ( x0 > z0 ) ? 16 : 0;
const c3 = ( y0 > z0 ) ? 8 : 0;
const c4 = ( x0 > w0 ) ? 4 : 0;
const c5 = ( y0 > w0 ) ? 2 : 0;
const c6 = ( z0 > w0 ) ? 1 : 0;
const c = c1 + c2 + c3 + c4 + c5 + c6;
// simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
// Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
// impossible. Only the 24 indices which have non-zero entries make any sense.
// We use a thresholding to set the coordinates in turn from the largest magnitude.
// The number 3 in the "simplex" array is at the position of the largest coordinate.
const i1 = simplex[ c ][ 0 ] >= 3 ? 1 : 0;
const j1 = simplex[ c ][ 1 ] >= 3 ? 1 : 0;
const k1 = simplex[ c ][ 2 ] >= 3 ? 1 : 0;
const l1 = simplex[ c ][ 3 ] >= 3 ? 1 : 0;
// The number 2 in the "simplex" array is at the second largest coordinate.
const i2 = simplex[ c ][ 0 ] >= 2 ? 1 : 0;
const j2 = simplex[ c ][ 1 ] >= 2 ? 1 : 0;
const k2 = simplex[ c ][ 2 ] >= 2 ? 1 : 0;
const l2 = simplex[ c ][ 3 ] >= 2 ? 1 : 0;
// The number 1 in the "simplex" array is at the second smallest coordinate.
const i3 = simplex[ c ][ 0 ] >= 1 ? 1 : 0;
const j3 = simplex[ c ][ 1 ] >= 1 ? 1 : 0;
const k3 = simplex[ c ][ 2 ] >= 1 ? 1 : 0;
const l3 = simplex[ c ][ 3 ] >= 1 ? 1 : 0;
// The fifth corner has all coordinate offsets = 1, so no need to look that up.
const x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
const y1 = y0 - j1 + G4;
const z1 = z0 - k1 + G4;
const w1 = w0 - l1 + G4;
const x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
const y2 = y0 - j2 + 2.0 * G4;
const z2 = z0 - k2 + 2.0 * G4;
const w2 = w0 - l2 + 2.0 * G4;
const x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
const y3 = y0 - j3 + 3.0 * G4;
const z3 = z0 - k3 + 3.0 * G4;
const w3 = w0 - l3 + 3.0 * G4;
const x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
const y4 = y0 - 1.0 + 4.0 * G4;
const z4 = z0 - 1.0 + 4.0 * G4;
const w4 = w0 - 1.0 + 4.0 * G4;
// Work out the hashed gradient indices of the five simplex corners
const ii = i & 255;
const jj = j & 255;
const kk = k & 255;
const ll = l & 255;
const gi0 = perm[ ii + perm[ jj + perm[ kk + perm[ ll ] ] ] ] % 32;
const gi1 = perm[ ii + i1 + perm[ jj + j1 + perm[ kk + k1 + perm[ ll + l1 ] ] ] ] % 32;
const gi2 = perm[ ii + i2 + perm[ jj + j2 + perm[ kk + k2 + perm[ ll + l2 ] ] ] ] % 32;
const gi3 = perm[ ii + i3 + perm[ jj + j3 + perm[ kk + k3 + perm[ ll + l3 ] ] ] ] % 32;
const gi4 = perm[ ii + 1 + perm[ jj + 1 + perm[ kk + 1 + perm[ ll + 1 ] ] ] ] % 32;
// Calculate the contribution from the five corners
let t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
if ( t0 < 0 ) n0 = 0.0;
else {
t0 *= t0;
n0 = t0 * t0 * this._dot4( grad4[ gi0 ], x0, y0, z0, w0 );
}
let t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
if ( t1 < 0 ) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * this._dot4( grad4[ gi1 ], x1, y1, z1, w1 );
}
let t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
if ( t2 < 0 ) n2 = 0.0;
else {
t2 *= t2;
n2 = t2 * t2 * this._dot4( grad4[ gi2 ], x2, y2, z2, w2 );
}
let t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
if ( t3 < 0 ) n3 = 0.0;
else {
t3 *= t3;
n3 = t3 * t3 * this._dot4( grad4[ gi3 ], x3, y3, z3, w3 );
}
let t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
if ( t4 < 0 ) n4 = 0.0;
else {
t4 *= t4;
n4 = t4 * t4 * this._dot4( grad4[ gi4 ], x4, y4, z4, w4 );
}
// Sum up and scale the result to cover the range [-1,1]
return 27.0 * ( n0 + n1 + n2 + n3 + n4 );
}
// private
_dot( g, x, y ) {
return g[ 0 ] * x + g[ 1 ] * y;
}
_dot3( g, x, y, z ) {
return g[ 0 ] * x + g[ 1 ] * y + g[ 2 ] * z;
}
_dot4( g, x, y, z, w ) {
return g[ 0 ] * x + g[ 1 ] * y + g[ 2 ] * z + g[ 3 ] * w;
}
}
export { SimplexNoise };