|
|
@@ -52,6 +52,293 @@ THREE.Mesh.prototype.getMorphTargetIndexByName = function ( name ) {
|
|
|
|
|
|
};
|
|
|
|
|
|
+
|
|
|
+THREE.Mesh.prototype.raycast = ( function () {
|
|
|
+
|
|
|
+ var inverseMatrix = new THREE.Matrix4();
|
|
|
+ var ray = new THREE.Ray();
|
|
|
+ var sphere = new THREE.Sphere();
|
|
|
+
|
|
|
+ var vA = new THREE.Vector3();
|
|
|
+ var vB = new THREE.Vector3();
|
|
|
+ var vC = new THREE.Vector3();
|
|
|
+
|
|
|
+ return function ( raycaster, intersects ) {
|
|
|
+
|
|
|
+ var geometry = this.geometry;
|
|
|
+
|
|
|
+ // Checking boundingSphere distance to ray
|
|
|
+
|
|
|
+ if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
|
|
|
+
|
|
|
+ sphere.copy( geometry.boundingSphere );
|
|
|
+ sphere.applyMatrix4( this.matrixWorld );
|
|
|
+
|
|
|
+ if ( raycaster.ray.isIntersectionSphere( sphere ) === false ) {
|
|
|
+
|
|
|
+ return;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // Check boundingBox before continuing
|
|
|
+
|
|
|
+ inverseMatrix.getInverse( this.matrixWorld );
|
|
|
+ ray.copy( raycaster.ray ).applyMatrix4( inverseMatrix );
|
|
|
+
|
|
|
+ if ( geometry.boundingBox !== null ) {
|
|
|
+
|
|
|
+ if ( ray.isIntersectionBox( geometry.boundingBox ) === false ) {
|
|
|
+
|
|
|
+ return;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( geometry instanceof THREE.BufferGeometry ) {
|
|
|
+
|
|
|
+ var material = this.material;
|
|
|
+
|
|
|
+ if ( material === undefined ) return;
|
|
|
+
|
|
|
+ var attributes = geometry.attributes;
|
|
|
+
|
|
|
+ var a, b, c;
|
|
|
+ var precision = raycaster.precision;
|
|
|
+
|
|
|
+ if ( attributes.index !== undefined ) {
|
|
|
+
|
|
|
+ var indices = attributes.index.array;
|
|
|
+ var positions = attributes.position.array;
|
|
|
+ var offsets = geometry.offsets;
|
|
|
+
|
|
|
+ if ( offsets.length === 0 ) {
|
|
|
+
|
|
|
+ offsets = [ { start: 0, count: indices.length, index: 0 } ];
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ for ( var oi = 0, ol = offsets.length; oi < ol; ++oi ) {
|
|
|
+
|
|
|
+ var start = offsets[ oi ].start;
|
|
|
+ var count = offsets[ oi ].count;
|
|
|
+ var index = offsets[ oi ].index;
|
|
|
+
|
|
|
+ for ( var i = start, il = start + count; i < il; i += 3 ) {
|
|
|
+
|
|
|
+ a = index + indices[ i ];
|
|
|
+ b = index + indices[ i + 1 ];
|
|
|
+ c = index + indices[ i + 2 ];
|
|
|
+
|
|
|
+ vA.set(
|
|
|
+ positions[ a * 3 ],
|
|
|
+ positions[ a * 3 + 1 ],
|
|
|
+ positions[ a * 3 + 2 ]
|
|
|
+ );
|
|
|
+ vB.set(
|
|
|
+ positions[ b * 3 ],
|
|
|
+ positions[ b * 3 + 1 ],
|
|
|
+ positions[ b * 3 + 2 ]
|
|
|
+ );
|
|
|
+ vC.set(
|
|
|
+ positions[ c * 3 ],
|
|
|
+ positions[ c * 3 + 1 ],
|
|
|
+ positions[ c * 3 + 2 ]
|
|
|
+ );
|
|
|
+
|
|
|
+
|
|
|
+ if ( material.side === THREE.BackSide ) {
|
|
|
+
|
|
|
+ var intersectionPoint = ray.intersectTriangle( vC, vB, vA, true );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var intersectionPoint = ray.intersectTriangle( vA, vB, vC, material.side !== THREE.DoubleSide );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( intersectionPoint === null ) continue;
|
|
|
+
|
|
|
+ intersectionPoint.applyMatrix4( this.matrixWorld );
|
|
|
+
|
|
|
+ var distance = raycaster.ray.origin.distanceTo( intersectionPoint );
|
|
|
+
|
|
|
+ if ( distance < precision || distance < raycaster.near || distance > raycaster.far ) continue;
|
|
|
+
|
|
|
+ intersects.push( {
|
|
|
+
|
|
|
+ distance: distance,
|
|
|
+ point: intersectionPoint,
|
|
|
+ indices: [a, b, c],
|
|
|
+ face: null,
|
|
|
+ faceIndex: null,
|
|
|
+ object: this
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var positions = attributes.position.array;
|
|
|
+
|
|
|
+ for ( var i = 0, j = 0, il = positions.length; i < il; i += 3, j += 9 ) {
|
|
|
+
|
|
|
+ a = i;
|
|
|
+ b = i + 1;
|
|
|
+ c = i + 2;
|
|
|
+
|
|
|
+ vA.set(
|
|
|
+ positions[ j ],
|
|
|
+ positions[ j + 1 ],
|
|
|
+ positions[ j + 2 ]
|
|
|
+ );
|
|
|
+ vB.set(
|
|
|
+ positions[ j + 3 ],
|
|
|
+ positions[ j + 4 ],
|
|
|
+ positions[ j + 5 ]
|
|
|
+ );
|
|
|
+ vC.set(
|
|
|
+ positions[ j + 6 ],
|
|
|
+ positions[ j + 7 ],
|
|
|
+ positions[ j + 8 ]
|
|
|
+ );
|
|
|
+
|
|
|
+
|
|
|
+ if ( material.side === THREE.BackSide ) {
|
|
|
+
|
|
|
+ var intersectionPoint = ray.intersectTriangle( vC, vB, vA, true );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var intersectionPoint = ray.intersectTriangle( vA, vB, vC, material.side !== THREE.DoubleSide );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( intersectionPoint === null ) continue;
|
|
|
+
|
|
|
+ intersectionPoint.applyMatrix4( this.matrixWorld );
|
|
|
+
|
|
|
+ var distance = raycaster.ray.origin.distanceTo( intersectionPoint );
|
|
|
+
|
|
|
+ if ( distance < precision || distance < raycaster.near || distance > raycaster.far ) continue;
|
|
|
+
|
|
|
+ intersects.push( {
|
|
|
+
|
|
|
+ distance: distance,
|
|
|
+ point: intersectionPoint,
|
|
|
+ indices: [ a, b, c ],
|
|
|
+ face: null,
|
|
|
+ faceIndex: null,
|
|
|
+ object: this
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ } else if ( geometry instanceof THREE.Geometry ) {
|
|
|
+
|
|
|
+ var isFaceMaterial = this.material instanceof THREE.MeshFaceMaterial;
|
|
|
+ var objectMaterials = isFaceMaterial === true ? this.material.materials : null;
|
|
|
+
|
|
|
+ var a, b, c, d;
|
|
|
+ var precision = raycaster.precision;
|
|
|
+
|
|
|
+ var vertices = geometry.vertices;
|
|
|
+
|
|
|
+ for ( var f = 0, fl = geometry.faces.length; f < fl; f ++ ) {
|
|
|
+
|
|
|
+ var face = geometry.faces[ f ];
|
|
|
+
|
|
|
+ var material = isFaceMaterial === true ? objectMaterials[ face.materialIndex ] : this.material;
|
|
|
+
|
|
|
+ if ( material === undefined ) continue;
|
|
|
+
|
|
|
+ a = vertices[ face.a ];
|
|
|
+ b = vertices[ face.b ];
|
|
|
+ c = vertices[ face.c ];
|
|
|
+
|
|
|
+ if ( material.morphTargets === true ) {
|
|
|
+
|
|
|
+ var morphTargets = geometry.morphTargets;
|
|
|
+ var morphInfluences = this.morphTargetInfluences;
|
|
|
+
|
|
|
+ vA.set( 0, 0, 0 );
|
|
|
+ vB.set( 0, 0, 0 );
|
|
|
+ vC.set( 0, 0, 0 );
|
|
|
+
|
|
|
+ for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {
|
|
|
+
|
|
|
+ var influence = morphInfluences[ t ];
|
|
|
+
|
|
|
+ if ( influence === 0 ) continue;
|
|
|
+
|
|
|
+ var targets = morphTargets[ t ].vertices;
|
|
|
+
|
|
|
+ vA.x += ( targets[ face.a ].x - a.x ) * influence;
|
|
|
+ vA.y += ( targets[ face.a ].y - a.y ) * influence;
|
|
|
+ vA.z += ( targets[ face.a ].z - a.z ) * influence;
|
|
|
+
|
|
|
+ vB.x += ( targets[ face.b ].x - b.x ) * influence;
|
|
|
+ vB.y += ( targets[ face.b ].y - b.y ) * influence;
|
|
|
+ vB.z += ( targets[ face.b ].z - b.z ) * influence;
|
|
|
+
|
|
|
+ vC.x += ( targets[ face.c ].x - c.x ) * influence;
|
|
|
+ vC.y += ( targets[ face.c ].y - c.y ) * influence;
|
|
|
+ vC.z += ( targets[ face.c ].z - c.z ) * influence;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ vA.add( a );
|
|
|
+ vB.add( b );
|
|
|
+ vC.add( c );
|
|
|
+
|
|
|
+ a = vA;
|
|
|
+ b = vB;
|
|
|
+ c = vC;
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( material.side === THREE.BackSide ) {
|
|
|
+
|
|
|
+ var intersectionPoint = ray.intersectTriangle( c, b, a, true );
|
|
|
+
|
|
|
+ } else {
|
|
|
+
|
|
|
+ var intersectionPoint = ray.intersectTriangle( a, b, c, material.side !== THREE.DoubleSide );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ if ( intersectionPoint === null ) continue;
|
|
|
+
|
|
|
+ intersectionPoint.applyMatrix4( this.matrixWorld );
|
|
|
+
|
|
|
+ var distance = raycaster.ray.origin.distanceTo( intersectionPoint );
|
|
|
+
|
|
|
+ if ( distance < precision || distance < raycaster.near || distance > raycaster.far ) continue;
|
|
|
+
|
|
|
+ intersects.push( {
|
|
|
+
|
|
|
+ distance: distance,
|
|
|
+ point: intersectionPoint,
|
|
|
+ face: face,
|
|
|
+ faceIndex: f,
|
|
|
+ object: this
|
|
|
+
|
|
|
+ } );
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ };
|
|
|
+
|
|
|
+}() );
|
|
|
+
|
|
|
THREE.Mesh.prototype.clone = function ( object, recursive ) {
|
|
|
|
|
|
if ( object === undefined ) object = new THREE.Mesh( this.geometry, this.material );
|
Mr.doob