| |
| |
| |
| |
| |
| |
|
|
| function Vector2( x, y ) { |
|
|
| this.x = x || 0; |
| this.y = y || 0; |
|
|
| } |
|
|
| Object.defineProperties( Vector2.prototype, { |
|
|
| "width": { |
|
|
| get: function () { |
|
|
| return this.x; |
|
|
| }, |
|
|
| set: function ( value ) { |
|
|
| this.x = value; |
|
|
| } |
|
|
| }, |
|
|
| "height": { |
|
|
| get: function () { |
|
|
| return this.y; |
|
|
| }, |
|
|
| set: function ( value ) { |
|
|
| this.y = value; |
|
|
| } |
|
|
| } |
|
|
| } ); |
|
|
| Object.assign( Vector2.prototype, { |
|
|
| isVector2: true, |
|
|
| set: function ( x, y ) { |
|
|
| this.x = x; |
| this.y = y; |
|
|
| return this; |
|
|
| }, |
|
|
| setScalar: function ( scalar ) { |
|
|
| this.x = scalar; |
| this.y = scalar; |
|
|
| return this; |
|
|
| }, |
|
|
| setX: function ( x ) { |
|
|
| this.x = x; |
|
|
| return this; |
|
|
| }, |
|
|
| setY: function ( y ) { |
|
|
| this.y = y; |
|
|
| return this; |
|
|
| }, |
|
|
| setComponent: function ( index, value ) { |
|
|
| switch ( index ) { |
|
|
| case 0: this.x = value; break; |
| case 1: this.y = value; break; |
| default: throw new Error( 'index is out of range: ' + index ); |
|
|
| } |
|
|
| return this; |
|
|
| }, |
|
|
| getComponent: function ( index ) { |
|
|
| switch ( index ) { |
|
|
| case 0: return this.x; |
| case 1: return this.y; |
| default: throw new Error( 'index is out of range: ' + index ); |
|
|
| } |
|
|
| }, |
|
|
| clone: function () { |
|
|
| return new this.constructor( this.x, this.y ); |
|
|
| }, |
|
|
| copy: function ( v ) { |
|
|
| this.x = v.x; |
| this.y = v.y; |
|
|
| return this; |
|
|
| }, |
|
|
| add: function ( v, w ) { |
|
|
| if ( w !== undefined ) { |
|
|
| console.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' ); |
| return this.addVectors( v, w ); |
|
|
| } |
|
|
| this.x += v.x; |
| this.y += v.y; |
|
|
| return this; |
|
|
| }, |
|
|
| addScalar: function ( s ) { |
|
|
| this.x += s; |
| this.y += s; |
|
|
| return this; |
|
|
| }, |
|
|
| addVectors: function ( a, b ) { |
|
|
| this.x = a.x + b.x; |
| this.y = a.y + b.y; |
|
|
| return this; |
|
|
| }, |
|
|
| addScaledVector: function ( v, s ) { |
|
|
| this.x += v.x * s; |
| this.y += v.y * s; |
|
|
| return this; |
|
|
| }, |
|
|
| sub: function ( v, w ) { |
|
|
| if ( w !== undefined ) { |
|
|
| console.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' ); |
| return this.subVectors( v, w ); |
|
|
| } |
|
|
| this.x -= v.x; |
| this.y -= v.y; |
|
|
| return this; |
|
|
| }, |
|
|
| subScalar: function ( s ) { |
|
|
| this.x -= s; |
| this.y -= s; |
|
|
| return this; |
|
|
| }, |
|
|
| subVectors: function ( a, b ) { |
|
|
| this.x = a.x - b.x; |
| this.y = a.y - b.y; |
|
|
| return this; |
|
|
| }, |
|
|
| multiply: function ( v ) { |
|
|
| this.x *= v.x; |
| this.y *= v.y; |
|
|
| return this; |
|
|
| }, |
|
|
| multiplyScalar: function ( scalar ) { |
|
|
| this.x *= scalar; |
| this.y *= scalar; |
|
|
| return this; |
|
|
| }, |
|
|
| divide: function ( v ) { |
|
|
| this.x /= v.x; |
| this.y /= v.y; |
|
|
| return this; |
|
|
| }, |
|
|
| divideScalar: function ( scalar ) { |
|
|
| return this.multiplyScalar( 1 / scalar ); |
|
|
| }, |
|
|
| applyMatrix3: function ( m ) { |
|
|
| var x = this.x, y = this.y; |
| var e = m.elements; |
|
|
| this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ]; |
| this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ]; |
|
|
| return this; |
|
|
| }, |
|
|
| min: function ( v ) { |
|
|
| this.x = Math.min( this.x, v.x ); |
| this.y = Math.min( this.y, v.y ); |
|
|
| return this; |
|
|
| }, |
|
|
| max: function ( v ) { |
|
|
| this.x = Math.max( this.x, v.x ); |
| this.y = Math.max( this.y, v.y ); |
|
|
| return this; |
|
|
| }, |
|
|
| clamp: function ( min, max ) { |
|
|
| |
|
|
| this.x = Math.max( min.x, Math.min( max.x, this.x ) ); |
| this.y = Math.max( min.y, Math.min( max.y, this.y ) ); |
|
|
| return this; |
|
|
| }, |
|
|
| clampScalar: function () { |
|
|
| var min = new Vector2(); |
| var max = new Vector2(); |
|
|
| return function clampScalar( minVal, maxVal ) { |
|
|
| min.set( minVal, minVal ); |
| max.set( maxVal, maxVal ); |
|
|
| return this.clamp( min, max ); |
|
|
| }; |
|
|
| }(), |
|
|
| clampLength: function ( min, max ) { |
|
|
| var length = this.length(); |
|
|
| return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) ); |
|
|
| }, |
|
|
| floor: function () { |
|
|
| this.x = Math.floor( this.x ); |
| this.y = Math.floor( this.y ); |
|
|
| return this; |
|
|
| }, |
|
|
| ceil: function () { |
|
|
| this.x = Math.ceil( this.x ); |
| this.y = Math.ceil( this.y ); |
|
|
| return this; |
|
|
| }, |
|
|
| round: function () { |
|
|
| this.x = Math.round( this.x ); |
| this.y = Math.round( this.y ); |
|
|
| return this; |
|
|
| }, |
|
|
| roundToZero: function () { |
|
|
| this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x ); |
| this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y ); |
|
|
| return this; |
|
|
| }, |
|
|
| negate: function () { |
|
|
| this.x = - this.x; |
| this.y = - this.y; |
|
|
| return this; |
|
|
| }, |
|
|
| dot: function ( v ) { |
|
|
| return this.x * v.x + this.y * v.y; |
|
|
| }, |
|
|
| cross: function ( v ) { |
|
|
| return this.x * v.y - this.y * v.x; |
|
|
| }, |
|
|
| lengthSq: function () { |
|
|
| return this.x * this.x + this.y * this.y; |
|
|
| }, |
|
|
| length: function () { |
|
|
| return Math.sqrt( this.x * this.x + this.y * this.y ); |
|
|
| }, |
|
|
| manhattanLength: function () { |
|
|
| return Math.abs( this.x ) + Math.abs( this.y ); |
|
|
| }, |
|
|
| normalize: function () { |
|
|
| return this.divideScalar( this.length() || 1 ); |
|
|
| }, |
|
|
| angle: function () { |
|
|
| |
|
|
| var angle = Math.atan2( this.y, this.x ); |
|
|
| if ( angle < 0 ) angle += 2 * Math.PI; |
|
|
| return angle; |
|
|
| }, |
|
|
| distanceTo: function ( v ) { |
|
|
| return Math.sqrt( this.distanceToSquared( v ) ); |
|
|
| }, |
|
|
| distanceToSquared: function ( v ) { |
|
|
| var dx = this.x - v.x, dy = this.y - v.y; |
| return dx * dx + dy * dy; |
|
|
| }, |
|
|
| manhattanDistanceTo: function ( v ) { |
|
|
| return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ); |
|
|
| }, |
|
|
| setLength: function ( length ) { |
|
|
| return this.normalize().multiplyScalar( length ); |
|
|
| }, |
|
|
| lerp: function ( v, alpha ) { |
|
|
| this.x += ( v.x - this.x ) * alpha; |
| this.y += ( v.y - this.y ) * alpha; |
|
|
| return this; |
|
|
| }, |
|
|
| lerpVectors: function ( v1, v2, alpha ) { |
|
|
| return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 ); |
|
|
| }, |
|
|
| equals: function ( v ) { |
|
|
| return ( ( v.x === this.x ) && ( v.y === this.y ) ); |
|
|
| }, |
|
|
| fromArray: function ( array, offset ) { |
|
|
| if ( offset === undefined ) offset = 0; |
|
|
| this.x = array[ offset ]; |
| this.y = array[ offset + 1 ]; |
|
|
| return this; |
|
|
| }, |
|
|
| toArray: function ( array, offset ) { |
|
|
| if ( array === undefined ) array = []; |
| if ( offset === undefined ) offset = 0; |
|
|
| array[ offset ] = this.x; |
| array[ offset + 1 ] = this.y; |
|
|
| return array; |
|
|
| }, |
|
|
| fromBufferAttribute: function ( attribute, index, offset ) { |
|
|
| if ( offset !== undefined ) { |
|
|
| console.warn( 'THREE.Vector2: offset has been removed from .fromBufferAttribute().' ); |
|
|
| } |
|
|
| this.x = attribute.getX( index ); |
| this.y = attribute.getY( index ); |
|
|
| return this; |
|
|
| }, |
|
|
| rotateAround: function ( center, angle ) { |
|
|
| var c = Math.cos( angle ), s = Math.sin( angle ); |
|
|
| var x = this.x - center.x; |
| var y = this.y - center.y; |
|
|
| this.x = x * c - y * s + center.x; |
| this.y = x * s + y * c + center.y; |
|
|
| return this; |
|
|
| } |
|
|
| } ); |
|
|
|
|
| export { Vector2 }; |
|
|
