optransfrm.h

Go to the documentation of this file.

/*
    Copyright (C) 1998-2001 by Jorrit Tyberghein
    Largely rewritten by Ivan Avramovic <ivan@avramovic.com>
  
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.
  
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.
  
    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_TRANSFORM_H__
#define __CS_TRANSFORM_H__

#include "opmatrix3.h"

class csReversibleTransform;

class csTransform
{
protected:
  csMatrix3 m_o2t;
  csVector3 v_o2t;

public:
  csTransform () : m_o2t (), v_o2t (0, 0, 0) {}

  csTransform (const csMatrix3& other2this, const csVector3& origin_pos) :
    m_o2t (other2this), v_o2t (origin_pos) {}

  inline const csMatrix3& GetO2T () const { return m_o2t; }

  inline const csVector3& GetO2TTranslation () const { return v_o2t; }

  inline const csVector3& GetOrigin () const { return v_o2t; }

  virtual void SetO2T (const csMatrix3& m) { m_o2t = m; }

  virtual void SetO2TTranslation (const csVector3& v) { v_o2t = v; }

  inline void SetOrigin (const csVector3& v) { SetO2TTranslation (v); }

  inline void Translate (const csVector3& v) { SetO2TTranslation (v_o2t + v); }

  inline csVector3 Other2This (const csVector3& v) const
  {
    return m_o2t * (v - v_o2t);
  }

  csVector3 Other2ThisRelative (const csVector3& v) const
  { return m_o2t * v; }

//  csPlane3 Other2This (const csPlane3& p) const;

//  csPlane3 Other2ThisRelative (const csPlane3& p) const;

//  void Other2This (const csPlane3& p, const csVector3& point,
//      csPlane3& result) const;

  friend csVector3 operator* (const csVector3& v, const csTransform& t);

  friend csVector3 operator* (const csTransform& t, const csVector3& v);
  friend csVector3& operator*= (csVector3& v, const csTransform& t);
//  friend csPlane3 operator* (const csPlane3& p, const csTransform& t);
//  friend csPlane3 operator* (const csTransform& t, const csPlane3& p);
//  friend csPlane3& operator*= (csPlane3& p, const csTransform& t);

  friend csMatrix3 operator* (const csMatrix3& m, const csTransform& t);
  friend csMatrix3 operator* (const csTransform& t, const csMatrix3& m);
  friend csMatrix3& operator*= (csMatrix3& m, const csTransform& t);
  friend csTransform operator* (const csTransform& t1,
                              const csReversibleTransform& t2);

//  static csTransform GetReflect (const csPlane3& pl);
};

class csReversibleTransform : public csTransform
{
protected:
  csMatrix3 m_t2o;
  
  csReversibleTransform (const csMatrix3& o2t, const csMatrix3& t2o, 
    const csVector3& pos) : csTransform (o2t,pos), m_t2o (t2o) {}

public:
  csReversibleTransform () : csTransform (), m_t2o () {}

  csReversibleTransform (const Matrix &m):
          csTransform (
              csMatrix3 (m.r[0],m.r[3],m.r[6],
                         m.r[1],m.r[4],m.r[7],
                         m.r[2],m.r[5],m.r[8]).GetInverse(),
              csVector3 (m.p.i,m.p.j,m.p.k)),
          m_t2o(m.r[0],m.r[3],m.r[6],
                m.r[1],m.r[4],m.r[7],
                m.r[2],m.r[5],m.r[8]) {
  }
  csReversibleTransform (const csMatrix3& o2t, const csVector3& pos) :
    csTransform (o2t,pos) { m_t2o = m_o2t.GetInverse (); }

  csReversibleTransform (const csTransform& t) :
    csTransform (t) { m_t2o = m_o2t.GetInverse (); }

  csReversibleTransform (const csReversibleTransform& t) :
    csTransform (t) { m_t2o = t.m_t2o; }

  inline const csMatrix3& GetT2O () const { return m_t2o; }

  inline csVector3 GetT2OTranslation () const { return -m_o2t*v_o2t; }

  csReversibleTransform GetInverse () const 
  { return csReversibleTransform (m_t2o, m_o2t, -m_o2t*v_o2t); } 

  virtual void SetO2T (const csMatrix3& m) 
  { m_o2t = m;  m_t2o = m_o2t.GetInverse (); }

  virtual void SetT2O (const csMatrix3& m) 
  { m_t2o = m;  m_o2t = m_t2o.GetInverse (); }

  csVector3 This2Other (const csVector3& v) const
  { return v_o2t + m_t2o * v; }

  inline csVector3 This2OtherRelative (const csVector3& v) const
  { return m_t2o * v; }

//  csPlane3 This2Other (const csPlane3& p) const;

//  csPlane3 This2OtherRelative (const csPlane3& p) const;

//  void This2Other (const csPlane3& p, const csVector3& point,
//      csPlane3& result) const;


  void RotateOther (const csVector3& v, float angle);

  void RotateThis (const csVector3& v, float angle);

  void RotateOther (const csMatrix3& m) { SetT2O (m * m_t2o); }

  void RotateThis (const csMatrix3& m) { SetT2O (m_t2o * m); }

  void LookAt (const csVector3& v, const csVector3& up);

  friend csVector3 operator/ (const csVector3& v, const csReversibleTransform& t); 
  friend csVector3& operator/= (csVector3& v, const csReversibleTransform& t); 
//  friend csPlane3 operator/ (const csPlane3& p, const csReversibleTransform& t);
//  friend csPlane3& operator/= (csPlane3& p, const csReversibleTransform& t);
  friend csReversibleTransform& operator*= (csReversibleTransform& t1,
                                          const csReversibleTransform& t2)
  {
    t1.v_o2t = t2.m_t2o*t1.v_o2t;
    t1.v_o2t += t2.v_o2t;
    t1.m_o2t *= t2.m_o2t;
    t1.m_t2o *= t1.m_t2o;
    return t1;
  }
  friend csReversibleTransform operator* (const csReversibleTransform& t1,
                                        const csReversibleTransform& t2)
  {
    return csReversibleTransform (t1.m_o2t*t2.m_o2t, t2.m_t2o*t1.m_t2o, 
                             t2.v_o2t + t2.m_t2o*t1.v_o2t); 
  }
  friend csTransform operator* (const csTransform& t1, 
                              const csReversibleTransform& t2);
  friend csReversibleTransform& operator/= (csReversibleTransform& t1,
                                          const csReversibleTransform& t2);
  friend csReversibleTransform operator/ (const csReversibleTransform& t1,
                                        const csReversibleTransform& t2);
};

class csOrthoTransform : public csReversibleTransform
{
public:
  csOrthoTransform () : csReversibleTransform () {}

  csOrthoTransform (const csMatrix3& o2t, const csVector3& pos) :
    csReversibleTransform (o2t, o2t.GetTranspose (), pos) { }

  csOrthoTransform (const csTransform& t) :
    csReversibleTransform (t.GetO2T (), t.GetO2T ().GetTranspose (), t.GetO2TTranslation ()) { }

  virtual void SetO2T (const csMatrix3& m) 
  { m_o2t = m;  m_t2o = m_o2t.GetTranspose (); }

  virtual void SetT2O (const csMatrix3& m) 
  { m_t2o = m;  m_o2t = m_t2o.GetTranspose (); }
};

#endif // __CS_TRANSFORM_H__