OMKDistributedCameraListener.cpp

Go to the documentation of this file.

#include "OMKDistributedCameraListener.h"
#include "OMKSystemEventIdentifier.h"
#include "OMKOgreVis.h"
#include "OMKTransformType.h"

using namespace OMK ;
using namespace OMK::Inp ;
using namespace OMK::Vis ;
using namespace OMK::Type ;
using namespace Ogre ;
using namespace Wm4 ;
using namespace OIS ;

REGISTER_OBJECT_FACTORY( DistributedCameraListener, "DistributedCameraListener" ) ;

//-------------------------------------------------------------------------
// constructor
//-------------------------------------------------------------------------
DistributedCameraListener::DistributedCameraListener
( OMK::Controller& ctrl, const ObjectDescriptor& objectDescriptor )
: 
SimulatedObject( ctrl, objectDescriptor ),
_ogreVis( NULL ),
_updateTransform( false ),
_translationSpeed( 1.0f ),
_wheelTranslationSpeed( 1.0f ),
_rotationSpeed( 0.001f ),
_inputManager( NULL ),
_mouse( NULL ),
_keyboard( NULL )
{ 
}

//-------------------------------------------------------------------------
// destructor
//-------------------------------------------------------------------------
DistributedCameraListener::~DistributedCameraListener( void ) 
{
}

//-------------------------------------------------------------------------
// init
//-------------------------------------------------------------------------
void 
DistributedCameraListener::init()
{
  readConfigurationParameters() ;

  ParamList pl ;
  size_t windowHnd( 0 ) ;
  std::ostringstream windowHndStr ;

#if defined WIN32
  // Uncomment these two lines to allow users to switch keyboards via the language bar
  pl.insert(std::make_pair( std::string( "w32_keyboard" ), std::string( "DISCL_FOREGROUND" ) ) );
  pl.insert(std::make_pair( std::string( "w32_keyboard" ), std::string( "DISCL_NONEXCLUSIVE" ) ) );

#elif defined OIS_LINUX_PLATFORM
  pl.insert( std::make_pair( std::string( "XAutoRepeatOn" ), std::string( "true") ) );    
  pl.insert( std::make_pair( std::string( "x11_mouse_hide" ), std::string( "false" ) ) );    
  pl.insert( std::make_pair( std::string( "x11_mouse_grab" ), std::string( "false" ) ) );    
  pl.insert( std::make_pair( std::string( "x11_keyboard_grab" ), std::string( "false" ) ) );    
#endif

  _ogreVis->touchRoot().getAutoCreatedWindow()->getCustomAttribute( "WINDOW", &windowHnd ) ;
  windowHndStr << windowHnd ;
  pl.insert( std::make_pair( std::string( "WINDOW" ), windowHndStr.str() ) ) ;

  _inputManager = InputManager::createInputSystem( pl ) ;

  //create devices
  _keyboard = static_cast<Keyboard*>( _inputManager->createInputObject( OISKeyboard, false ) ) ;
  _mouse = static_cast<Mouse*>( _inputManager->createInputObject( OISMouse, false ) ) ;

  //Set initial mouse clipping size
  windowResized( _ogreVis->touchRoot().getAutoCreatedWindow() );

  //Register as a Window listener
  WindowEventUtilities::addWindowEventListener( _ogreVis->touchRoot().getAutoCreatedWindow(), this ) ;

  //register as a frame listener
  _ogreVis->touchRoot().addFrameListener( this ) ;
}

//-------------------------------------------------------------------------
// finish
//-------------------------------------------------------------------------
void 
DistributedCameraListener::finish()
{
  //Remove ourself as a Window listener
  WindowEventUtilities::removeWindowEventListener( _ogreVis->touchRoot().getAutoCreatedWindow(), this ) ;
  windowClosed( _ogreVis->touchRoot().getAutoCreatedWindow() ) ;
}

//-------------------------------------------------------------------------
// compute
//-------------------------------------------------------------------------
void 
DistributedCameraListener::compute() 
{
  if ( _updateTransform == true )
  {
   // std::cerr << "DistributedCameraListener::compute() Signal" << std::endl ;
    fireValuedSignal< TransformType >( "moveCamera", _transform ) ;
    _updateTransform = false ;
  }
}

//-------------------------------------------------------------------------
// readConfigurationParameters
//-------------------------------------------------------------------------
void
DistributedCameraListener::readConfigurationParameters()
{
  const ConfigurationParameterDescriptor* node( getConfigurationParameters() ) ;

  // Retrieve the VisuName parameter
  std::string visuName ;
  ParametersAccessor::get( node, "VisuName", visuName ) ;
  OMASSERT( ( visuName.empty() == false ) && "The VisuName configuration parameter must be declared" ) ;
  SimulatedObject* vis( getController().getPointerToSimulatedObjectNamed( visuName ) ) ;
  OMASSERT( ( vis != NULL ) && "The VisuName configuration parameter is not a SimulatedObject" ) ;
  _ogreVis = dynamic_cast<OgreVis*>( vis ) ;
  OMASSERT( ( _ogreVis != NULL ) && "The VisuName configuration parameter is not an OgreVis" ) ;
  OMASSERT( ( _ogreVis->getRoot().isInitialised() == true ) && "The OgreVis 'VisuName' is incorrectly initialised" ) ;
}

