37239732ac
- Globe Asset - Spatial Anchors - Photon Implementation - Scripts for Globe Control and Initial Country Colorizing - Script for Reading csv file
429 lines
10 KiB
C#
429 lines
10 KiB
C#
/* Poly2Tri
|
|
* Copyright (c) 2009-2010, Poly2Tri Contributors
|
|
* http://code.google.com/p/poly2tri/
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* * Neither the name of Poly2Tri nor the names of its contributors may be
|
|
* used to endorse or promote products derived from this software without specific
|
|
* prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
namespace WPM.Poly2Tri {
|
|
public class Point2D : IComparable<Point2D> {
|
|
|
|
protected double mX = 0.0;
|
|
|
|
public virtual double X { get { return mX; } set { mX = value; } }
|
|
|
|
protected double mY = 0.0;
|
|
|
|
public virtual double Y { get { return mY; } set { mY = value; } }
|
|
|
|
protected float mZf = 0.0f; // this is not used by the polygon library but it's useful to conserve the value linked to the point
|
|
|
|
public virtual float Zf { get { return mZf; } set { mZf = value; } }
|
|
|
|
public float Xf { get { return (float)X; } }
|
|
|
|
public float Yf { get { return (float)Y; } }
|
|
|
|
public Point2D () {
|
|
mX = 0.0;
|
|
mY = 0.0;
|
|
mZf = 0.0f;
|
|
}
|
|
|
|
public Point2D (double x, double y) {
|
|
mX = x;
|
|
mY = y;
|
|
mZf = 0;
|
|
}
|
|
|
|
public Point2D (double x, double y, float z) {
|
|
mX = x;
|
|
mY = y;
|
|
mZf = z;
|
|
}
|
|
|
|
public Point2D (Point2D p) {
|
|
mX = p.X;
|
|
mY = p.Y;
|
|
mZf = p.Zf;
|
|
}
|
|
|
|
public override string ToString () {
|
|
return "[" + X.ToString () + "," + Y.ToString () + "," + Zf.ToString() + "]";
|
|
}
|
|
|
|
public override int GetHashCode () {
|
|
return base.GetHashCode ();
|
|
}
|
|
|
|
public override bool Equals (Object obj) {
|
|
Point2D p = obj as Point2D;
|
|
if (p != null) {
|
|
return Equals (p);
|
|
}
|
|
|
|
return base.Equals (obj);
|
|
}
|
|
|
|
public bool Equals (Point2D p) {
|
|
// return Equals (p, 0.0);
|
|
return Equals (p, TriangulationPoint.kVertexCodeDefaultPrecision); // Changed by Kronnect Games
|
|
}
|
|
|
|
public bool Equals (Point2D p, double epsilon) {
|
|
if ((object)p == null || !MathUtil.AreValuesEqual (X, p.X, epsilon) || !MathUtil.AreValuesEqual (Y, p.Y, epsilon)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public int CompareTo (Point2D other) {
|
|
if (Y < other.Y) {
|
|
return -1;
|
|
} else if (Y > other.Y) {
|
|
return 1;
|
|
} else {
|
|
if (X < other.X) {
|
|
return -1;
|
|
} else if (X > other.X) {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
public virtual void Set (double x, double y) {
|
|
X = x;
|
|
Y = y;
|
|
}
|
|
|
|
public virtual void Set (Point2D p) {
|
|
X = p.X;
|
|
Y = p.Y;
|
|
}
|
|
|
|
public void Add (Point2D p) {
|
|
X += p.X;
|
|
Y += p.Y;
|
|
}
|
|
|
|
public void Add (double scalar) {
|
|
X += scalar;
|
|
Y += scalar;
|
|
}
|
|
|
|
public void Subtract (Point2D p) {
|
|
X -= p.X;
|
|
Y -= p.Y;
|
|
}
|
|
|
|
public void Subtract (double scalar) {
|
|
X -= scalar;
|
|
Y -= scalar;
|
|
}
|
|
|
|
public void Multiply (Point2D p) {
|
|
X *= p.X;
|
|
Y *= p.Y;
|
|
}
|
|
|
|
public void Multiply (double scalar) {
|
|
X *= scalar;
|
|
Y *= scalar;
|
|
}
|
|
|
|
public void Divide (Point2D p) {
|
|
X /= p.X;
|
|
Y /= p.Y;
|
|
}
|
|
|
|
public void Divide (double scalar) {
|
|
X /= scalar;
|
|
Y /= scalar;
|
|
}
|
|
|
|
public void Negate () {
|
|
X = -X;
|
|
Y = -Y;
|
|
}
|
|
|
|
public double Magnitude () {
|
|
return Math.Sqrt ((X * X) + (Y * Y));
|
|
}
|
|
|
|
public double MagnitudeSquared () {
|
|
return (X * X) + (Y * Y);
|
|
}
|
|
|
|
public double MagnitudeReciprocal () {
|
|
return 1.0 / Magnitude ();
|
|
}
|
|
|
|
public void Normalize () {
|
|
Multiply (MagnitudeReciprocal ());
|
|
}
|
|
|
|
public double Dot (Point2D p) {
|
|
return (X * p.X) + (Y * p.Y);
|
|
}
|
|
|
|
public double Cross (Point2D p) {
|
|
return (X * p.Y) - (Y * p.X);
|
|
}
|
|
|
|
public void Clamp (Point2D low, Point2D high) {
|
|
X = Math.Max (low.X, Math.Min (X, high.X));
|
|
Y = Math.Max (low.Y, Math.Min (Y, high.Y));
|
|
}
|
|
|
|
public void Abs () {
|
|
X = Math.Abs (X);
|
|
Y = Math.Abs (Y);
|
|
}
|
|
|
|
public void Reciprocal () {
|
|
if (X != 0.0 && Y != 0.0) {
|
|
X = 1.0 / X;
|
|
Y = 1.0 / Y;
|
|
}
|
|
}
|
|
|
|
public void Translate (Point2D vector) {
|
|
Add (vector);
|
|
}
|
|
|
|
public void Translate (double x, double y) {
|
|
X += x;
|
|
Y += y;
|
|
}
|
|
|
|
public void Scale (Point2D vector) {
|
|
Multiply (vector);
|
|
}
|
|
|
|
public void Scale (double scalar) {
|
|
Multiply (scalar);
|
|
}
|
|
|
|
public void Scale (double x, double y) {
|
|
X *= x;
|
|
Y *= y;
|
|
}
|
|
|
|
public void Rotate (double radians) {
|
|
double cosr = Math.Cos (radians);
|
|
double sinr = Math.Sin (radians);
|
|
double xold = X;
|
|
double yold = Y;
|
|
X = (xold * cosr) - (yold * sinr);
|
|
Y = (xold * sinr) + (yold * cosr);
|
|
}
|
|
|
|
public void RotateDegrees (double degrees) {
|
|
double radians = degrees * Math.PI / 180.0;
|
|
Rotate (radians);
|
|
}
|
|
|
|
public static double Dot (Point2D lhs, Point2D rhs) {
|
|
return (lhs.X * rhs.X) + (lhs.Y * rhs.Y);
|
|
}
|
|
|
|
public static double Cross (Point2D lhs, Point2D rhs) {
|
|
return (lhs.X * rhs.Y) - (lhs.Y * rhs.X);
|
|
}
|
|
|
|
public static Point2D Clamp (Point2D a, Point2D low, Point2D high) {
|
|
Point2D p = new Point2D (a);
|
|
p.Clamp (low, high);
|
|
return p;
|
|
}
|
|
|
|
public static Point2D Min (Point2D a, Point2D b) {
|
|
Point2D p = new Point2D ();
|
|
p.X = Math.Min (a.X, b.X);
|
|
p.Y = Math.Min (a.Y, b.Y);
|
|
return p;
|
|
}
|
|
|
|
public static Point2D Max (Point2D a, Point2D b) {
|
|
Point2D p = new Point2D ();
|
|
p.X = Math.Max (a.X, b.X);
|
|
p.Y = Math.Max (a.Y, b.Y);
|
|
return p;
|
|
}
|
|
|
|
public static Point2D Abs (Point2D a) {
|
|
Point2D p = new Point2D (Math.Abs (a.X), Math.Abs (a.Y));
|
|
return p;
|
|
}
|
|
|
|
public static Point2D Reciprocal (Point2D a) {
|
|
Point2D p = new Point2D (1.0 / a.X, 1.0 / a.Y);
|
|
return p;
|
|
}
|
|
|
|
// returns a scaled perpendicular vector. Which direction it goes depends on the order in which the arguments are passed
|
|
public static Point2D Perpendicular (Point2D lhs, double scalar) {
|
|
Point2D p = new Point2D (lhs.Y * scalar, lhs.X * -scalar);
|
|
return p;
|
|
}
|
|
|
|
public static Point2D Perpendicular (double scalar, Point2D rhs) {
|
|
Point2D p = new Point2D (-scalar * rhs.Y, scalar * rhs.X);
|
|
return p;
|
|
}
|
|
|
|
|
|
//
|
|
// operator overloading
|
|
//
|
|
|
|
// Binary Operators
|
|
// Note that in C#, when a binary operator is overloaded, its corresponding compound assignment operator is also automatically
|
|
// overloaded. So, for example, overloading operator + implicitly overloads += as well
|
|
public static Point2D operator + (Point2D lhs, Point2D rhs) {
|
|
Point2D result = new Point2D (lhs);
|
|
result.Add (rhs);
|
|
return result;
|
|
}
|
|
|
|
public static Point2D operator + (Point2D lhs, double scalar) {
|
|
Point2D result = new Point2D (lhs);
|
|
result.Add (scalar);
|
|
return result;
|
|
}
|
|
|
|
public static Point2D operator - (Point2D lhs, Point2D rhs) {
|
|
Point2D result = new Point2D (lhs);
|
|
result.Subtract (rhs);
|
|
return result;
|
|
}
|
|
|
|
public static Point2D operator - (Point2D lhs, double scalar) {
|
|
Point2D result = new Point2D (lhs);
|
|
result.Subtract (scalar);
|
|
return result;
|
|
}
|
|
|
|
public static Point2D operator * (Point2D lhs, Point2D rhs) {
|
|
Point2D result = new Point2D (lhs);
|
|
result.Multiply (rhs);
|
|
return result;
|
|
}
|
|
|
|
public static Point2D operator * (Point2D lhs, double scalar) {
|
|
Point2D result = new Point2D (lhs);
|
|
result.Multiply (scalar);
|
|
return result;
|
|
}
|
|
|
|
public static Point2D operator * (double scalar, Point2D lhs) {
|
|
Point2D result = new Point2D (lhs);
|
|
result.Multiply (scalar);
|
|
return result;
|
|
}
|
|
|
|
public static Point2D operator / (Point2D lhs, Point2D rhs) {
|
|
Point2D result = new Point2D (lhs);
|
|
result.Divide (rhs);
|
|
return result;
|
|
}
|
|
|
|
public static Point2D operator / (Point2D lhs, double scalar) {
|
|
Point2D result = new Point2D (lhs);
|
|
result.Divide (scalar);
|
|
return result;
|
|
}
|
|
|
|
// Unary Operators
|
|
public static Point2D operator - (Point2D p) {
|
|
Point2D tmp = new Point2D (p);
|
|
tmp.Negate ();
|
|
return tmp;
|
|
}
|
|
|
|
// Relational Operators
|
|
//public static bool operator ==(Point2D lhs, Point2D rhs) { if ((object)lhs != null) { return lhs.Equals(rhs, 0.0); } if ((object)rhs == null) { return true; } else { return false; } }
|
|
//public static bool operator !=(Point2D lhs, Point2D rhs) { if ((object)lhs != null) { return !lhs.Equals(rhs, 0.0); } if ((object)rhs == null) { return false; } else { return true; } }
|
|
public static bool operator < (Point2D lhs, Point2D rhs) {
|
|
return (lhs.CompareTo (rhs) == -1) ? true : false;
|
|
}
|
|
|
|
public static bool operator > (Point2D lhs, Point2D rhs) {
|
|
return (lhs.CompareTo (rhs) == 1) ? true : false;
|
|
}
|
|
|
|
public static bool operator <= (Point2D lhs, Point2D rhs) {
|
|
return (lhs.CompareTo (rhs) <= 0) ? true : false;
|
|
}
|
|
|
|
public static bool operator >= (Point2D lhs, Point2D rhs) {
|
|
return (lhs.CompareTo (rhs) >= 0) ? true : false;
|
|
}
|
|
}
|
|
|
|
public class Point2DEnumerator : IEnumerator<Point2D> {
|
|
protected IList<Point2D> mPoints;
|
|
protected int position = -1; // Enumerators are positioned before the first element until the first MoveNext() call.
|
|
int pointCount;
|
|
|
|
public Point2DEnumerator (IList<Point2D> points) {
|
|
mPoints = points;
|
|
pointCount = mPoints.Count;
|
|
}
|
|
|
|
public bool MoveNext () {
|
|
position++;
|
|
return (position < pointCount);
|
|
}
|
|
|
|
public void Reset () {
|
|
position = -1;
|
|
}
|
|
|
|
void IDisposable.Dispose () {
|
|
}
|
|
|
|
Object IEnumerator.Current { get { return Current; } }
|
|
|
|
public Point2D Current {
|
|
get {
|
|
if (position < 0 || position >= pointCount) {
|
|
return null;
|
|
}
|
|
return mPoints [position];
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|