diff options
Diffstat (limited to 'indra/llmath/llline.cpp')
| -rw-r--r-- | indra/llmath/llline.cpp | 220 |
1 files changed, 110 insertions, 110 deletions
diff --git a/indra/llmath/llline.cpp b/indra/llmath/llline.cpp index cfee315b55..70c68dd42f 100644 --- a/indra/llmath/llline.cpp +++ b/indra/llmath/llline.cpp @@ -1,4 +1,4 @@ -/** +/** * @file llline.cpp * @author Andrew Meadows * @brief Simple line class that can compute nearest approach between two lines @@ -6,21 +6,21 @@ * $LicenseInfo:firstyear=2006&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. - * + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; * version 2.1 of the License only. - * + * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. - * + * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * + * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ @@ -33,87 +33,87 @@ const F32 SOME_VERY_SMALL_NUMBER = 1.0e-8f; LLLine::LLLine() -: mPoint(0.f, 0.f, 0.f), - mDirection(1.f, 0.f, 0.f) +: mPoint(0.f, 0.f, 0.f), + mDirection(1.f, 0.f, 0.f) { } LLLine::LLLine( const LLVector3& first_point, const LLVector3& second_point ) { - setPoints(first_point, second_point); + setPoints(first_point, second_point); } void LLLine::setPoints( const LLVector3& first_point, const LLVector3& second_point ) { - mPoint = first_point; - mDirection = second_point - first_point; - mDirection.normalize(); + mPoint = first_point; + mDirection = second_point - first_point; + mDirection.normalize(); } void LLLine::setPointDirection( const LLVector3& first_point, const LLVector3& second_point ) { - setPoints(first_point, first_point + second_point); + setPoints(first_point, first_point + second_point); } bool LLLine::intersects( const LLVector3& point, F32 radius ) const { - LLVector3 other_direction = point - mPoint; - LLVector3 nearest_point = mPoint + mDirection * (other_direction * mDirection); - F32 nearest_approach = (nearest_point - point).length(); - return (nearest_approach <= radius); + LLVector3 other_direction = point - mPoint; + LLVector3 nearest_point = mPoint + mDirection * (other_direction * mDirection); + F32 nearest_approach = (nearest_point - point).length(); + return (nearest_approach <= radius); } // returns the point on this line that is closest to some_point LLVector3 LLLine::nearestApproach( const LLVector3& some_point ) const { - return (mPoint + mDirection * ((some_point - mPoint) * mDirection)); + return (mPoint + mDirection * ((some_point - mPoint) * mDirection)); } // the accuracy of this method sucks when you give it two nearly // parallel lines, so you should probably check for parallelism // before you call this -// +// // returns the point on this line that is closest to other_line LLVector3 LLLine::nearestApproach( const LLLine& other_line ) const { - LLVector3 between_points = other_line.mPoint - mPoint; - F32 dir_dot_dir = mDirection * other_line.mDirection; - F32 one_minus_dir_dot_dir = 1.0f - fabs(dir_dot_dir); - if ( one_minus_dir_dot_dir < SOME_VERY_SMALL_NUMBER ) - { + LLVector3 between_points = other_line.mPoint - mPoint; + F32 dir_dot_dir = mDirection * other_line.mDirection; + F32 one_minus_dir_dot_dir = 1.0f - fabs(dir_dot_dir); + if ( one_minus_dir_dot_dir < SOME_VERY_SMALL_NUMBER ) + { #ifdef LL_DEBUG - LL_WARNS() << "LLLine::nearestApproach() was given two very " - << "nearly parallel lines dir1 = " << mDirection - << " dir2 = " << other_line.mDirection << " with 1-dot_product = " - << one_minus_dir_dot_dir << LL_ENDL; + LL_WARNS() << "LLLine::nearestApproach() was given two very " + << "nearly parallel lines dir1 = " << mDirection + << " dir2 = " << other_line.mDirection << " with 1-dot_product = " + << one_minus_dir_dot_dir << LL_ENDL; #endif - // the lines are approximately parallel - // We shouldn't fall in here because this check should have been made - // BEFORE this function was called. We dare not continue with the - // computations for fear of division by zero, but we have to return - // something so we return a bogus point -- caller beware. - return 0.5f * (mPoint + other_line.mPoint); - } - - F32 odir_dot_bp = other_line.mDirection * between_points; - - F32 numerator = 0; - F32 denominator = 0; - for (S32 i=0; i<3; i++) - { - F32 factor = dir_dot_dir * other_line.mDirection.mV[i] - mDirection.mV[i]; - numerator += ( between_points.mV[i] - odir_dot_bp * other_line.mDirection.mV[i] ) * factor; - denominator -= factor * factor; - } - - F32 length_to_nearest_approach = numerator / denominator; - - return mPoint + length_to_nearest_approach * mDirection; + // the lines are approximately parallel + // We shouldn't fall in here because this check should have been made + // BEFORE this function was called. We dare not continue with the + // computations for fear of division by zero, but we have to return + // something so we return a bogus point -- caller beware. + return 0.5f * (mPoint + other_line.mPoint); + } + + F32 odir_dot_bp = other_line.mDirection * between_points; + + F32 numerator = 0; + F32 denominator = 0; + for (S32 i=0; i<3; i++) + { + F32 factor = dir_dot_dir * other_line.mDirection.mV[i] - mDirection.mV[i]; + numerator += ( between_points.mV[i] - odir_dot_bp * other_line.mDirection.mV[i] ) * factor; + denominator -= factor * factor; + } + + F32 length_to_nearest_approach = numerator / denominator; + + return mPoint + length_to_nearest_approach * mDirection; } std::ostream& operator<<( std::ostream& output_stream, const LLLine& line ) { - output_stream << "{point=" << line.mPoint << "," << "dir=" << line.mDirection << "}"; - return output_stream; + output_stream << "{point=" << line.mPoint << "," << "dir=" << line.mDirection << "}"; + return output_stream; } @@ -124,72 +124,72 @@ F32 TOO_SMALL_FOR_DIVISION = 0.0001f; // on success stores the intersection point in 'result' bool LLLine::intersectsPlane( LLVector3& result, const LLLine& plane ) const { - // p = P + l * d equation for a line - // - // N * p = D equation for a point - // - // N * (P + l * d) = D - // N*P + l * (N*d) = D - // l * (N*d) = D - N*P - // l = ( D - N*P ) / ( N*d ) - // - - F32 dot = plane.mDirection * mDirection; - if (fabs(dot) < TOO_SMALL_FOR_DIVISION) - { - return false; - } - - F32 plane_dot = plane.mDirection * plane.mPoint; - F32 length = ( plane_dot - (plane.mDirection * mPoint) ) / dot; - result = mPoint + length * mDirection; - return true; + // p = P + l * d equation for a line + // + // N * p = D equation for a point + // + // N * (P + l * d) = D + // N*P + l * (N*d) = D + // l * (N*d) = D - N*P + // l = ( D - N*P ) / ( N*d ) + // + + F32 dot = plane.mDirection * mDirection; + if (fabs(dot) < TOO_SMALL_FOR_DIVISION) + { + return false; + } + + F32 plane_dot = plane.mDirection * plane.mPoint; + F32 length = ( plane_dot - (plane.mDirection * mPoint) ) / dot; + result = mPoint + length * mDirection; + return true; } -//static -// returns 'true' if planes intersect, and stores the result +//static +// returns 'true' if planes intersect, and stores the result // the second and third arguments are treated as planes // where mPoint is on the plane and mDirection is the normal -// result.mPoint will be the intersection line's closest approach +// result.mPoint will be the intersection line's closest approach // to first_plane.mPoint bool LLLine::getIntersectionBetweenTwoPlanes( LLLine& result, const LLLine& first_plane, const LLLine& second_plane ) { - // TODO -- if we ever get some generic matrix solving code in our libs - // then we should just use that, since this problem is really just - // linear algebra. - - F32 dot = fabs(first_plane.mDirection * second_plane.mDirection); - if (dot > ALMOST_PARALLEL) - { - // the planes are nearly parallel - return false; - } - - LLVector3 direction = first_plane.mDirection % second_plane.mDirection; - direction.normalize(); - - LLVector3 first_intersection; - { - LLLine intersection_line(first_plane); - intersection_line.mDirection = direction % first_plane.mDirection; - intersection_line.mDirection.normalize(); - intersection_line.intersectsPlane(first_intersection, second_plane); - } - - /* - LLVector3 second_intersection; - { - LLLine intersection_line(second_plane); - intersection_line.mDirection = direction % second_plane.mDirection; - intersection_line.mDirection.normalize(); - intersection_line.intersectsPlane(second_intersection, first_plane); - } - */ - - result.mPoint = first_intersection; - result.mDirection = direction; - - return true; + // TODO -- if we ever get some generic matrix solving code in our libs + // then we should just use that, since this problem is really just + // linear algebra. + + F32 dot = fabs(first_plane.mDirection * second_plane.mDirection); + if (dot > ALMOST_PARALLEL) + { + // the planes are nearly parallel + return false; + } + + LLVector3 direction = first_plane.mDirection % second_plane.mDirection; + direction.normalize(); + + LLVector3 first_intersection; + { + LLLine intersection_line(first_plane); + intersection_line.mDirection = direction % first_plane.mDirection; + intersection_line.mDirection.normalize(); + intersection_line.intersectsPlane(first_intersection, second_plane); + } + + /* + LLVector3 second_intersection; + { + LLLine intersection_line(second_plane); + intersection_line.mDirection = direction % second_plane.mDirection; + intersection_line.mDirection.normalize(); + intersection_line.intersectsPlane(second_intersection, first_plane); + } + */ + + result.mPoint = first_intersection; + result.mDirection = direction; + + return true; } |