Converters.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.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 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// 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.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------


#ifndef PHY_CONVERTERS_H
#define PHY_CONVERTERS_H

#include <PVLE/Export.h>
#include <ode/ode.h>

// Include of the right version of OSG VecN / Quaternion / Matrix
#if defined(dSINGLE)
    #include <osg/Vec3f>
    #include <osg/Vec4f>
    #include <osg/Quat>
    #include <osg/Matrixf>
    #include <osg/BoundingBox>
#elif defined(dDOUBLE)
    #include <osg/Vec3d>
    #include <osg/Vec4d>
    #include <osg/Quat>
    #include <osg/Matrixd>
    #include <osg/BoundingBox>
#else
#error You must #define dSINGLE or dDOUBLE
#endif



namespace Physics {

// Defines, for genericity
#if defined(dSINGLE)
    #define graphVec3 osg::Vec3f
    #define graphVec4 osg::Vec4f
    #define graphQuat osg::Quat
    #define graphMat osg::Matrixf
    #define graphBB osg::BoundingBox
#else
    #define graphVec3 osg::Vec3d
    #define graphVec4 osg::Vec4d
    #define graphQuat osg::Quat
    #define graphMat osg::Matrixd
    #define graphBB osg::BoundingBox
#endif

//operator graphVec3(const dVector3 & v) { return graphVec3(v[0], v[1], v[2]); }
//operator graphVec4(const dVector4 & v) { return graphVec4(v[0], v[1], v[2], v[3]); }

//inline graphVec3 toGraphVec3(const dVector3 & v) { return graphVec3(v[0], v[1], v[2]); }
inline graphVec3 toGraphVec3(const dReal * v) { return graphVec3(v[0], v[1], v[2]); }
inline graphVec4 toGraphVec4(const dVector4 & v) { return graphVec4(v[0], v[1], v[2], v[3]); }

inline void toPhyVec3(const graphVec3 & v, dVector3 out_ret) { out_ret[0] = v.x(); out_ret[1] = v.y(); out_ret[2] = v.z(); }
inline void toPhyVec3(const dReal & x, const dReal & y, const dReal & z, dVector3 out_ret) { out_ret[0] = x; out_ret[1] = y; out_ret[2] = z; }
inline void toPhyVec4(const graphVec4 & v, dVector4 out_ret) { out_ret[0] = v.x(); out_ret[1] = v.y(); out_ret[2] = v.z(); out_ret[3] = v.w(); }
inline void toPhyVec4(const dReal & x, const dReal & y, const dReal & z, const dReal & w, dVector3 out_ret) { out_ret[0] = x; out_ret[1] = y; out_ret[2] = z; out_ret[3] = w; }

//inline graphQuat toGraphQuat(const dQuaternion & v) { return osg::Quat(v[1], v[2], v[3], v[0]); }
inline graphQuat toGraphQuat(const dReal * v) { return osg::Quat(v[1], v[2], v[3], v[0]); }

inline void toPhyQuat(const graphQuat & quat, dQuaternion & out_q) { out_q[0]=quat.w(); out_q[1]=quat.x(); out_q[2]=quat.y(); out_q[3]=quat.z(); }

PVLE_EXPORT graphMat toGraphMatInertia(const dReal * m);
PVLE_EXPORT graphMat toGraphMatRotation(const dReal * m);
PVLE_EXPORT graphMat toGraphMatRotationPosition(const dReal * m, const dReal * p);
PVLE_EXPORT void toPhyMatRotation(const graphMat & matrix, dMatrix3 & out_matrix);

// ODE bounding box is (minx, maxx, miny, maxy, minz, maxz)
inline graphBB toGraphBB(dReal * bb) { return graphBB(graphVec3(bb[0], bb[2], bb[4]), graphVec3(bb[1], bb[3], bb[5])); }
inline void toPhyBB(const graphBB & bb, dReal * out_bb) { out_bb[0]=bb._min.x(); out_bb[1]=bb._max.x(); out_bb[2]=bb._min.y(); out_bb[3]=bb._max.y(); out_bb[4]=bb._min.z(); out_bb[5]=bb._max.z(); }


inline dReal kmhToms(dReal v) { return v*static_cast<dReal>(0.2777777777); }
inline dReal msTokmh(dReal v) { return v*static_cast<dReal>(3.6); }

}   // namespace Physics



#endif  // PHY_CONVERTERS_H

---