// BasicTypes.h
//
//  (C) COPYRIGHT John Henckel, mailto:henckel@iname.com         Aug 1998
//
//  Permission to use, copy, modify, distribute and sell this software
//  and its documentation for any purpose is hereby granted without fee,
//  provided that the above copyright notice appear in all copies.
//
//  Visit my website!  http://www.GeoCities.com/Paris/6502

#if !defined(BasicTypes_h_INCLUDED_)
#define BasicTypes_h_INCLUDED_

#include <afxtempl.h>
#include <math.h>

#define EPSILON (1e-13)             // double has 16 significant digits
#define M_PI (3.14159265359)

//---------------------------------------------------------------------------

inline double random(double range = 1.0)
{
  return range * rand() / RAND_MAX;
}

class Vect;

//---------------------------------------------------------------------------
//  QUATERNION

class Quat
{
public:
  Quat(): w(1.0), x(0.0), y(0.0), z(0.0) {}
  Quat(const Quat& p, const Quat& q);
  Quat(double theta, double ax, double ay, double az);

  GLdouble* AsMatrix() const;
  double Dot(const Quat& p) const { return w*p.w + x*p.x + y*p.y + z*p.z; }
  void Slerp(const Quat& p, double alpha, int spins = 0);
  int IsZero() const { return w>0 && fabs(x)<EPSILON && fabs(y)<EPSILON && fabs(z)<EPSILON; }
  void operator *= (const Quat& p);
  Vect SpinVector() const;

  double w, x, y, z;

private:
  static GLdouble matrix[16];       // temp matrix used by Quat::AsMatrix
};

//---------------------------------------------------------------------------
//  VECTOR 3D

class Vect
{
public:
  Vect(): x(0.0), y(0.0), z(0.0) {}
  Vect(double ax, double ay, double az): x(ax), y(ay), z(az) {}

  double Dot(const Vect& p) const { return x*p.x + y*p.y + z*p.z; }
  double Norm() const { return x*x + y*y + z*z; }
  double Length() const { return sqrt(Norm()); }
  void Rotate(const Quat& p);
  void Normalize() { double r=Length(); if (r>0) operator *= (1/r); }
  void Negate() { x=-x; y=-y; z=-z; }
  Vect Cross(const Vect& v) const { return Vect(y*v.z-v.y*z,z*v.x-v.z*x,x*v.y-v.x*y); }
  Vect Cross2(const Vect& v) const { return Vect(v.y*z-v.z*y,v.z*x-v.x*z,v.x*y-v.y*x); }
  void Random() { x=random(); y=random(); z=random(); }
  int IsZero() const { return fabs(x)<EPSILON && fabs(y)<EPSILON && fabs(z)<EPSILON; }
  int IsDiagonal() const { return fabs(x-y)<EPSILON && fabs(y-z)<EPSILON; }
  Vect EulerDelta(const Vect& m) const {
    return Vect((m.y-m.z)*y*z/m.x, (m.z-m.x)*z*x/m.y, (m.x-m.y)*x*y/m.z); }
  double AngleTo(const Vect& v);
  Vect AxisTo(const Vect& v);

  void operator *= (double a) { x*=a; y*=a; z*=a; }
  void operator += (const Vect& v) { x+=v.x; y+=v.y; z+=v.z; }
  void operator -= (const Vect& v) { x-=v.x; y-=v.y; z-=v.z; }
  Vect operator + (const Vect& v) const { return Vect(x+v.x,y+v.y,z+v.z); }
  Vect operator - (const Vect& v) const { return Vect(x-v.x,y-v.y,z-v.z); }
  operator GLdouble* () { return &x; }

  double x, y, z;
};

//---------------------------------------------------------------------------

class Color {
public:
  Color(GLfloat rr=0.5f, GLfloat gg=0.5f, 
        GLfloat bb=0.5f, GLfloat aa=1.0f) : r(rr), g(gg), b(bb), a(aa) {}
  GLfloat r,g,b,a;
  operator GLfloat* () { return &r; }
};


//---------------------------------------------------------------------------
//   MATRIX
//
//  This matrix is row-major which means that the element m[r][c] is the r-th
//  row and the c-th column.

class Matrix 
{
  double **m;
  int numr, numc;

  void deallocate();               // some private methods for memory management
  void loadcopy(const Matrix& p);

public:
  Matrix(int numrow, int numcol);
  Matrix(const Matrix& p);
  ~Matrix();
  Matrix& operator =(const Matrix& p);
  const double* operator [](int i) const { return m[i]; }
  double* operator [](int i) { return m[i]; }
  void SetToZero();
  void SetToIdentity();

};


#endif