OpenSimMirror/addon-modules/ConvexDecompositionDotNet/float3.cs

/* The MIT License
 * 
 * Copyright (c) 2010 Intel Corporation.
 * All rights reserved.
 *
 * Based on the convexdecomposition library from 
 * <http://codesuppository.googlecode.com> by John W. Ratcliff and Stan Melax.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

using System;

namespace OpenSim.Region.Physics.ConvexDecompositionDotNet
{
    public class float3 : IEquatable<float3>
    {
        public float x;
        public float y;
        public float z;

        public float3()
        {
            x = 0;
            y = 0;
            z = 0;
        }

        public float3(float _x, float _y, float _z)
        {
            x = _x;
            y = _y;
            z = _z;
        }

        public float3(float3 f)
        {
            x = f.x;
            y = f.y;
            z = f.z;
        }

        public float this[int i]
        {
            get
            {
                switch (i)
                {
                    case 0: return x;
                    case 1: return y;
                    case 2: return z;
                }
                throw new ArgumentOutOfRangeException();
            }
        }

        public float Distance(float3 a)
        {
            float3 d = new float3(a.x - x, a.y - y, a.z - z);
            return d.Length();
        }

        public float Distance2(float3 a)
        {
            float dx = a.x - x;
            float dy = a.y - y;
            float dz = a.z - z;
            return dx * dx + dy * dy + dz * dz;
        }

        public float Length()
        {
            return (float)Math.Sqrt(x * x + y * y + z * z);
        }

        public float Area(float3 p1, float3 p2)
        {
            float A = Partial(p1);
            A += p1.Partial(p2);
            A += p2.Partial(this);
            return A * 0.5f;
        }

        public float Partial(float3 p)
        {
            return (x * p.y) - (p.x * y);
        }

        // Given a point and a line (defined by two points), compute the closest point
        // in the line.  (The line is treated as infinitely long.)
        public void NearestPointInLine(float3 point, float3 line0, float3 line1)
        {
            float3 nearestPoint = new float3();
            float3 lineDelta = line1 - line0;

            // Handle degenerate lines
            if (lineDelta == float3.Zero)
            {
                nearestPoint = line0;
            }
            else
            {
                float delta = float3.dot(point - line0, lineDelta) / float3.dot(lineDelta, lineDelta);
                nearestPoint = line0 + lineDelta * delta;
            }

            this.x = nearestPoint.x;
            this.y = nearestPoint.y;
            this.z = nearestPoint.z;
        }

        // Given a point and a line segment (defined by two points), compute the closest point
        // in the line.  Cap the point at the endpoints of the line segment.
        public void NearestPointInLineSegment(float3 point, float3 line0, float3 line1)
        {
            float3 nearestPoint = new float3();
            float3 lineDelta = line1 - line0;

            // Handle degenerate lines
            if (lineDelta == Zero)
            {
                nearestPoint = line0;
            }
            else
            {
                float delta = float3.dot(point - line0, lineDelta) / float3.dot(lineDelta, lineDelta);

                // Clamp the point to conform to the segment's endpoints
                if (delta < 0)
                    delta = 0;
                else if (delta > 1)
                    delta = 1;

                nearestPoint = line0 + lineDelta * delta;
            }

            this.x = nearestPoint.x;
            this.y = nearestPoint.y;
            this.z = nearestPoint.z;
        }

        // Given a point and a triangle (defined by three points), compute the closest point
        // in the triangle.  Clamp the point so it's confined to the area of the triangle.
        public void NearestPointInTriangle(float3 point, float3 triangle0, float3 triangle1, float3 triangle2)
        {
            float3 nearestPoint = new float3();

            float3 lineDelta0 = triangle1 - triangle0;
            float3 lineDelta1 = triangle2 - triangle0;

            // Handle degenerate triangles
            if ((lineDelta0 == Zero) || (lineDelta1 == Zero))
            {
                nearestPoint.NearestPointInLineSegment(point, triangle1, triangle2);
            }
            else if (lineDelta0 == lineDelta1)
            {
                nearestPoint.NearestPointInLineSegment(point, triangle0, triangle1);
            }
            else
            {
                float3[] axis = new float3[3] { new float3(), new float3(), new float3() };
                axis[0].NearestPointInLine(triangle0, triangle1, triangle2);
                axis[1].NearestPointInLine(triangle1, triangle0, triangle2);
                axis[2].NearestPointInLine(triangle2, triangle0, triangle1);

                float3 axisDot = new float3();
                axisDot.x = dot(triangle0 - axis[0], point - axis[0]);
                axisDot.y = dot(triangle1 - axis[1], point - axis[1]);
                axisDot.z = dot(triangle2 - axis[2], point - axis[2]);

                bool bForce = true;
                float bestMagnitude2 = 0;
                float closeMagnitude2;
                float3 closePoint = new float3();

                if (axisDot.x < 0f)
                {
                    closePoint.NearestPointInLineSegment(point, triangle1, triangle2);
                    closeMagnitude2 = point.Distance2(closePoint);
                    if (bForce || (bestMagnitude2 > closeMagnitude2))
                    {
                        bForce = false;
                        bestMagnitude2 = closeMagnitude2;
                        nearestPoint = closePoint;
                    }
                }
                if (axisDot.y < 0f)
                {
                    closePoint.NearestPointInLineSegment(point, triangle0, triangle2);
                    closeMagnitude2 = point.Distance2(closePoint);
                    if (bForce || (bestMagnitude2 > closeMagnitude2))
                    {
                        bForce = false;
                        bestMagnitude2 = closeMagnitude2;
                        nearestPoint = closePoint;
                    }
                }
                if (axisDot.z < 0f)
                {
                    closePoint.NearestPointInLineSegment(point, triangle0, triangle1);
                    closeMagnitude2 = point.Distance2(closePoint);
                    if (bForce || (bestMagnitude2 > closeMagnitude2))
                    {
                        bForce = false;
                        bestMagnitude2 = closeMagnitude2;
                        nearestPoint = closePoint;
                    }
                }

                // If bForce is true at this point, it means the nearest point lies
                // inside the triangle; use the nearest-point-on-a-plane equation
                if (bForce)
                {
                    float3 normal;

                    // Get the normal of the polygon (doesn't have to be a unit vector)
                    normal = float3.cross(lineDelta0, lineDelta1);

                    float3 pointDelta = point - triangle0;
                    float delta = float3.dot(normal, pointDelta) / float3.dot(normal, normal);

                    nearestPoint = point - normal * delta;
                }
            }

            this.x = nearestPoint.x;
            this.y = nearestPoint.y;
            this.z = nearestPoint.z;
        }

        public static float3 operator +(float3 a, float3 b)
        {
            return new float3(a.x + b.x, a.y + b.y, a.z + b.z);
        }

        public static float3 operator -(float3 a, float3 b)
        {
            return new float3(a.x - b.x, a.y - b.y, a.z - b.z);
        }

        public static float3 operator -(float3 a, float s)
        {
            return new float3(a.x - s, a.y - s, a.z - s);
        }

        public static float3 operator -(float3 v)
        {
            return new float3(-v.x, -v.y, -v.z);
        }

        public static float3 operator *(float3 v, float s)
        {
            return new float3(v.x * s, v.y * s, v.z * s);
        }

        public static float3 operator *(float s, float3 v)
        {
            return new float3(v.x * s, v.y * s, v.z * s);
        }

        public static float3 operator *(float3 v, float3x3 m)
        {
            return new float3((m.x.x * v.x + m.y.x * v.y + m.z.x * v.z), (m.x.y * v.x + m.y.y * v.y + m.z.y * v.z), (m.x.z * v.x + m.y.z * v.y + m.z.z * v.z));
        }

        public static float3 operator *(float3x3 m, float3 v)
        {
            return new float3(dot(m.x, v), dot(m.y, v), dot(m.z, v));
        }

        public static float3 operator /(float3 v, float s)
        {
            float sinv = 1.0f / s;
            return new float3(v.x * sinv, v.y * sinv, v.z * sinv);
        }

        public bool Equals(float3 other)
        {
            return this == other;
        }

        public override bool Equals(object obj)
        {
            float3 f = obj as float3;
            if (f == null)
                return false;

            return this == f;
        }

        public override int GetHashCode()
        {
            return x.GetHashCode() ^ y.GetHashCode() ^ z.GetHashCode();
        }

        public static bool operator ==(float3 a, float3 b)
        {
            // If both are null, or both are same instance, return true.
            if (System.Object.ReferenceEquals(a, b))
                return true;
            // If one is null, but not both, return false.
            if (((object)a == null) || ((object)b == null))
                return false;

            return (a.x == b.x && a.y == b.y && a.z == b.z);
        }

        public static bool operator !=(float3 a, float3 b)
        {
            return (a.x != b.x || a.y != b.y || a.z != b.z);
        }

        public static float dot(float3 a, float3 b)
        {
            return a.x * b.x + a.y * b.y + a.z * b.z;
        }

        public static float3 cmul(float3 v1, float3 v2)
        {
            return new float3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
        }

        public static float3 cross(float3 a, float3 b)
        {
            return new float3(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
        }

        public static float3 Interpolate(float3 v0, float3 v1, float alpha)
        {
            return v0 * (1 - alpha) + v1 * alpha;
        }

        public static float3 Round(float3 a, int digits)
        {
            return new float3((float)Math.Round(a.x, digits), (float)Math.Round(a.y, digits), (float)Math.Round(a.z, digits));
        }

        public static float3 VectorMax(float3 a, float3 b)
        {
            return new float3(Math.Max(a.x, b.x), Math.Max(a.y, b.y), Math.Max(a.z, b.z));
        }

        public static float3 VectorMin(float3 a, float3 b)
        {
            return new float3(Math.Min(a.x, b.x), Math.Min(a.y, b.y), Math.Min(a.z, b.z));
        }

        public static float3 vabs(float3 v)
        {
            return new float3(Math.Abs(v.x), Math.Abs(v.y), Math.Abs(v.z));
        }

        public static float magnitude(float3 v)
        {
            return (float)Math.Sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
        }

        public static float3 normalize(float3 v)
        {
            float d = magnitude(v);
            if (d == 0)
                d = 0.1f;
            d = 1 / d;
            return new float3(v.x * d, v.y * d, v.z * d);
        }

        public static float3 safenormalize(float3 v)
        {
            if (magnitude(v) <= 0.0f)
                return new float3(1, 0, 0);
            else
                return normalize(v);
        }

        public static float Yaw(float3 v)
        {
            return (v.y == 0.0 && v.x == 0.0) ? 0.0f : (float)Math.Atan2(-v.x, v.y) * (180.0f / 3.14159264f);
        }

        public static float Pitch(float3 v)
        {
            return (float)Math.Atan2(v.z, Math.Sqrt(v.x * v.x + v.y * v.y)) * (180.0f / 3.14159264f);
        }

        public float ComputePlane(float3 A, float3 B, float3 C)
        {
            float vx, vy, vz, wx, wy, wz, vw_x, vw_y, vw_z, mag;

            vx = (B.x - C.x);
            vy = (B.y - C.y);
            vz = (B.z - C.z);

            wx = (A.x - B.x);
            wy = (A.y - B.y);
            wz = (A.z - B.z);

            vw_x = vy * wz - vz * wy;
            vw_y = vz * wx - vx * wz;
            vw_z = vx * wy - vy * wx;

            mag = (float)Math.Sqrt((vw_x * vw_x) + (vw_y * vw_y) + (vw_z * vw_z));

            if (mag < 0.000001f)
            {
                mag = 0;
            }
            else
            {
                mag = 1.0f / mag;
            }

            x = vw_x * mag;
            y = vw_y * mag;
            z = vw_z * mag;

            float D = 0.0f - ((x * A.x) + (y * A.y) + (z * A.z));
            return D;
        }

        public override string ToString()
        {
            return String.Format("<{0}, {1}, {2}>", x, y, z);
        }

        public static readonly float3 Zero = new float3();
    }
}