HBTPlayer.cpp

Go to the documentation of this file.

#include "HBTPlayer.h"
#include "OBT_ASSERT.h"
#include "HBTRecorder.h"

using namespace HBT ;


//=============================================================================

Player::Player( const std::string& fileName )
: _initRead( false ),
  _loop( false ),
  _file()
{ 
  open( fileName ) ;
}
//-----------------------------------------------------------------------------
Player::Player()
: _initRead( false ),
  _loop( false ),
  _file()
{ 
}
//-----------------------------------------------------------------------------
Player::~Player() 
{
  _file.close() ;
}
//-----------------------------------------------------------------------------
void Player::open( const std::string& fileName ) 
{
  _file.open( fileName.c_str(), std::ios::binary ) ;
  _initRead = false ;
}
//-----------------------------------------------------------------------------
void Player::read( std::string& txt )
{
  size_t size ;
  _file.read( (char*)&size, sizeof(size) ) ;
  char* txtTmp = new char[ size ] ;
  _file.read( txtTmp, size ) ;
  txt = txtTmp ;
  delete[] txtTmp ;
}
//-----------------------------------------------------------------------------
void Player::read( bool& flag )
{
  char tmp ;
  _file.read( &tmp, 1 ) ;
  flag = tmp == '1' ;
}
//-----------------------------------------------------------------------------
template< typename T >
void Player::read( T& val )
{
  _file.read( (char*)&val, sizeof( T ) ) ;
}
//-----------------------------------------------------------------------------
void Player::read( Ogre::Vector3& vect )
{
  _file.read( (char*)&vect.x, sizeof( Ogre::Real ) ) ;
  _file.read( (char*)&vect.y, sizeof( Ogre::Real ) ) ;
  _file.read( (char*)&vect.z, sizeof( Ogre::Real ) ) ;
}
//-----------------------------------------------------------------------------
void Player::read( Ogre::Quaternion& quat )
{
  _file.read( (char*)&quat.w, sizeof( Ogre::Real ) ) ;
  _file.read( (char*)&quat.x, sizeof( Ogre::Real ) ) ;
  _file.read( (char*)&quat.y, sizeof( Ogre::Real ) ) ;
  _file.read( (char*)&quat.z, sizeof( Ogre::Real ) ) ;
}
//-----------------------------------------------------------------------------
template< typename T >
void Player::read( std::vector< T >& tab ) 
{
  tab.clear() ;
  size_t size ;
  _file.read( (char*)&size, sizeof( size_t ) ) ;
  for( ; size != 0 ; size-- )
  {
    T val ;
    read( val ) ;
    tab.push_back( val ) ;
  }
}

//-----------------------------------------------------------------------------
Player& Player::read( InitialisationSequence& initialisationSequence ) 
{
  OBT_ASSERT( _file.is_open() && "The file is not opened" ) ;
  // Go to the beginning of the file
  _file.seekg( 0 ) ;

  // Tag
  std::string header ;
  read( header ) ;
  size_t length = Recorder::HEADER.length() ;
  OBT_ASSERT( header.substr( 0, length ) == Recorder::HEADER && "Not the good header" ) ;
  // Version
  if( header.substr( length ) == "0" )
  {
    read( initialisationSequence.meshFile ) ;
    read( initialisationSequence.humanName ) ;
    read( initialisationSequence.useShadows ) ;
    read( initialisationSequence.generalScale ) ;
    read( initialisationSequence.rootQuat ) ;
    read( initialisationSequence.rootPos ) ;
    read( initialisationSequence.boneNumber ) ;
    read( initialisationSequence.postureQuat ) ;
  }
  else
  {
    OBT_ASSERT( false && "not the good version" ) ; // version
  }

  _initRead = true ;
  return *this ;
}
//-----------------------------------------------------------------------------
Player& Player::read( unsigned int& date, PostureData& posture ) 
{
  OBT_ASSERT( _file.is_open() && "The file is not opened" ) ;
  OBT_ASSERT( _initRead && "You must read InitialisationSequence before reading the posture data" ) ;
  _file.peek() ;
  if( !_file.eof() )
  {
    read( _lastDate ) ; 
    read( _lastPosture.rootPos ) ; 
    read( _lastPosture.rootQuat ) ;    
    read( _lastPosture.generalScale ) ;
    read( _lastPosture.postureQuat ) ; 
    read( _lastPosture.quatModified ) ;
  }
  else if( _loop )
  {
    _file.clear() ;
    InitialisationSequence initialisationSequence ;
    read( initialisationSequence ) ;
  }
  date = _lastDate ;
  posture = _lastPosture ;
  return *this ;
}
//-----------------------------------------------------------------------------

---