NetConverters.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 NET_CONVERTERS_H
#define NET_CONVERTERS_H

#include <PVLE/Config.h>

#ifdef PVLE_NETWORKING


#include <tnl/tnlbitstream.h>
#include <PVLE/Export.h>
#include <PVLE/Util/Util.h>
#include <string>
#include <limits.h>
#include <ode/common.h>     // For dSINGLE/dDOUBLE

#if defined(dSINGLE)
    #include <osg/Vec3f>
    #include <osg/Vec4f>
    #include <osg/Quat>
    #include <osg/Matrixf>
#elif defined(dDOUBLE)
    #include <osg/Vec3d>
    #include <osg/Vec4d>
    #include <osg/Quat>
    #include <osg/Matrixd>
#else
#error You must #define dSINGLE or dDOUBLE
#endif


namespace Net {

inline TNL::Point3F toNetVec3(const osg::Vec3f & v) {
    TNL::Point3F res;
    res.x = v.x();
    res.y = v.y();
    res.z = v.z();
    return res;
}

inline osg::Vec3f toGraphVec3(const TNL::Point3F & v) { return osg::Vec3f(v.x, v.y, v.z); }


// ----- Readers/writers -----

inline void writeSignedFloat(TNL::BitStream * pStream, float v, float maxAbsValue, TNL::U8 bitCount) {
    ASSERT(v>=-maxAbsValue && v<=maxAbsValue);          // If this assertion fails, then your maxAbsValue is not high enough...
    pStream->writeSignedFloat(v/maxAbsValue, bitCount);
}
inline float readSignedFloat(TNL::BitStream * pStream, float maxAbsValue, TNL::U8 bitCount) {
    return pStream->readSignedFloat(bitCount) * maxAbsValue;
}
inline void writeFloat(TNL::BitStream * pStream, float v, float maxAbsValue, TNL::U8 bitCount) {
    ASSERT(v>=0);
    ASSERT(v<=maxAbsValue);         // If this assertion fails, then your maxAbsValue is not high enough...
    pStream->writeFloat(v/maxAbsValue, bitCount);
}
inline float readFloat(TNL::BitStream * pStream, float maxAbsValue, TNL::U8 bitCount) {
    return pStream->readFloat(bitCount) * maxAbsValue;
}


inline void writePointCompressed(TNL::BitStream * pStream, const osg::Vec3f & v, TNL::F32 scale) {
    pStream->writePointCompressed(toNetVec3(v), scale);
}
inline osg::Vec3f readPointCompressed(TNL::BitStream * pStream) {
    TNL::Point3F point;
    pStream->readPointCompressed(&point, 1.f);
    return toGraphVec3(point);
}


inline void write(TNL::BitStream * pStream, const osg::Vec3f & v) {
    pStream->write(v.x());
    pStream->write(v.y());
    pStream->write(v.z());
}
inline void read(TNL::BitStream * pStream, osg::Vec3f & v) {
    osg::Vec3f::value_type temp;
    pStream->read(&temp);
    v.x() = temp;
    pStream->read(&temp);
    v.y() = temp;
    pStream->read(&temp);
    v.z() = temp;
}


inline void write(TNL::BitStream * pStream, const osg::Quat & q) {
#ifdef PVLE_NET_SEND_QUATERNION_NATIVE_PRECISION
    pStream->write(q.x());
    pStream->write(q.y());
    pStream->write(q.z());
    pStream->write(q.w());
#else
    pStream->write(static_cast<float>(q.x()));
    pStream->write(static_cast<float>(q.y()));
    pStream->write(static_cast<float>(q.z()));
    pStream->write(static_cast<float>(q.w()));
#endif
}
inline void read(TNL::BitStream * pStream, osg::Quat & q) {
#ifdef PVLE_NET_SEND_QUATERNION_NATIVE_PRECISION
    osg::Quat::value_type temp;
#else
    float temp;
#endif
    pStream->read(&temp);
    q.x() = temp;
    pStream->read(&temp);
    q.y() = temp;
    pStream->read(&temp);
    q.z() = temp;
    pStream->read(&temp);
    q.w() = temp;
}

inline void write(TNL::BitStream * pStream, const std::string & v) {
    ASSERT(v.length() < USHRT_MAX);
    pStream->write(static_cast<USHORT>(v.length()));
    pStream->write(v.length(), v.c_str());
}
inline void read(TNL::BitStream * pStream, std::string & v) {
    USHORT len;
    pStream->read(&len);
    //v.resize(len);
    std::string::value_type * pBuffer = new std::string::value_type[len+1];
    pStream->read(len, pBuffer);
    pBuffer[len] = 0;
    v = pBuffer;
    delete[] pBuffer;
}

PVLE_EXPORT void writeMatrix(TNL::BitStream * pStream, const osg::Matrixf & m);
PVLE_EXPORT void readMatrix(TNL::BitStream * pStream, osg::Matrixf & m);

}  // namespace Net

#endif  // PVLE_NETWORKING

#endif  // NET_CONVERTERS_H

---