std.geometry.library.plato

library Geometry
{
	Implicit(x: Point2D): Point3D
		=> (x.X, x.Y, 0.0);

	Implicit(x: Point2D): Vector3D
		=> (x.X, x.Y, 0.0);

	Implicit(x: Point2D): Vector2D
		=> (x.X, x.Y);

	Implicit(x: Vector2D): Point2D
		=> (x.X, x.Y);

	Implicit(x: Vector3D): Point3D
		=> (x.X, x.Y, x.Z);

	Implicit(x: Point3D): Vector3D
		=> (x.X, x.Y, x.Z);

	Implicit(x: Vector4D): Point4D
		=> (x.X, x.Y, x.Z, x.W);

	Implicit(x: Point4D): Vector4D
		=> (x.X, x.Y, x.Z, x.W);

	Deform(x: Point3D, f: Function1<Vector3D, Vector3D>): Point3D
		=> f(x);

	Deform(x: Point2D, f: Function1<Vector3D, Vector3D>): Point3D
		=> f(x);

	Transform(x: Deformable3D, m: Matrix3D): Deformable3D
		=> x.Deform(v => m * v);

	Closed(x: Line2D): Boolean
		=> false;

	Closed(x: Line3D): Boolean
		=> false;

	Closed(x: ClosedShape2D): Boolean
		=> true;

	Closed(x: ClosedShape3D): Boolean
		=> true;

	Closed(x: OpenShape2D): Boolean
		=> false;

	// TODO: move these function out

	Turns(x: Number): Angle
		=> x;

	FloatDivision(x: Integer, y: Integer): Number
		=> x.ToNumber / y.ToNumber;

	Fractions(x: Integer): Array<Number>
		=> x.Range.Map((i) => i.FloatDivision(x));

	CirclePoints(n: Integer): Array<Point2D>
		=> n.Fractions.Map((x) => x.Circle);

	Points(x: RegularPolygon): Array<Point2D>
		=> x.NumPoints.CirclePoints;

	Points(x: Line3D): Array<Point3D>
		=> x;

	Closed(x: Ellipse): Boolean
		=> true;

	Eval(x: Ellipse, t: Number): Point2D
		=> t.Turns.CirclePoint.ToVector * x.Size + x.Center;

	Closed(x: Polygon2D): Boolean
		=> true;

	Closed(x: Polygon3D): Boolean
		=> true;

	ToVector(a: Point3D): Vector3D
		=> a;

	Add(a: Point3D, b: Vector3D): Point3D
		=> a.ToVector + b;

	Subtract(a: Point3D, b: Vector3D): Point3D
		=> a.ToVector - b;

	Subtract(a: Point3D, b: Point3D): Vector3D
		=> a.ToVector - b.ToVector;

	ToVector(a: Point2D): Vector2D
		=> a;

	Implicit(a: Size2D): Vector2D
		=> (a.Width, a.Height);

	Add(a: Point2D, b: Vector2D): Point2D
		=> a.ToVector + b;

	Subtract(a: Point2D, b: Vector2D): Point2D
		=> a.ToVector - b;

	Subtract(a: Point2D, b: Point2D): Vector2D
		=> a.ToVector - b.ToVector;

	ToVector(a: Point4D): Vector4D
		=> a;

	Add(a: Point4D, b: Vector4D): Point4D
		=> a.ToVector+ b;

	Subtract(a: Point4D, b: Vector4D): Point4D
		=> a.ToVector - b;

	Subtract(a: Point4D, b: Point4D): Vector4D
		=> a.ToVector - b.ToVector;

	Points(x: Line2D): Array<Point2D>
		=> x;

	Points(x: Triangle2D): Array<Point2D>
		=> CirclePoints(3);

	Width(x: Rect2D): Number
		=> x.Size.Width;

	Height(x: Rect2D): Number
		=> x.Size.Height;

	HalfWidth(x: Rect2D): Number
		=> x.Width.Half;

	HalfHeight(x: Rect2D): Number
		=> x.Height.Half;

	Top(x: Rect2D): Number
		=> x.Center.Y + HalfHeight;

	Bottom(x: Rect2D): Number
		=> x.Top + x.Height;

	Left(x: Rect2D): Number
		=> x.Center.X - HalfWidth;

	Right(x: Rect2D): Number
		=> x.Left + x.Width;

	TopLeft(x: Rect2D): Point2D
		=> (x.Left, x.Top);

	TopRight(x: Rect2D): Point2D
		=> (x.Right, x.Top);

	BottomRight(x: Rect2D): Point2D
		=> (x.Right, x.Bottom);

	BottomLeft(x: Rect2D): Point2D
		=> (x.Left, x.Bottom);

	Points(x: Rect2D): Array<Point2D>
		=> [x.TopLeft, x.TopRight, x.BottomRight, x.BottomLeft];
}