mirror of
https://github.com/xibyte/jsketcher
synced 2026-01-08 16:58:42 +01:00
349 lines
6.6 KiB
JavaScript
349 lines
6.6 KiB
JavaScript
/**
|
|
* @author mrdoob / http://mrdoob.com/
|
|
* @author WestLangley / http://github.com/WestLangley
|
|
* @author bhouston / http://exocortex.com
|
|
*/
|
|
|
|
THREE.Euler = function ( x, y, z, order ) {
|
|
|
|
this._x = x || 0;
|
|
this._y = y || 0;
|
|
this._z = z || 0;
|
|
this._order = order || THREE.Euler.DefaultOrder;
|
|
|
|
};
|
|
|
|
THREE.Euler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ];
|
|
|
|
THREE.Euler.DefaultOrder = 'XYZ';
|
|
|
|
THREE.Euler.prototype = {
|
|
|
|
constructor: THREE.Euler,
|
|
|
|
_x: 0, _y: 0, _z: 0, _order: THREE.Euler.DefaultOrder,
|
|
|
|
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: function ( x, y, z, order ) {
|
|
|
|
this._x = x;
|
|
this._y = y;
|
|
this._z = z;
|
|
this._order = order || this._order;
|
|
|
|
this.onChangeCallback();
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
copy: function ( euler ) {
|
|
|
|
this._x = euler._x;
|
|
this._y = euler._y;
|
|
this._z = euler._z;
|
|
this._order = euler._order;
|
|
|
|
this.onChangeCallback();
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
setFromRotationMatrix: function ( m, order ) {
|
|
|
|
var clamp = THREE.Math.clamp;
|
|
|
|
// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
|
|
|
|
var te = m.elements;
|
|
var m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ];
|
|
var m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ];
|
|
var m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
|
|
|
|
order = order || this._order;
|
|
|
|
if ( order === 'XYZ' ) {
|
|
|
|
this._y = Math.asin( clamp( m13, - 1, 1 ) );
|
|
|
|
if ( Math.abs( m13 ) < 0.99999 ) {
|
|
|
|
this._x = Math.atan2( - m23, m33 );
|
|
this._z = Math.atan2( - m12, m11 );
|
|
|
|
} else {
|
|
|
|
this._x = Math.atan2( m32, m22 );
|
|
this._z = 0;
|
|
|
|
}
|
|
|
|
} else if ( order === 'YXZ' ) {
|
|
|
|
this._x = Math.asin( - clamp( m23, - 1, 1 ) );
|
|
|
|
if ( Math.abs( m23 ) < 0.99999 ) {
|
|
|
|
this._y = Math.atan2( m13, m33 );
|
|
this._z = Math.atan2( m21, m22 );
|
|
|
|
} else {
|
|
|
|
this._y = Math.atan2( - m31, m11 );
|
|
this._z = 0;
|
|
|
|
}
|
|
|
|
} else if ( order === 'ZXY' ) {
|
|
|
|
this._x = Math.asin( clamp( m32, - 1, 1 ) );
|
|
|
|
if ( Math.abs( m32 ) < 0.99999 ) {
|
|
|
|
this._y = Math.atan2( - m31, m33 );
|
|
this._z = Math.atan2( - m12, m22 );
|
|
|
|
} else {
|
|
|
|
this._y = 0;
|
|
this._z = Math.atan2( m21, m11 );
|
|
|
|
}
|
|
|
|
} else if ( order === 'ZYX' ) {
|
|
|
|
this._y = Math.asin( - clamp( m31, - 1, 1 ) );
|
|
|
|
if ( Math.abs( m31 ) < 0.99999 ) {
|
|
|
|
this._x = Math.atan2( m32, m33 );
|
|
this._z = Math.atan2( m21, m11 );
|
|
|
|
} else {
|
|
|
|
this._x = 0;
|
|
this._z = Math.atan2( - m12, m22 );
|
|
|
|
}
|
|
|
|
} else if ( order === 'YZX' ) {
|
|
|
|
this._z = Math.asin( clamp( m21, - 1, 1 ) );
|
|
|
|
if ( Math.abs( m21 ) < 0.99999 ) {
|
|
|
|
this._x = Math.atan2( - m23, m22 );
|
|
this._y = Math.atan2( - m31, m11 );
|
|
|
|
} else {
|
|
|
|
this._x = 0;
|
|
this._y = Math.atan2( m13, m33 );
|
|
|
|
}
|
|
|
|
} else if ( order === 'XZY' ) {
|
|
|
|
this._z = Math.asin( - clamp( m12, - 1, 1 ) );
|
|
|
|
if ( Math.abs( m12 ) < 0.99999 ) {
|
|
|
|
this._x = Math.atan2( m32, m22 );
|
|
this._y = Math.atan2( m13, m11 );
|
|
|
|
} else {
|
|
|
|
this._x = Math.atan2( - m23, m33 );
|
|
this._y = 0;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
console.warn( 'THREE.Euler: .setFromRotationMatrix() given unsupported order: ' + order )
|
|
|
|
}
|
|
|
|
this._order = order;
|
|
|
|
this.onChangeCallback();
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
setFromQuaternion: function ( q, order, update ) {
|
|
|
|
var clamp = THREE.Math.clamp;
|
|
|
|
// q is assumed to be normalized
|
|
|
|
// http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
|
|
|
|
var sqx = q.x * q.x;
|
|
var sqy = q.y * q.y;
|
|
var sqz = q.z * q.z;
|
|
var sqw = q.w * q.w;
|
|
|
|
order = order || this._order;
|
|
|
|
if ( order === 'XYZ' ) {
|
|
|
|
this._x = Math.atan2( 2 * ( q.x * q.w - q.y * q.z ), ( sqw - sqx - sqy + sqz ) );
|
|
this._y = Math.asin( clamp( 2 * ( q.x * q.z + q.y * q.w ), - 1, 1 ) );
|
|
this._z = Math.atan2( 2 * ( q.z * q.w - q.x * q.y ), ( sqw + sqx - sqy - sqz ) );
|
|
|
|
} else if ( order === 'YXZ' ) {
|
|
|
|
this._x = Math.asin( clamp( 2 * ( q.x * q.w - q.y * q.z ), - 1, 1 ) );
|
|
this._y = Math.atan2( 2 * ( q.x * q.z + q.y * q.w ), ( sqw - sqx - sqy + sqz ) );
|
|
this._z = Math.atan2( 2 * ( q.x * q.y + q.z * q.w ), ( sqw - sqx + sqy - sqz ) );
|
|
|
|
} else if ( order === 'ZXY' ) {
|
|
|
|
this._x = Math.asin( clamp( 2 * ( q.x * q.w + q.y * q.z ), - 1, 1 ) );
|
|
this._y = Math.atan2( 2 * ( q.y * q.w - q.z * q.x ), ( sqw - sqx - sqy + sqz ) );
|
|
this._z = Math.atan2( 2 * ( q.z * q.w - q.x * q.y ), ( sqw - sqx + sqy - sqz ) );
|
|
|
|
} else if ( order === 'ZYX' ) {
|
|
|
|
this._x = Math.atan2( 2 * ( q.x * q.w + q.z * q.y ), ( sqw - sqx - sqy + sqz ) );
|
|
this._y = Math.asin( clamp( 2 * ( q.y * q.w - q.x * q.z ), - 1, 1 ) );
|
|
this._z = Math.atan2( 2 * ( q.x * q.y + q.z * q.w ), ( sqw + sqx - sqy - sqz ) );
|
|
|
|
} else if ( order === 'YZX' ) {
|
|
|
|
this._x = Math.atan2( 2 * ( q.x * q.w - q.z * q.y ), ( sqw - sqx + sqy - sqz ) );
|
|
this._y = Math.atan2( 2 * ( q.y * q.w - q.x * q.z ), ( sqw + sqx - sqy - sqz ) );
|
|
this._z = Math.asin( clamp( 2 * ( q.x * q.y + q.z * q.w ), - 1, 1 ) );
|
|
|
|
} else if ( order === 'XZY' ) {
|
|
|
|
this._x = Math.atan2( 2 * ( q.x * q.w + q.y * q.z ), ( sqw - sqx + sqy - sqz ) );
|
|
this._y = Math.atan2( 2 * ( q.x * q.z + q.y * q.w ), ( sqw + sqx - sqy - sqz ) );
|
|
this._z = Math.asin( clamp( 2 * ( q.z * q.w - q.x * q.y ), - 1, 1 ) );
|
|
|
|
} else {
|
|
|
|
console.warn( 'THREE.Euler: .setFromQuaternion() given unsupported order: ' + order )
|
|
|
|
}
|
|
|
|
this._order = order;
|
|
|
|
if ( update !== false ) this.onChangeCallback();
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
reorder: function () {
|
|
|
|
// WARNING: this discards revolution information -bhouston
|
|
|
|
var q = new THREE.Quaternion();
|
|
|
|
return function ( newOrder ) {
|
|
|
|
q.setFromEuler( this );
|
|
this.setFromQuaternion( q, newOrder );
|
|
|
|
};
|
|
|
|
|
|
}(),
|
|
|
|
equals: function ( euler ) {
|
|
|
|
return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );
|
|
|
|
},
|
|
|
|
fromArray: function ( 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: function () {
|
|
|
|
return [ this._x, this._y, this._z, this._order ];
|
|
|
|
},
|
|
|
|
onChange: function ( callback ) {
|
|
|
|
this.onChangeCallback = callback;
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
onChangeCallback: function () {},
|
|
|
|
clone: function () {
|
|
|
|
return new THREE.Euler( this._x, this._y, this._z, this._order );
|
|
|
|
}
|
|
|
|
};
|