From 2f8d7092bc2c9609fa98d6888106b96f38b22828 Mon Sep 17 00:00:00 2001 From: dan miller Date: Sun, 21 Oct 2007 08:36:32 +0000 Subject: libraries moved to opensim-libs, a new repository --- .../ode-0.9/OPCODE/Ice/IceIndexedTriangle.cpp | 548 --------------------- 1 file changed, 548 deletions(-) delete mode 100644 libraries/ode-0.9/OPCODE/Ice/IceIndexedTriangle.cpp (limited to 'libraries/ode-0.9/OPCODE/Ice/IceIndexedTriangle.cpp') diff --git a/libraries/ode-0.9/OPCODE/Ice/IceIndexedTriangle.cpp b/libraries/ode-0.9/OPCODE/Ice/IceIndexedTriangle.cpp deleted file mode 100644 index db279c4..0000000 --- a/libraries/ode-0.9/OPCODE/Ice/IceIndexedTriangle.cpp +++ /dev/null @@ -1,548 +0,0 @@ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Contains a handy indexed triangle class. - * \file IceIndexedTriangle.cpp - * \author Pierre Terdiman - * \date January, 17, 2000 - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -// Precompiled Header -#include "Stdafx.h" - -using namespace IceMaths; - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Contains an indexed triangle class. - * - * \class Triangle - * \author Pierre Terdiman - * \version 1.0 - * \date 08.15.98 -*/ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Flips the winding order. - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void IndexedTriangle::Flip() -{ - Swap(mVRef[1], mVRef[2]); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the triangle area. - * \param verts [in] the list of indexed vertices - * \return the area - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -float IndexedTriangle::Area(const Point* verts) const -{ - if(!verts) return 0.0f; - const Point& p0 = verts[0]; - const Point& p1 = verts[1]; - const Point& p2 = verts[2]; - return ((p0-p1)^(p0-p2)).Magnitude() * 0.5f; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the triangle perimeter. - * \param verts [in] the list of indexed vertices - * \return the perimeter - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -float IndexedTriangle::Perimeter(const Point* verts) const -{ - if(!verts) return 0.0f; - const Point& p0 = verts[0]; - const Point& p1 = verts[1]; - const Point& p2 = verts[2]; - return p0.Distance(p1) - + p0.Distance(p2) - + p1.Distance(p2); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the triangle compacity. - * \param verts [in] the list of indexed vertices - * \return the compacity - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -float IndexedTriangle::Compacity(const Point* verts) const -{ - if(!verts) return 0.0f; - float P = Perimeter(verts); - if(P==0.0f) return 0.0f; - return (4.0f*PI*Area(verts)/(P*P)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the triangle normal. - * \param verts [in] the list of indexed vertices - * \param normal [out] the computed normal - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void IndexedTriangle::Normal(const Point* verts, Point& normal) const -{ - if(!verts) return; - - const Point& p0 = verts[mVRef[0]]; - const Point& p1 = verts[mVRef[1]]; - const Point& p2 = verts[mVRef[2]]; - normal = ((p2-p1)^(p0-p1)).Normalize(); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the triangle denormalized normal. - * \param verts [in] the list of indexed vertices - * \param normal [out] the computed normal - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void IndexedTriangle::DenormalizedNormal(const Point* verts, Point& normal) const -{ - if(!verts) return; - - const Point& p0 = verts[mVRef[0]]; - const Point& p1 = verts[mVRef[1]]; - const Point& p2 = verts[mVRef[2]]; - normal = ((p2-p1)^(p0-p1)); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the triangle center. - * \param verts [in] the list of indexed vertices - * \param center [out] the computed center - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void IndexedTriangle::Center(const Point* verts, Point& center) const -{ - if(!verts) return; - - const Point& p0 = verts[mVRef[0]]; - const Point& p1 = verts[mVRef[1]]; - const Point& p2 = verts[mVRef[2]]; - center = (p0+p1+p2)*INV3; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the centered normal - * \param verts [in] the list of indexed vertices - * \param normal [out] the computed centered normal - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void IndexedTriangle::CenteredNormal(const Point* verts, Point& normal) const -{ - if(!verts) return; - - const Point& p0 = verts[mVRef[0]]; - const Point& p1 = verts[mVRef[1]]; - const Point& p2 = verts[mVRef[2]]; - Point Center = (p0+p1+p2)*INV3; - normal = Center + ((p2-p1)^(p0-p1)).Normalize(); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes a random point within the triangle. - * \param verts [in] the list of indexed vertices - * \param normal [out] the computed centered normal - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void IndexedTriangle::RandomPoint(const Point* verts, Point& random) const -{ - if(!verts) return; - - // Random barycentric coords - float Alpha = UnitRandomFloat(); - float Beta = UnitRandomFloat(); - float Gamma = UnitRandomFloat(); - float OneOverTotal = 1.0f / (Alpha + Beta + Gamma); - Alpha *= OneOverTotal; - Beta *= OneOverTotal; - Gamma *= OneOverTotal; - - const Point& p0 = verts[mVRef[0]]; - const Point& p1 = verts[mVRef[1]]; - const Point& p2 = verts[mVRef[2]]; - random = Alpha*p0 + Beta*p1 + Gamma*p2; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes backface culling. - * \param verts [in] the list of indexed vertices - * \param source [in] source point (in local space) from which culling must be computed - * \return true if the triangle is visible from the source point - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -bool IndexedTriangle::IsVisible(const Point* verts, const Point& source) const -{ - // Checkings - if(!verts) return false; - - const Point& p0 = verts[mVRef[0]]; - const Point& p1 = verts[mVRef[1]]; - const Point& p2 = verts[mVRef[2]]; - - // Compute denormalized normal - Point Normal = (p2 - p1)^(p0 - p1); - - // Backface culling - return (Normal | source) >= 0.0f; - -// Same as: -// Plane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]); -// return PL.Distance(source) > PL.d; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes backface culling. - * \param verts [in] the list of indexed vertices - * \param source [in] source point (in local space) from which culling must be computed - * \return true if the triangle is visible from the source point - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -bool IndexedTriangle::BackfaceCulling(const Point* verts, const Point& source) const -{ - // Checkings - if(!verts) return false; - - const Point& p0 = verts[mVRef[0]]; - const Point& p1 = verts[mVRef[1]]; - const Point& p2 = verts[mVRef[2]]; - - // Compute base -// Point Base = (p0 + p1 + p2)*INV3; - - // Compute denormalized normal - Point Normal = (p2 - p1)^(p0 - p1); - - // Backface culling -// return (Normal | (source - Base)) >= 0.0f; - return (Normal | (source - p0)) >= 0.0f; - -// Same as: (but a bit faster) -// Plane PL(verts[mVRef[0]], verts[mVRef[1]], verts[mVRef[2]]); -// return PL.Distance(source)>0.0f; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the occlusion potential of the triangle. - * \param verts [in] the list of indexed vertices - * \param source [in] source point (in local space) from which occlusion potential must be computed - * \return the occlusion potential - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -float IndexedTriangle::ComputeOcclusionPotential(const Point* verts, const Point& view) const -{ - if(!verts) return 0.0f; - // Occlusion potential: -(A * (N|V) / d^2) - // A = polygon area - // N = polygon normal - // V = view vector - // d = distance viewpoint-center of polygon - - float A = Area(verts); - Point N; Normal(verts, N); - Point C; Center(verts, C); - float d = view.Distance(C); - return -(A*(N|view))/(d*d); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Replaces a vertex reference with another one. - * \param oldref [in] the vertex reference to replace - * \param newref [in] the new vertex reference - * \return true if success, else false if the input vertex reference doesn't belong to the triangle - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -bool IndexedTriangle::ReplaceVertex(udword oldref, udword newref) -{ - if(mVRef[0]==oldref) { mVRef[0] = newref; return true; } - else if(mVRef[1]==oldref) { mVRef[1] = newref; return true; } - else if(mVRef[2]==oldref) { mVRef[2] = newref; return true; } - return false; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Checks whether the triangle is degenerate or not. A degenerate triangle has two common vertex references. This is a zero-area triangle. - * \return true if the triangle is degenerate - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -bool IndexedTriangle::IsDegenerate() const -{ - if(mVRef[0]==mVRef[1]) return true; - if(mVRef[1]==mVRef[2]) return true; - if(mVRef[2]==mVRef[0]) return true; - return false; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Checks whether the input vertex reference belongs to the triangle or not. - * \param ref [in] the vertex reference to look for - * \return true if the triangle contains the vertex reference - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -bool IndexedTriangle::HasVertex(udword ref) const -{ - if(mVRef[0]==ref) return true; - if(mVRef[1]==ref) return true; - if(mVRef[2]==ref) return true; - return false; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Checks whether the input vertex reference belongs to the triangle or not. - * \param ref [in] the vertex reference to look for - * \param index [out] the corresponding index in the triangle - * \return true if the triangle contains the vertex reference - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -bool IndexedTriangle::HasVertex(udword ref, udword* index) const -{ - if(mVRef[0]==ref) { *index = 0; return true; } - if(mVRef[1]==ref) { *index = 1; return true; } - if(mVRef[2]==ref) { *index = 2; return true; } - return false; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Finds an edge in a tri, given two vertex references. - * \param vref0 [in] the edge's first vertex reference - * \param vref1 [in] the edge's second vertex reference - * \return the edge number between 0 and 2, or 0xff if input refs are wrong. - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -ubyte IndexedTriangle::FindEdge(udword vref0, udword vref1) const -{ - if(mVRef[0]==vref0 && mVRef[1]==vref1) return 0; - else if(mVRef[0]==vref1 && mVRef[1]==vref0) return 0; - else if(mVRef[0]==vref0 && mVRef[2]==vref1) return 1; - else if(mVRef[0]==vref1 && mVRef[2]==vref0) return 1; - else if(mVRef[1]==vref0 && mVRef[2]==vref1) return 2; - else if(mVRef[1]==vref1 && mVRef[2]==vref0) return 2; - return 0xff; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Gets the last reference given the first two. - * \param vref0 [in] the first vertex reference - * \param vref1 [in] the second vertex reference - * \return the last reference, or INVALID_ID if input refs are wrong. - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -udword IndexedTriangle::OppositeVertex(udword vref0, udword vref1) const -{ - if(mVRef[0]==vref0 && mVRef[1]==vref1) return mVRef[2]; - else if(mVRef[0]==vref1 && mVRef[1]==vref0) return mVRef[2]; - else if(mVRef[0]==vref0 && mVRef[2]==vref1) return mVRef[1]; - else if(mVRef[0]==vref1 && mVRef[2]==vref0) return mVRef[1]; - else if(mVRef[1]==vref0 && mVRef[2]==vref1) return mVRef[0]; - else if(mVRef[1]==vref1 && mVRef[2]==vref0) return mVRef[0]; - return INVALID_ID; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Gets the three sorted vertex references according to an edge number. - * edgenb = 0 => edge 0-1, returns references 0, 1, 2 - * edgenb = 1 => edge 0-2, returns references 0, 2, 1 - * edgenb = 2 => edge 1-2, returns references 1, 2, 0 - * - * \param edgenb [in] the edge number, 0, 1 or 2 - * \param vref0 [out] the returned first vertex reference - * \param vref1 [out] the returned second vertex reference - * \param vref2 [out] the returned third vertex reference - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void IndexedTriangle::GetVRefs(ubyte edgenb, udword& vref0, udword& vref1, udword& vref2) const -{ - if(edgenb==0) - { - vref0 = mVRef[0]; - vref1 = mVRef[1]; - vref2 = mVRef[2]; - } - else if(edgenb==1) - { - vref0 = mVRef[0]; - vref1 = mVRef[2]; - vref2 = mVRef[1]; - } - else if(edgenb==2) - { - vref0 = mVRef[1]; - vref1 = mVRef[2]; - vref2 = mVRef[0]; - } -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the triangle's smallest edge length. - * \param verts [in] the list of indexed vertices - * \return the smallest edge length - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -float IndexedTriangle::MinEdgeLength(const Point* verts) const -{ - if(!verts) return 0.0f; - - float Min = MAX_FLOAT; - float Length01 = verts[0].Distance(verts[1]); - float Length02 = verts[0].Distance(verts[2]); - float Length12 = verts[1].Distance(verts[2]); - if(Length01 < Min) Min = Length01; - if(Length02 < Min) Min = Length02; - if(Length12 < Min) Min = Length12; - return Min; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the triangle's largest edge length. - * \param verts [in] the list of indexed vertices - * \return the largest edge length - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -float IndexedTriangle::MaxEdgeLength(const Point* verts) const -{ - if(!verts) return 0.0f; - - float Max = MIN_FLOAT; - float Length01 = verts[0].Distance(verts[1]); - float Length02 = verts[0].Distance(verts[2]); - float Length12 = verts[1].Distance(verts[2]); - if(Length01 > Max) Max = Length01; - if(Length02 > Max) Max = Length02; - if(Length12 > Max) Max = Length12; - return Max; -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes a point on the triangle according to the stabbing information. - * \param verts [in] the list of indexed vertices - * \param u,v [in] point's barycentric coordinates - * \param pt [out] point on triangle - * \param nearvtx [out] index of nearest vertex - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -void IndexedTriangle::ComputePoint(const Point* verts, float u, float v, Point& pt, udword* nearvtx) const -{ - // Checkings - if(!verts) return; - - // Get face in local or global space - const Point& p0 = verts[mVRef[0]]; - const Point& p1 = verts[mVRef[1]]; - const Point& p2 = verts[mVRef[2]]; - - // Compute point coordinates - pt = (1.0f - u - v)*p0 + u*p1 + v*p2; - - // Compute nearest vertex if needed - if(nearvtx) - { - // Compute distance vector - Point d(p0.SquareDistance(pt), // Distance^2 from vertex 0 to point on the face - p1.SquareDistance(pt), // Distance^2 from vertex 1 to point on the face - p2.SquareDistance(pt)); // Distance^2 from vertex 2 to point on the face - - // Get smallest distance - *nearvtx = mVRef[d.SmallestAxis()]; - } -} - - //************************************** - // Angle between two vectors (in radians) - // we use this formula - // uv = |u||v| cos(u,v) - // u ^ v = w - // |w| = |u||v| |sin(u,v)| - //************************************** - float Angle(const Point& u, const Point& v) - { - float NormU = u.Magnitude(); // |u| - float NormV = v.Magnitude(); // |v| - float Product = NormU*NormV; // |u||v| - if(Product==0.0f) return 0.0f; - float OneOverProduct = 1.0f / Product; - - // Cosinus - float Cosinus = (u|v) * OneOverProduct; - - // Sinus - Point w = u^v; - float NormW = w.Magnitude(); - - float AbsSinus = NormW * OneOverProduct; - - // Remove degeneracy - if(AbsSinus > 1.0f) AbsSinus = 1.0f; - if(AbsSinus < -1.0f) AbsSinus = -1.0f; - - if(Cosinus>=0.0f) return asinf(AbsSinus); - else return (PI-asinf(AbsSinus)); - } - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Computes the angle between two triangles. - * \param tri [in] the other triangle - * \param verts [in] the list of indexed vertices - * \return the angle in radians - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -float IndexedTriangle::Angle(const IndexedTriangle& tri, const Point* verts) const -{ - // Checkings - if(!verts) return 0.0f; - - // Compute face normals - Point n0, n1; - Normal(verts, n0); - tri.Normal(verts, n1); - - // Compute angle - float dp = n0|n1; - if(dp>1.0f) return 0.0f; - if(dp<-1.0f) return PI; - return acosf(dp); - -// return ::Angle(n0,n1); -} - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -/** - * Checks a triangle is the same as another one. - * \param tri [in] the other triangle - * \return true if same triangle - */ -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// -bool IndexedTriangle::Equal(const IndexedTriangle& tri) const -{ - // Test all vertex references - return (HasVertex(tri.mVRef[0]) && - HasVertex(tri.mVRef[1]) && - HasVertex(tri.mVRef[2])); -} -- cgit v1.1