OMKConversion.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2006 by Benoit Chanclou,bunraku   *
 *   bchanclo@irisa.fr   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef OMK_VIS_CONVERSION_H
#define OMK_VIS_CONVERSION_H

#include "Wm4Quaternion.h"
#include "OgreQuaternion.h"
#include "Wm4Vector3.h"
#include "OgreVector3.h"
#include "Wm4Matrix3.h"
#include "OgreMatrix3.h"
#include "Wm4Matrix4.h"
#include "OgreMatrix4.h"
#include "OgreNode.h"
#include "OMKTransform.h"

namespace OMK  
{
  namespace Vis 
  {



inline Wm4::Quaternionf convert( const Ogre::Quaternion& q )
{
  return Wm4::Quaternionf( q.w, q.x, q.y, q.z ) ;
}
inline Ogre::Quaternion convert( const Wm4::Quaternionf& q )
{
  return Ogre::Quaternion( q.W(), q.X(), q.Y(), q.Z() ) ;
}


inline Wm4::Vector3f convert( const Ogre::Vector3& v )
{
  return Wm4::Vector3f( v.x, v.y, v.z ) ;
}
inline Ogre::Vector3 convert( const Wm4::Vector3f& v )
{
  return Ogre::Vector3( v.X(), v.Y(), v.Z() ) ;
}


inline Wm4::Matrix3f convert( const Ogre::Matrix3& m )
{
  return Wm4::Matrix3f( m[0][0], m[0][1], m[0][2],
                        m[1][0], m[1][1], m[1][2],
                        m[2][0], m[2][1], m[2][2] ) ;
}
inline Ogre::Matrix3 convert( const Wm4::Matrix3f& m )
{
  return Ogre::Matrix3( m[0][0], m[0][1], m[0][2],
                        m[1][0], m[1][1], m[1][2],
                        m[2][0], m[2][1], m[2][2] ) ;
}


inline Wm4::Matrix4f convert( const Ogre::Matrix4& m )
{
  return Wm4::Matrix4f( m[0][0], m[0][1], m[0][2], m[0][3],
                        m[1][0], m[1][1], m[1][2], m[1][3],
                        m[2][0], m[2][1], m[2][2], m[2][3],
                        m[3][0], m[3][1], m[3][2], m[3][3] ) ;
}
inline Ogre::Matrix4 convert( const Wm4::Matrix4f& m )
{
  return Ogre::Matrix4( m[0][0], m[0][1], m[0][2], m[0][3],
                        m[1][0], m[1][1], m[1][2], m[1][3],
                        m[2][0], m[2][1], m[2][2], m[2][3],
                        m[3][0], m[3][1], m[3][2], m[3][3] ) ;
}



inline Wm4::Plane3f convert( const Ogre::Plane& p )
{
  return Wm4::Plane3f( convert( p.normal ), -p.d ) ;
}
inline Ogre::Plane convert( const Wm4::Plane3f& p )
{
  return Ogre::Plane( convert( p.Normal ), p.Constant ) ;
}


inline void 
convert( const Type::Transform& transform, Ogre::Node& node )
{        
        const Wm4::Vector3f& translate( transform.getTranslate() ) ;
        node.setPosition( translate.X(), translate.Y(), translate.Z() ) ;
        const Wm4::Quaternionf& quaternion( transform.getQuaternionRotate() ) ; ;
        node.setOrientation( quaternion.W(), quaternion.X(), quaternion.Y(), quaternion.Z() ) ;
        const Wm4::Vector3f& scale( transform.getScale() ) ;
        node.setScale( scale.X(), scale.Y(), scale.Z() ) ;
}
inline void 
convert( const Ogre::Node& node, Type::Transform& transform )
{
        transform.setTranslate( convert( node.getPosition() ) ) ;
        Wm4::Quaternionf quaternion( convert( node.getOrientation() ) ) ;
        Wm4::Matrix3f matrix ;
        quaternion.ToRotationMatrix( matrix ) ;
        transform.setRotate( matrix ) ;
        transform.setScale( convert( node.getScale() ) ) ;
}

  }// namespace Vis
}// namespace OMK

#endif // OMK_VIS_CONVERSION_H

---