//-------------------------------------------------------------------------
// windowResized
//-------------------------------------------------------------------------
void 
DistributedCameraListener::windowResized( RenderWindow* rw )
{
  unsigned int width( 0 ) ;
  unsigned int height( 0 ) ;
  unsigned int depth( 0 ) ;
  int left( 0 ) ;
  int top( 0 ) ;
  rw->getMetrics( width,  height, depth, left, top ) ;
  _mouse->getMouseState().width = width ;
  _mouse->getMouseState().height = height ;
}

//-------------------------------------------------------------------------
// windowClosed
//-------------------------------------------------------------------------
void 
DistributedCameraListener::windowClosed( RenderWindow* rw )
{
  //Only close for window that created OIS (the main window)
  if( rw == _ogreVis->touchRoot().getAutoCreatedWindow() )
  {
    if( _inputManager != NULL )
    {
      _inputManager->destroyInputObject( _mouse ) ;
      _inputManager->destroyInputObject( _keyboard ) ;
      OIS::InputManager::destroyInputSystem( _inputManager ) ;
      _inputManager = NULL ;
    }
    sendEvent( getController().getName(), SystemEventIdentifier::MaskStop ) ;
  }
}

//-------------------------------------------------------------------------
// processUnbufferedKeyInput
//-------------------------------------------------------------------------
bool 
DistributedCameraListener::processUnbufferedKeyInput( const FrameEvent& evt )
{
  // quit
  if( _keyboard->isKeyDown( KC_ESCAPE ) )
  {
    sendEvent( getController().getName(), SystemEventIdentifier::MaskStop ) ;
  }

  // forward
  if ( _keyboard->isKeyDown( KC_UP ) )
  {
    _transform.setTranslate( _transform.getTranslate() - ( _transform.getDirection() * _translationSpeed ) ) ;
    _updateTransform = true ;
  }

  // backward
  if ( _keyboard->isKeyDown( KC_DOWN ) )
  {
    _transform.setTranslate( _transform.getTranslate() + ( _transform.getDirection() * _translationSpeed ) ) ;
    _updateTransform = true ;
  }

  // slide left
  if ( _keyboard->isKeyDown( KC_LEFT ) )
  {
    _transform.setTranslate( _transform.getTranslate() - ( _transform.getRight() * _translationSpeed ) ) ;
    _updateTransform = true ;
  }

  // slide right
  if ( _keyboard->isKeyDown( KC_RIGHT ) )
  {
    _transform.setTranslate( _transform.getTranslate() + ( _transform.getRight() * _translationSpeed ) ) ;
    _updateTransform = true ;
  }

  // increase translation speed
  if ( _keyboard->isKeyDown( KC_ADD ) )
  {
    _translationSpeed += 1;
  }

  // decrease translation speed
  if ( _keyboard->isKeyDown( KC_SUBTRACT ) )
  {
    _translationSpeed -= ( 0 < _translationSpeed - 1 ) ? 1 : 0 ;
  }

  return true ;
}

//-------------------------------------------------------------------------
// processUnbufferedMouseInput
//-------------------------------------------------------------------------
bool 
DistributedCameraListener::processUnbufferedMouseInput( const FrameEvent& evt )
{
  if( _mouse->getMouseState().buttonDown( OIS::MB_Left ) ) 
  {
    float dx( _mouse->getMouseState().X.rel * _rotationSpeed ) ;
    float dy( _mouse->getMouseState().Y.rel * _rotationSpeed ) ;

    if ( ( dx != 0.f ) || ( dy != 0.f ) )
    {
      Matrix3f rotation ;
      // yaw (fixed to the world axis)
      rotation.FromAxisAngle( Vector3f::UNIT_Y, -dx ) ;
      _transform.setRotate( rotation * _transform.getRotate() ) ;
      // pitch
      rotation.FromAxisAngle( _transform.getRotate() * Vector3f::UNIT_X, -dy ) ;
      _transform.setRotate( rotation * _transform.getRotate() ) ;

      _updateTransform = true ;
    }
  }

  return true ;
}

//-------------------------------------------------------------------------
// frameStarted
//-------------------------------------------------------------------------
bool 
DistributedCameraListener::frameStarted( const FrameEvent& evt )
{
  bool returnCode( _ogreVis->touchRoot().getAutoCreatedWindow()->isClosed() ) ;
  if ( returnCode == false )
  {
    //Need to capture/update each device
    _keyboard->capture() ;
    _mouse->capture() ;

    returnCode = processUnbufferedKeyInput( evt ) ;
    if ( returnCode == true )
    {
      returnCode = processUnbufferedMouseInput( evt ) ;
    }
  }
  return returnCode ;
}

---