---

Transform.H

Go to the documentation of this file.

#ifndef _TRANSFORM_H
#define _TRANSFORM_H


#include <Matrix.H>


namespace xchen
{
  class Transform {
      enum { TRANSFORM_POINT, TRANSFORM_VECTOR, INV_TRANSFORM_POINT, INV_TRANSFORM_VECTOR, TRANSFORM_NORMAL };
  public:
      Transform();

      void SetIdentity() { M.SetIdentity(); validCache() = false; }

      void ShearXY(double a, double b);
      void ShearXZ(double a, double b);
      void ShearYZ(double a, double b);

      void Translate(double x, double y, double z);
      void Translate(const dVector3D& v)                                  { Translate(v[0], v[1], v[2]); }
      void TranslateX(double x)                                           { Translate(x, 0, 0); }
      void TranslateY(double y)                                           { Translate(0, y, 0); }
      void TranslateZ(double z)                                           { Translate(0, 0, z); }

      void Rotate(double dx, double dy, double dz, double angle);
      void RotateX(double x);
      void RotateY(double y);
      void RotateZ(double z);

      void Rotate2Frame(const class Frame&);
    
      void Scale(double sx, double sy, double sz);
      void ScaleX(double x)                                               { Scale(x, 1, 1); }
      void ScaleY(double y)                                               { Scale(1, y, 1); }
      void ScaleZ(double z)                                               { Scale(1, 1, z); }

      void Rotate(const dVector3D& v, double angle)                       { Rotate(v[0], v[1], v[2], angle); }
      void Scale(const dVector3D& v)                                      { Scale(v[0], v[1], v[2]); }

      void RotateTo(const dVector3D& from, const dVector3D& to)           { Rotate(from^to, from.Angle(to)); }

      void GetGLMatrix(double* m) const                                   { M.GetColumnMajorData(m); }
      double* GetGLMatrix() const                                         { double *m = new double[16]; GetGLMatrix(m); return m; }
      const HMatrix& GetMatrix() const                                    { return M; }
    
      double GetMeasureScale() const                                      { return measure_scale; }

      dVector4D operator()(dVector4D const& p) const                      { return M * p; }
      dVector4D operator*(dVector4D const& p) const                       { return M * p; }

      //      Transform& operator*(Transform const& rhs)                          { M *= rhs.M; return *this; }

      void TransformPoint(dVector3D& p) const                             { transform(p, TRANSFORM_POINT); }
      void TransformVector(dVector3D& v) const                            { transform(v, TRANSFORM_VECTOR); }
      void TransformNormal(dVector3D& n) const                            { transform(n, TRANSFORM_NORMAL); }

      void InvTransformPoint(dVector3D& p) const                          { transform(p, INV_TRANSFORM_POINT); }
      void InvTransformVector(dVector3D& v) const                         { transform(v, INV_TRANSFORM_VECTOR); }

      friend ostream& operator << (ostream& os, const Transform& trans);

  private:
      void transform(dVector3D& p, int trans) const;

      HMatrix M, invM, itM;
      bool valid_cache;
      bool& validCache() const                                             { return (bool&) valid_cache; }

      double measure_scale;

      HMatrix m;                                                           // tempary working matrix.
  };



  inline void Transform :: transform(dVector3D& p, int trans) const
  {
    dVector4D p2(p);

    if(trans == TRANSFORM_POINT || trans == INV_TRANSFORM_POINT)
      p2[3] = 1.0;

    const HMatrix* m = &M;

    if( (trans == TRANSFORM_NORMAL || trans == INV_TRANSFORM_POINT || trans == INV_TRANSFORM_VECTOR) &&
        (! validCache() ) )
    {
      Transform* This = (Transform*) this;
      M.GetInverse(&This->invM);
      M.GetTranspose(&This->itM);
      This->validCache() = true;
    }

    if(trans == TRANSFORM_NORMAL) 
      m = &itM;
    else if(trans == INV_TRANSFORM_POINT || trans == INV_TRANSFORM_VECTOR)
      m = &invM;
  
    dVector4D p3 = (*m) * p2;
    assert( approx_eq(p3[3], p2[3]) );

    p = dVector3D(p3);
  }

  inline Transform :: Transform() : valid_cache(false), measure_scale(1.0)
  {
    M.SetIdentity();
  }





  inline Transform scale(double s)
  {
    Transform tr; tr.Scale(s,s,s); return tr;
  }

  inline Transform rotateX(double ang) 
  {
    Transform tr; tr.RotateX(ang); return tr;
  }

  inline Transform rotateY(double ang) 
  {
    Transform tr; tr.RotateY(ang); return tr;
  }

  inline Transform rotateZ(double ang) 
  {
    Transform tr; tr.RotateZ(ang); return tr;
  }

  inline Transform tX(double d) 
  {
    Transform tr; tr.TranslateX(d); return tr;
  }
  inline Transform tY(double d) 
  {
    Transform tr; tr.TranslateY(d); return tr;
  }
  inline Transform tZ(double d) 
  {
    Transform tr; tr.TranslateZ(d); return tr;
  }


#define sc scale
#define rX rotateX
#define rY rotateY
#define rZ rotateZ


}//end namespace xchen


#endif

---