mirror of
https://github.com/tengge1/ShadowEditor.git
synced 2026-01-25 15:08:11 +00:00
239 lines
4.6 KiB
Go
239 lines
4.6 KiB
Go
// +build ignore
|
|
|
|
// Copyright 2017-2020 The ShadowEditor Authors. All rights reserved.
|
|
// Use of this source code is governed by a MIT-style
|
|
// license that can be found in the LICENSE file.
|
|
//
|
|
// For more information, please visit: https://github.com/tengge1/ShadowEditor
|
|
// You can also visit: https://gitee.com/tengge1/ShadowEditor
|
|
//
|
|
// This package is translated from three.js, visit `https://github.com/mrdoob/three.js`
|
|
// for more information.
|
|
|
|
package three
|
|
|
|
/**
|
|
* @author bhouston / http://clara.io
|
|
*/
|
|
|
|
var _vector1 = new Vector3();
|
|
var _vector2 = new Vector3();
|
|
var _normalMatrix = new Matrix3();
|
|
|
|
function Plane( normal, constant ) {
|
|
|
|
// normal is assumed to be normalized
|
|
|
|
this.normal = ( normal !== undefined ) ? normal : new Vector3( 1, 0, 0 );
|
|
this.constant = ( constant !== undefined ) ? constant : 0;
|
|
|
|
}
|
|
|
|
Object.assign( Plane.prototype, {
|
|
|
|
isPlane: true,
|
|
|
|
set: function ( normal, constant ) {
|
|
|
|
this.normal.copy( normal );
|
|
this.constant = constant;
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
setComponents: function ( x, y, z, w ) {
|
|
|
|
this.normal.set( x, y, z );
|
|
this.constant = w;
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
setFromNormalAndCoplanarPoint: function ( normal, point ) {
|
|
|
|
this.normal.copy( normal );
|
|
this.constant = - point.dot( this.normal );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
setFromCoplanarPoints: function ( a, b, c ) {
|
|
|
|
var normal = _vector1.subVectors( c, b ).cross( _vector2.subVectors( a, b ) ).normalize();
|
|
|
|
// Q: should an error be thrown if normal is zero (e.g. degenerate plane)?
|
|
|
|
this.setFromNormalAndCoplanarPoint( normal, a );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
clone: function () {
|
|
|
|
return new this.constructor().copy( this );
|
|
|
|
},
|
|
|
|
copy: function ( plane ) {
|
|
|
|
this.normal.copy( plane.normal );
|
|
this.constant = plane.constant;
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
normalize: function () {
|
|
|
|
// Note: will lead to a divide by zero if the plane is invalid.
|
|
|
|
var inverseNormalLength = 1.0 / this.normal.length();
|
|
this.normal.multiplyScalar( inverseNormalLength );
|
|
this.constant *= inverseNormalLength;
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
negate: function () {
|
|
|
|
this.constant *= - 1;
|
|
this.normal.negate();
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
distanceToPoint: function ( point ) {
|
|
|
|
return this.normal.dot( point ) + this.constant;
|
|
|
|
},
|
|
|
|
distanceToSphere: function ( sphere ) {
|
|
|
|
return this.distanceToPoint( sphere.center ) - sphere.radius;
|
|
|
|
},
|
|
|
|
projectPoint: function ( point, target ) {
|
|
|
|
if ( target === undefined ) {
|
|
|
|
console.warn( 'THREE.Plane: .projectPoint() target is now required' );
|
|
target = new Vector3();
|
|
|
|
}
|
|
|
|
return target.copy( this.normal ).multiplyScalar( - this.distanceToPoint( point ) ).add( point );
|
|
|
|
},
|
|
|
|
intersectLine: function ( line, target ) {
|
|
|
|
if ( target === undefined ) {
|
|
|
|
console.warn( 'THREE.Plane: .intersectLine() target is now required' );
|
|
target = new Vector3();
|
|
|
|
}
|
|
|
|
var direction = line.delta( _vector1 );
|
|
|
|
var denominator = this.normal.dot( direction );
|
|
|
|
if ( denominator === 0 ) {
|
|
|
|
// line is coplanar, return origin
|
|
if ( this.distanceToPoint( line.start ) === 0 ) {
|
|
|
|
return target.copy( line.start );
|
|
|
|
}
|
|
|
|
// Unsure if this is the correct method to handle this case.
|
|
return undefined;
|
|
|
|
}
|
|
|
|
var t = - ( line.start.dot( this.normal ) + this.constant ) / denominator;
|
|
|
|
if ( t < 0 || t > 1 ) {
|
|
|
|
return undefined;
|
|
|
|
}
|
|
|
|
return target.copy( direction ).multiplyScalar( t ).add( line.start );
|
|
|
|
},
|
|
|
|
intersectsLine: function ( line ) {
|
|
|
|
// Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.
|
|
|
|
var startSign = this.distanceToPoint( line.start );
|
|
var endSign = this.distanceToPoint( line.end );
|
|
|
|
return ( startSign < 0 && endSign > 0 ) || ( endSign < 0 && startSign > 0 );
|
|
|
|
},
|
|
|
|
intersectsBox: function ( box ) {
|
|
|
|
return box.intersectsPlane( this );
|
|
|
|
},
|
|
|
|
intersectsSphere: function ( sphere ) {
|
|
|
|
return sphere.intersectsPlane( this );
|
|
|
|
},
|
|
|
|
coplanarPoint: function ( target ) {
|
|
|
|
if ( target === undefined ) {
|
|
|
|
console.warn( 'THREE.Plane: .coplanarPoint() target is now required' );
|
|
target = new Vector3();
|
|
|
|
}
|
|
|
|
return target.copy( this.normal ).multiplyScalar( - this.constant );
|
|
|
|
},
|
|
|
|
applyMatrix4: function ( matrix, optionalNormalMatrix ) {
|
|
|
|
var normalMatrix = optionalNormalMatrix || _normalMatrix.getNormalMatrix( matrix );
|
|
|
|
var referencePoint = this.coplanarPoint( _vector1 ).applyMatrix4( matrix );
|
|
|
|
var normal = this.normal.applyMatrix3( normalMatrix ).normalize();
|
|
|
|
this.constant = - referencePoint.dot( normal );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
translate: function ( offset ) {
|
|
|
|
this.constant -= offset.dot( this.normal );
|
|
|
|
return this;
|
|
|
|
},
|
|
|
|
equals: function ( plane ) {
|
|
|
|
return plane.normal.equals( this.normal ) && ( plane.constant === this.constant );
|
|
|
|
}
|
|
|
|
} ); |