Moved Stars45 to StarsEx

1 files changed, 0 insertions, 303 deletions

diff --git a/Stars45/Geometry.h b/Stars45/Geometry.h
deleted file mode 100644
index 7170c6c..0000000
--- a/Stars45/Geometry.h
+++ /dev/null
@@ -1,303 +0,0 @@
-/*  Starshatter: The Open Source Project
-    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
-    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
-    Copyright (c) 1997-2006, Destroyer Studios LLC.
-
-    AUTHOR:       John DiCamillo
-
-
-    OVERVIEW
-    ========
-    Geometric classes: Rect, Vec3, Point, Matrix, Plane
-*/
-
-#ifndef Geometry_h
-#define Geometry_h
-
-#include "Types.h"
-
-// +--------------------------------------------------------------------+
-
-struct Rect;
-struct Insets;
-struct Matrix;
-struct Vec3;
-struct Point;
-struct Quaternion;
-struct Plane;
-
-#ifndef PI
-const double PI = 3.14159265358979323846;
-#endif
-const double DEGREES = (PI/180);
-
-// +--------------------------------------------------------------------+
-
-struct Rect
-{
-    static const char* TYPENAME() { return "Rect"; }
-
-    Rect()                                 : x(0),  y(0),  w(0),  h(0)  { }
-    Rect(int ix, int iy, int iw, int ih)   : x(ix), y(iy), w(iw), h(ih) { }
-
-    int    operator==(const Rect& r)  const { return x==r.x && y==r.y && w==r.w && h==r.h; }
-    int    operator!=(const Rect& r)  const { return x!=r.x || y!=r.y || w!=r.w || h!=r.h; }
-
-    void   Inflate(int dw, int dh);
-    void   Deflate(int dw, int dh);
-    void   Inset(int left, int right, int top, int bottom);
-    int    Contains(int x, int y) const;
-
-    int x, y, w, h;
-};
-
-// +--------------------------------------------------------------------+
-
-struct Insets
-{
-    Insets() : left(0), right(0), top(0), bottom(0) { }
-    Insets(WORD l, WORD r, WORD t, WORD b) : left(l), right(r), top(t), bottom(b) { }
-
-    WORD  left;
-    WORD  right;
-    WORD  top;
-    WORD  bottom;
-};
-
-// +--------------------------------------------------------------------+
-
-struct Matrix
-{
-    static const char* TYPENAME() { return "Matrix"; }
-
-    Matrix();
-    Matrix(const Matrix& m);
-    Matrix(const Point& vrt, const Point& vup, const Point& vpn);
-
-    Matrix& operator =  (const Matrix& m);
-    Matrix& operator *= (const Matrix& m);
-
-    double  operator() (int i, int j)   const { return elem[i][j]; }
-    double& operator() (int i, int j)         { return elem[i][j]; }
-
-    void Identity();
-    void Transpose();
-    void Rotate(double roll, double pitch, double yaw);
-    void Roll(double roll);
-    void Pitch(double pitch);
-    void Yaw(double yaw);
-    void ComputeEulerAngles(double& roll, double& pitch, double& yaw) const;
-
-    double Cofactor(int i, int j) const;
-    void   Invert();
-
-    Matrix Inverse() const {
-        Matrix result(*this);
-        result.Invert();
-        return result;
-    }
-
-    Matrix operator*(const Matrix& m) const;
-    Point  operator*(const Point & p) const;
-    Vec3   operator*(const Vec3&   v) const;
-
-    double elem[3][3];
-
-private:
-    Matrix(int no_init) { }
-};
-
-// +--------------------------------------------------------------------+
-
-struct Vec2
-{
-    static const char* TYPENAME() { return "Vec2"; }
-
-    Vec2()                                                      { }
-    Vec2(int    ix, int    iy) : x((float) ix), y((float) iy)   { }
-    Vec2(float  ix, float  iy) : x(ix),         y(iy)           { }
-    Vec2(double ix, double iy) : x((float) ix), y((float) iy)   { }
-
-    operator void*()          const { return (void*) (x || y);    }
-    int    operator==(const Vec2& p) const { return x==p.x && y==p.y;    }
-    int    operator!=(const Vec2& p) const { return x!=p.x || y!=p.y;    }
-    Vec2   operator+ (const Vec2& p) const { return Vec2(x+p.x, y+p.y);  }
-    Vec2   operator- (const Vec2& p) const { return Vec2(x-p.x, y-p.y);  }
-    Vec2   operator- ()              const { return Vec2(-x, -y);        }
-    Vec2   operator* (float s)       const { return Vec2(x*s, y*s);      }
-    Vec2   operator/ (float s)       const { return Vec2(x/s, y/s);      }
-    float  operator*(const Vec2& p)  const { return (x*p.x + y*p.y);     }
-
-    Vec2&  operator= (const Vec2& p) { x =p.x; y =p.y; return *this;     }
-    Vec2&  operator+=(const Vec2& p) { x+=p.x; y+=p.y; return *this;     }
-    Vec2&  operator-=(const Vec2& p) { x-=p.x; y-=p.y; return *this;     }
-    Vec2&  operator*=(float  s)      { x*=s;   y*=s;   return *this;     }
-    Vec2&  operator/=(float  s)      { x/=s;   y/=s;   return *this;     }
-
-    float    length()             const { return (float) sqrt(x*x+y*y);  }
-    float    Normalize();
-    float    dot(const Vec2& p)   const { return (x*p.x + y*p.y);        }
-    Vec2     normal()             const { return Vec2(-y, x);            }
-
-    float x, y;
-};
-
-// +--------------------------------------------------------------------+
-
-struct Vec3
-{
-    static const char* TYPENAME() { return "Vec3"; }
-
-    Vec3() { }
-    Vec3(int    ix, int    iy, int    iz) : x((float) ix), y((float) iy), z((float) iz) { }
-    Vec3(float  ix, float  iy, float  iz) : x(ix),         y(iy),         z(iz)         { }
-    Vec3(double ix, double iy, double iz) : x((float) ix), y((float) iy), z((float) iz) { }
-
-    operator void*()           const { return (void*) (x || y || z);      }
-    int    operator==(const Vec3& p)  const { return x==p.x && y==p.y && z==p.z; }
-    int    operator!=(const Vec3& p)  const { return x!=p.x || y!=p.y || z!=p.z; }
-    Vec3   operator+ (const Vec3& p)  const { return Vec3(x+p.x, y+p.y, z+p.z);  }
-    Vec3   operator- (const Vec3& p)  const { return Vec3(x-p.x, y-p.y, z-p.z);  }
-    Vec3   operator- ()               const { return Vec3(-x, -y, -z);           }
-    Vec3   operator* (float s)        const { return Vec3(x*s, y*s, z*s);        }
-    Vec3   operator/ (float s)        const { return Vec3(x/s, y/s, z/s);        }
-    float  operator* (const Vec3& p)  const { return (x*p.x + y*p.y + z*p.z);    }
-    Vec3   operator* (const Matrix&)  const;
-
-    Vec3&  operator= (const Vec3& p)  { x =p.x; y =p.y; z =p.z; return *this; }
-    Vec3&  operator+=(const Vec3& p)  { x+=p.x; y+=p.y; z+=p.z; return *this; }
-    Vec3&  operator-=(const Vec3& p)  { x-=p.x; y-=p.y; z-=p.z; return *this; }
-    Vec3&  operator*=(float  s)       { x*=s;   y*=s;   z*=s;   return *this; }
-    Vec3&  operator/=(float  s)       { x/=s;   y/=s;   z/=s;   return *this; }
-
-    void     SwapYZ() { float t = y; y = z; z = t; }
-    float    length() const           { return (float) sqrt(x*x+y*y+z*z); }
-    float    Normalize();
-
-    float    dot(const Vec3& p)   const { return (x*p.x + y*p.y + z*p.z);    }
-    Vec3     cross(const Vec3& v) const { return Vec3((y*v.z) - (z*v.y),
-        (z*v.x) - (x*v.z),
-        (x*v.y) - (y*v.x));    }
-
-    float x, y, z;
-};
-
-double ClosestApproachTime(const Vec3& loc1, const Vec3& vel1,
-const Vec3& loc2, const Vec3& vel2);
-
-// +--------------------------------------------------------------------+
-
-struct Point
-{
-    static const char* TYPENAME() { return "Point"; }
-
-    Point()                                : x(0),   y(0),   z(0)    { }
-    Point(double ix, double iy, double iz) : x(ix),  y(iy),  z(iz)   { }
-    Point(const Point& p)                  : x(p.x), y(p.y), z(p.z)  { }
-    Point(const Vec3& v)                   : x(v.x), y(v.y), z(v.z)  { }
-
-    operator Vec3() const { return Vec3((float) x, (float) y, (float) z); }
-
-    operator void*()           const { return (void*) (x || y || z);      }
-    int   operator==(const Point& p) const { return x==p.x && y==p.y && z==p.z; }
-    int   operator!=(const Point& p) const { return x!=p.x || y!=p.y || z!=p.z; }
-    Point operator+ (const Point& p) const { return Point(x+p.x, y+p.y, z+p.z); }
-    Point operator- (const Point& p) const { return Point(x-p.x, y-p.y, z-p.z); }
-    Point operator- ()               const { return Point(-x, -y, -z);          }
-    Point operator* (double s)       const { return Point(x*s, y*s, z*s);       }
-    Point operator/ (double s)       const { return Point(x/s, y/s, z/s);       }
-    double operator*(const Point& p) const { return (x*p.x + y*p.y + z*p.z);    }
-    Point operator* (const Matrix& m) const;
-
-    Point& operator= (const Point& p)      { x =p.x; y =p.y; z =p.z; return *this; }
-    Point& operator+=(const Point& p)      { x+=p.x; y+=p.y; z+=p.z; return *this; }
-    Point& operator-=(const Point& p)      { x-=p.x; y-=p.y; z-=p.z; return *this; }
-    Point& operator*=(double s)            { x*=s;   y*=s;   z*=s;   return *this; }
-    Point& operator/=(double s)            { x/=s;   y/=s;   z/=s;   return *this; }
-
-    double   length()                const { return sqrt(x*x+y*y+z*z); }
-    double   Normalize();
-    void     SwapYZ()                      { double t = y; y = z; z = t; }
-    Point    OtherHand()             const { return Point(-x, z, y); }
-
-    void     SetElement(int i, double v);
-
-    double   dot(const Point& p)     const { return (x*p.x + y*p.y + z*p.z);    }
-    Point    cross(const Point& p)   const { return Point((y*p.z) - (z*p.y),
-        (z*p.x) - (x*p.z),
-        (x*p.y) - (y*p.x));   }
-
-    double x, y, z;
-};
-
-double ClosestApproachTime(const Point& loc1, const Point& vel1,
-const Point& loc2, const Point& vel2);
-
-// +--------------------------------------------------------------------+
-
-struct Quaternion
-{
-    static const char* TYPENAME() { return "Quaternion"; }
-
-    Quaternion()                     : x(0),   y(0),   z(0),   w(0)   { }
-    Quaternion(double ix,
-    double iy,
-    double iz,
-    double iw)            : x(ix),  y(iy),  z(iz),  w(iw)  { }
-    Quaternion(const Quaternion& q)  : x(q.x), y(q.y), z(q.z), w(q.w) { }
-
-    int   operator==(const Quaternion& q)  const { return x==q.x && y==q.y && z==q.z && w==q.w;  }
-    int   operator!=(const Quaternion& q)  const { return x!=q.x || y!=q.y || z!=q.z || w!=q.w;  }
-
-    Quaternion operator+ (const Quaternion& q) const { return Quaternion(x+q.x, y+q.y, z+q.z, w+q.w); }
-    Quaternion operator- (const Quaternion& q) const { return Quaternion(x-q.x, y-q.y, z-q.z, w-q.w); }
-    Quaternion operator- ()                const { return Quaternion(-x, -y, -z, -w);            }
-    Quaternion operator* (double s)        const { return Quaternion(x*s, y*s, z*s, w*s);        }
-    Quaternion operator/ (double s)        const { return Quaternion(x/s, y/s, z/s, w/s);        }
-
-    Quaternion& operator= (const Quaternion& q)  { x =q.x; y =q.y; z =q.z; w =q.w; return *this; }
-    Quaternion& operator+=(const Quaternion& q)  { x+=q.x; y+=q.y; z+=q.z; w+=q.w; return *this; }
-    Quaternion& operator-=(const Quaternion& q)  { x-=q.x; y-=q.y; z-=q.z; w-=q.w; return *this; }
-    Quaternion& operator*=(double s)             { x*=s;   y*=s;   z*=s;   w*=s;   return *this; }
-    Quaternion& operator/=(double s)             { x/=s;   y/=s;   z/=s;   w/=s;   return *this; }
-
-    double   length()                      const { return sqrt(x*x + y*y + z*z + w*w); }
-    double   Normalize();
-
-    double x, y, z, w;
-};
-
-// +--------------------------------------------------------------------+
-
-struct Plane
-{
-    static const char* TYPENAME() { return "Plane"; }
-
-    Plane();
-    Plane(const Point& p0,  const Point& p1,  const Point& p2);
-    Plane(const Vec3&  v0,  const Vec3&  v1,  const Vec3&  v2);
-
-    void Rotate(const Vec3& v0, const Matrix& m);
-    void Translate(const Vec3& v0);
-
-    float          distance;
-    Vec3           normal;
-};
-
-// +--------------------------------------------------------------------+
-
-double DotProduct(const Point& a, const Point& b);
-void   CrossProduct(const Point& a, const Point& b, Point& out);
-void   MConcat(double in1[3][3], double in2[3][3], double out[3][3]);
-
-// +--------------------------------------------------------------------+
-
-int lines_intersect(
-/* 1st line segment */ double x1, double y1, double x2, double y2,
-/* 2nd line segment */ double x3, double y3, double x4, double y4,
-/* intersect point  */ double& x, double& y);
-
-// +--------------------------------------------------------------------+
-
-#endif  // Geometry_h
-