Public API Reference

csgeom/transfrm.h

Go to the documentation of this file.

/*
    Copyright (C) 1998-2001 by Jorrit Tyberghein
    Largely rewritten by Ivan Avramovic <[email protected]>

    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 "csextern.h"


#include "csgeom/matrix3.h"
#include "csgeom/vector3.h"

class csPlane3;
class csSphere;

class csReversibleTransform;

class CS_CRYSTALSPACE_EXPORT csTransform
{
protected:
  csMatrix3 m_o2t;
  csVector3 v_o2t;

public:
  // Needed for GCC4. Otherwise emits a flood of "virtual functions but
  // non-virtual destructor" warnings.
  virtual ~csTransform() {}
  csTransform () : m_o2t (), v_o2t (0, 0, 0) {}

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

  inline void Identity ()
  {
    SetO2TTranslation (csVector3 (0));
    SetO2T (csMatrix3 ());
  }

  inline bool IsIdentity () const
  {
    if (ABS (v_o2t.x) >= SMALL_EPSILON) return false;
    if (ABS (v_o2t.y) >= SMALL_EPSILON) return false;
    if (ABS (v_o2t.z) >= SMALL_EPSILON) return false;
    if (ABS (m_o2t.m11-1) >= SMALL_EPSILON) return false;
    if (ABS (m_o2t.m12) >= SMALL_EPSILON) return false;
    if (ABS (m_o2t.m13) >= SMALL_EPSILON) return false;
    if (ABS (m_o2t.m21) >= SMALL_EPSILON) return false;
    if (ABS (m_o2t.m22-1) >= SMALL_EPSILON) return false;
    if (ABS (m_o2t.m23) >= SMALL_EPSILON) return false;
    if (ABS (m_o2t.m31) >= SMALL_EPSILON) return false;
    if (ABS (m_o2t.m32) >= SMALL_EPSILON) return false;
    if (ABS (m_o2t.m33-1) >= SMALL_EPSILON) return false;
    return true;
  }

  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);
  }

  inline 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;

  csSphere Other2This (const csSphere& s) const;

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

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

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

  friend CS_CRYSTALSPACE_EXPORT csPlane3 operator* (const csPlane3& p, 
    const csTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csPlane3 operator* (const csTransform& t, 
    const csPlane3& p);

  friend CS_CRYSTALSPACE_EXPORT csPlane3& operator*= (csPlane3& p, 
    const csTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csSphere operator* (const csSphere& p, 
    const csTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csSphere operator* (const csTransform& t, 
    const csSphere& p);

  friend CS_CRYSTALSPACE_EXPORT csSphere& operator*= (csSphere& p, 
    const csTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csMatrix3 operator* (const csMatrix3& m, 
    const csTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csMatrix3 operator* (const csTransform& t, 
    const csMatrix3& m);

  friend CS_CRYSTALSPACE_EXPORT csMatrix3& operator*= (csMatrix3& m, 
    const csTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csTransform operator* (const csTransform& t1,
                              const csReversibleTransform& t2);

  static csTransform GetReflect (const csPlane3& pl);

  csVector3 GetFront () const
  { 
    return csVector3 (m_o2t.m31, m_o2t.m32, m_o2t.m33); 
  }

  csVector3 GetUp () const
  {
    return csVector3 (m_o2t.m21, m_o2t.m22, m_o2t.m23); 
  }

  csVector3 GetRight () const 
  {
    return csVector3 (m_o2t.m11, m_o2t.m12, m_o2t.m13); 
  }
};

class CS_CRYSTALSPACE_EXPORT 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 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 (); }

  inline 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;

  csSphere This2Other (const csSphere& s) 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 CS_CRYSTALSPACE_EXPORT csVector3 operator/ (const csVector3& v,
        const csReversibleTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csVector3& operator/= (csVector3& v, 
    const csReversibleTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csPlane3 operator/ (const csPlane3& p, 
    const csReversibleTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csPlane3& operator/= (csPlane3& p, 
    const csReversibleTransform& t);

  friend CS_CRYSTALSPACE_EXPORT csSphere operator/ (const csSphere& 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);
  }

#if !defined(SWIG) /* Otherwise Swig 1.3.22 thinks this is multiply declared */

  friend CS_CRYSTALSPACE_EXPORT csTransform operator* (const csTransform& t1,
                              const csReversibleTransform& t2);
#endif

  friend CS_CRYSTALSPACE_EXPORT csReversibleTransform& operator/= (
    csReversibleTransform& t1, const csReversibleTransform& t2);

  friend CS_CRYSTALSPACE_EXPORT 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__

---