@yangyongtao/gaea 1.0.3 → 1.1.0

package/public/math/Cylindrical.js

@@ -0,0 +1,61 @@
+/**
+ * Ref: https://en.wikipedia.org/wiki/Cylindrical_coordinate_system
+ */
+
+class Cylindrical {
+
+	constructor( radius = 1, theta = 0, y = 0 ) {
+
+		this.radius = radius; // distance from the origin to a point in the x-z plane
+		this.theta = theta; // counterclockwise angle in the x-z plane measured in radians from the positive z-axis
+		this.y = y; // height above the x-z plane
+
+		return this;
+
+	}
+
+	set( radius, theta, y ) {
+
+		this.radius = radius;
+		this.theta = theta;
+		this.y = y;
+
+		return this;
+
+	}
+
+	copy( other ) {
+
+		this.radius = other.radius;
+		this.theta = other.theta;
+		this.y = other.y;
+
+		return this;
+
+	}
+
+	setFromVector3( v ) {
+
+		return this.setFromCartesianCoords( v.x, v.y, v.z );
+
+	}
+
+	setFromCartesianCoords( x, y, z ) {
+
+		this.radius = Math.sqrt( x * x + z * z );
+		this.theta = Math.atan2( x, z );
+		this.y = y;
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+export { Cylindrical };

package/public/math/EngineUtils.js

@@ -0,0 +1,81 @@
+import { Matrix3 } from "./Matrix3.js";
+import { Matrix4 } from "./Matrix4.js";
+import { Vector3 } from "./Vector3.js";
+import { Vector2 } from "./Vector2.js";
+import { Quaternion } from "./Quaternion.js";
+import { Color } from "./Color.js";
+
+/**
+ * @param {Vector3|Vector2|Quaternion|Matrix3|Matrix4|Color} obj
+ * @return {string}
+ */
+function Var2Str(obj) {
+    // console.log("[DEBUG] JS Var2Str obj:", obj)
+    if (obj instanceof Vector3) {
+        return `Vector3,${obj.x},${obj.y},${obj.z}`
+    }
+    else if (obj instanceof Vector2) {
+        return `Vector2,${obj.x},${obj.y}`
+    }
+    else if (obj instanceof Matrix3) {
+        return `Basis,${obj.elements.join(',')}`
+    }
+    else if (obj instanceof Quaternion) {
+        return `Quat,${obj.x},${obj.y},${obj.z},${obj.w}`
+    }
+    else if (obj instanceof Matrix4) {
+        return `Transform,${obj.elements[0]},${obj.elements[1]},${obj.elements[2]},${obj.elements[4]},${obj.elements[5]},${obj.elements[6]},${obj.elements[8]},${obj.elements[9]},${obj.elements[10]},${obj.elements[12]},${obj.elements[13]},${obj.elements[14]}`
+    }
+    else if (obj instanceof Color) {
+        var r = obj.r;
+        var g = obj.g;
+        var b = obj.b;
+        return `Color,${r},${g},${b}`
+    }
+    else {
+        return obj;
+    }
+}
+
+/**
+ * @param {string} str 
+ * @returns {Vector3|Vector2|Quaternion|Matrix3|Matrix4|Color}
+ */
+function Str2Var(str) {
+    // console.log("[DEBUG] JS Str2Var str:", str)
+    var bol = Number.isInteger(str);
+    if (bol) {
+        return str;
+    }
+    let values = str.split(',')
+    let key = values[0]
+    switch (key) {
+        case "Transform":
+            return new Matrix4(
+                parseFloat(values[1]), parseFloat(values[2]), parseFloat(values[3]), 0,
+                parseFloat(values[4]), parseFloat(values[5]), parseFloat(values[6]), 0,
+                parseFloat(values[7]), parseFloat(values[8]), parseFloat(values[9]), 0,
+                parseFloat(values[10]), parseFloat(values[11]), parseFloat(values[12]), 1)
+        case "Quat":
+            return new Quaternion(parseFloat(values[1]), parseFloat(values[2]), parseFloat(values[3]), parseFloat(values[4]))
+        case "Basis":
+            return new Matrix3(...values.slice(1).map(parseFloat))
+        case "Vector3":
+            return new Vector3(parseFloat(values[1]), parseFloat(values[2]), parseFloat(values[3]))
+        case "Color":
+            return new Color(parseFloat(values[1]), parseFloat(values[2]), parseFloat(values[3]))
+        case "Vector2":
+            return new Vector2(parseFloat(values[1]), parseFloat(values[2]))
+    }
+}
+
+export {
+    Str2Var,
+    Var2Str,
+    Quaternion as Quat,
+    Vector3,
+    Vector2,
+    Matrix3 as Basis,
+    Matrix4 as Transform,
+    Color as Color
+};

package/public/math/Euler.js

@@ -0,0 +1,315 @@
+import { Quaternion } from './Quaternion.js';
+import { Matrix4 } from './Matrix4.js';
+import { clamp } from './MathUtils.js';
+
+const _matrix = /*@__PURE__*/ new Matrix4();
+const _quaternion = /*@__PURE__*/ new Quaternion();
+
+class Euler {
+
+	constructor( x = 0, y = 0, z = 0, order = Euler.DEFAULT_ORDER ) {
+
+		this.isEuler = true;
+
+		this._x = x;
+		this._y = y;
+		this._z = z;
+		this._order = order;
+
+	}
+
+	get x() {
+
+		return this._x;
+
+	}
+
+	set x( value ) {
+
+		this._x = value;
+		this._onChangeCallback();
+
+	}
+
+	get y() {
+
+		return this._y;
+
+	}
+
+	set y( value ) {
+
+		this._y = value;
+		this._onChangeCallback();
+
+	}
+
+	get z() {
+
+		return this._z;
+
+	}
+
+	set z( value ) {
+
+		this._z = value;
+		this._onChangeCallback();
+
+	}
+
+	get order() {
+
+		return this._order;
+
+	}
+
+	set order( value ) {
+
+		this._order = value;
+		this._onChangeCallback();
+
+	}
+
+	set( x, y, z, order = this._order ) {
+
+		this._x = x;
+		this._y = y;
+		this._z = z;
+		this._order = order;
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	clone() {
+
+		return new this.constructor( this._x, this._y, this._z, this._order );
+
+	}
+
+	copy( euler ) {
+
+		this._x = euler._x;
+		this._y = euler._y;
+		this._z = euler._z;
+		this._order = euler._order;
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	setFromRotationMatrix( m, order = this._order, update = true ) {
+
+		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+		const te = m.elements;
+		const m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ];
+		const m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ];
+		const m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
+
+		switch ( order ) {
+
+			case 'XYZ':
+
+				this._y = Math.asin( clamp( m13, - 1, 1 ) );
+
+				if ( Math.abs( m13 ) < 0.9999999 ) {
+
+					this._x = Math.atan2( - m23, m33 );
+					this._z = Math.atan2( - m12, m11 );
+
+				} else {
+
+					this._x = Math.atan2( m32, m22 );
+					this._z = 0;
+
+				}
+
+				break;
+
+			case 'YXZ':
+
+				this._x = Math.asin( - clamp( m23, - 1, 1 ) );
+
+				if ( Math.abs( m23 ) < 0.9999999 ) {
+
+					this._y = Math.atan2( m13, m33 );
+					this._z = Math.atan2( m21, m22 );
+
+				} else {
+
+					this._y = Math.atan2( - m31, m11 );
+					this._z = 0;
+
+				}
+
+				break;
+
+			case 'ZXY':
+
+				this._x = Math.asin( clamp( m32, - 1, 1 ) );
+
+				if ( Math.abs( m32 ) < 0.9999999 ) {
+
+					this._y = Math.atan2( - m31, m33 );
+					this._z = Math.atan2( - m12, m22 );
+
+				} else {
+
+					this._y = 0;
+					this._z = Math.atan2( m21, m11 );
+
+				}
+
+				break;
+
+			case 'ZYX':
+
+				this._y = Math.asin( - clamp( m31, - 1, 1 ) );
+
+				if ( Math.abs( m31 ) < 0.9999999 ) {
+
+					this._x = Math.atan2( m32, m33 );
+					this._z = Math.atan2( m21, m11 );
+
+				} else {
+
+					this._x = 0;
+					this._z = Math.atan2( - m12, m22 );
+
+				}
+
+				break;
+
+			case 'YZX':
+
+				this._z = Math.asin( clamp( m21, - 1, 1 ) );
+
+				if ( Math.abs( m21 ) < 0.9999999 ) {
+
+					this._x = Math.atan2( - m23, m22 );
+					this._y = Math.atan2( - m31, m11 );
+
+				} else {
+
+					this._x = 0;
+					this._y = Math.atan2( m13, m33 );
+
+				}
+
+				break;
+
+			case 'XZY':
+
+				this._z = Math.asin( - clamp( m12, - 1, 1 ) );
+
+				if ( Math.abs( m12 ) < 0.9999999 ) {
+
+					this._x = Math.atan2( m32, m22 );
+					this._y = Math.atan2( m13, m11 );
+
+				} else {
+
+					this._x = Math.atan2( - m23, m33 );
+					this._y = 0;
+
+				}
+
+				break;
+
+			default:
+
+				console.warn( 'THREE.Euler: .setFromRotationMatrix() encountered an unknown order: ' + order );
+
+		}
+
+		this._order = order;
+
+		if ( update === true ) this._onChangeCallback();
+
+		return this;
+
+	}
+
+	setFromQuaternion( q, order, update ) {
+
+		_matrix.makeRotationFromQuaternion( q );
+
+		return this.setFromRotationMatrix( _matrix, order, update );
+
+	}
+
+	setFromVector3( v, order = this._order ) {
+
+		return this.set( v.x, v.y, v.z, order );
+
+	}
+
+	reorder( newOrder ) {
+
+		// WARNING: this discards revolution information -bhouston
+
+		_quaternion.setFromEuler( this );
+
+		return this.setFromQuaternion( _quaternion, newOrder );
+
+	}
+
+	equals( euler ) {
+
+		return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );
+
+	}
+
+	fromArray( array ) {
+
+		this._x = array[ 0 ];
+		this._y = array[ 1 ];
+		this._z = array[ 2 ];
+		if ( array[ 3 ] !== undefined ) this._order = array[ 3 ];
+
+		this._onChangeCallback();
+
+		return this;
+
+	}
+
+	toArray( array = [], offset = 0 ) {
+
+		array[ offset ] = this._x;
+		array[ offset + 1 ] = this._y;
+		array[ offset + 2 ] = this._z;
+		array[ offset + 3 ] = this._order;
+
+		return array;
+
+	}
+
+	_onChange( callback ) {
+
+		this._onChangeCallback = callback;
+
+		return this;
+
+	}
+
+	_onChangeCallback() {}
+
+	*[ Symbol.iterator ]() {
+
+		yield this._x;
+		yield this._y;
+		yield this._z;
+		yield this._order;
+
+	}
+
+}
+
+Euler.DEFAULT_ORDER = 'XYZ';
+
+export { Euler };

package/public/math/Frustum.js

@@ -0,0 +1,162 @@
+import { Vector3 } from './Vector3.js';
+import { Sphere } from './Sphere.js';
+import { Plane } from './Plane.js';
+
+const _sphere = /*@__PURE__*/ new Sphere();
+const _vector = /*@__PURE__*/ new Vector3();
+
+class Frustum {
+
+	constructor( p0 = new Plane(), p1 = new Plane(), p2 = new Plane(), p3 = new Plane(), p4 = new Plane(), p5 = new Plane() ) {
+
+		this.planes = [ p0, p1, p2, p3, p4, p5 ];
+
+	}
+
+	set( p0, p1, p2, p3, p4, p5 ) {
+
+		const planes = this.planes;
+
+		planes[ 0 ].copy( p0 );
+		planes[ 1 ].copy( p1 );
+		planes[ 2 ].copy( p2 );
+		planes[ 3 ].copy( p3 );
+		planes[ 4 ].copy( p4 );
+		planes[ 5 ].copy( p5 );
+
+		return this;
+
+	}
+
+	copy( frustum ) {
+
+		const planes = this.planes;
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			planes[ i ].copy( frustum.planes[ i ] );
+
+		}
+
+		return this;
+
+	}
+
+	setFromProjectionMatrix( m ) {
+
+		const planes = this.planes;
+		const me = m.elements;
+		const me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ];
+		const me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ];
+		const me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ];
+		const me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ];
+
+		planes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize();
+		planes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize();
+		planes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize();
+		planes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize();
+		planes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize();
+		planes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize();
+
+		return this;
+
+	}
+
+	intersectsObject( object ) {
+
+		const geometry = object.geometry;
+
+		if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
+
+		_sphere.copy( geometry.boundingSphere ).applyMatrix4( object.matrixWorld );
+
+		return this.intersectsSphere( _sphere );
+
+	}
+
+	intersectsSprite( sprite ) {
+
+		_sphere.center.set( 0, 0, 0 );
+		_sphere.radius = 0.7071067811865476;
+		_sphere.applyMatrix4( sprite.matrixWorld );
+
+		return this.intersectsSphere( _sphere );
+
+	}
+
+	intersectsSphere( sphere ) {
+
+		const planes = this.planes;
+		const center = sphere.center;
+		const negRadius = - sphere.radius;
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			const distance = planes[ i ].distanceToPoint( center );
+
+			if ( distance < negRadius ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	intersectsBox( box ) {
+
+		const planes = this.planes;
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			const plane = planes[ i ];
+
+			// corner at max distance
+
+			_vector.x = plane.normal.x > 0 ? box.max.x : box.min.x;
+			_vector.y = plane.normal.y > 0 ? box.max.y : box.min.y;
+			_vector.z = plane.normal.z > 0 ? box.max.z : box.min.z;
+
+			if ( plane.distanceToPoint( _vector ) < 0 ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	containsPoint( point ) {
+
+		const planes = this.planes;
+
+		for ( let i = 0; i < 6; i ++ ) {
+
+			if ( planes[ i ].distanceToPoint( point ) < 0 ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+	clone() {
+
+		return new this.constructor().copy( this );
+
+	}
+
+}
+
+
+export { Frustum };