bool Vwr::CameraManipulator::handle(const GUIEventAdapter& ea, GUIActionAdapter& us)
{
switch(ea.getEventType())
{
case(GUIEventAdapter::FRAME):
{
return handleFrame(ea, us);
}
default:
break;
}
if (ea.getHandled()) return false;
switch(ea.getEventType())
{
case(GUIEventAdapter::PUSH):
{
return handlePush(ea, us);
}
case(GUIEventAdapter::RELEASE):
{
return handleRelease(ea, us);
}
case(GUIEventAdapter::DRAG):
case(GUIEventAdapter::SCROLL):
{
return handleScroll(ea, us);
}
case(GUIEventAdapter::MOVE):
{
return false;
}
case(GUIEventAdapter::KEYDOWN):
{
return handleKeyDown(ea, us);
}
case(GUIEventAdapter::KEYUP):
{
return handleKeyUp( ea, us );
}
case(GUIEventAdapter::FRAME):
{
if (_thrown)
{
if (calcMovement()) us.requestRedraw();
}
return false;
}
default:
return false;
}
}
/** Handles events. Returns true if handled, false otherwise.*/
bool StandardManipulator::handle( const GUIEventAdapter& ea, GUIActionAdapter& us )
{
switch( ea.getEventType() )
{
case GUIEventAdapter::FRAME:
return handleFrame( ea, us );
case GUIEventAdapter::RESIZE:
return handleResize( ea, us );
default:
break;
}
if( ea.getHandled() )
return false;
switch( ea.getEventType() )
{
case GUIEventAdapter::MOVE:
return handleMouseMove( ea, us );
case GUIEventAdapter::DRAG:
return handleMouseDrag( ea, us );
case GUIEventAdapter::PUSH:
return handleMousePush( ea, us );
case GUIEventAdapter::RELEASE:
return handleMouseRelease( ea, us );
case GUIEventAdapter::KEYDOWN:
return handleKeyDown( ea, us );
case GUIEventAdapter::KEYUP:
return handleKeyUp( ea, us );
case GUIEventAdapter::SCROLL:
if( _flags & PROCESS_MOUSE_WHEEL )
return handleMouseWheel( ea, us );
else
return false;
default:
return false;
}
}
bool CPanelActionListener::handle(const GUIEventAdapter& ea,GUIActionAdapter& aa)
{
switch(ea.getEventType())
{
case GUIEventAdapter::KEYDOWN:
KeyDownEvent(ea,aa);
break;
case GUIEventAdapter::PUSH:
//MousePressEvent(ea,aa);
break;
case GUIEventAdapter::DRAG:
//MouseDragEvent(ea,aa);
break;
case GUIEventAdapter::DOUBLECLICK:
MouseClickEvent(ea,aa);
break;
case GUIEventAdapter::MOVE:
//MouseMoveEvent(ea,aa);
break;
//case GUIEventAdapter::FRAME:
//displayEachLine();
//break;
default:
break;
}
return false;
}
bool CameraViewSwitchManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter&)
{
if (ea.getHandled()) return false;
switch(ea.getEventType())
{
case(GUIEventAdapter::KEYDOWN):
if (ea.getKey()=='[')
{
if (_currentView == 0)
_currentView = _cameraViews.size()-1;
else
_currentView--;
return true;
}
else if (ea.getKey()==']')
{
_currentView++;
if (_currentView >= _cameraViews.size())
_currentView = 0;
return true;
}
return false;
default:
return false;
}
}
bool ChaseCam::handle(const GUIEventAdapter& ea, GUIActionAdapter& us)
{
if (ea.getHandled()) return false;
osgGA::GUIEventAdapter::EventType et = ea.getEventType();
if (et == GUIEventAdapter::KEYDOWN || et == GUIEventAdapter::KEYUP)
{
bool onoff = (et == GUIEventAdapter::KEYDOWN);
if (ea.getKey() == GUIEventAdapter::KEY_Space) {
ship->sendInput(SpaceShipServer::ACCELERATE, onoff);
return true;
}
else if (ea.getKey() == GUIEventAdapter::KEY_Left) {
ship->sendInput(SpaceShipServer::LEFT, onoff);
return true;
}
else if (ea.getKey() == GUIEventAdapter::KEY_Right) {
ship->sendInput(SpaceShipServer::RIGHT, onoff);
return true;
}
else if (ea.getKey() == GUIEventAdapter::KEY_Up) {
ship->sendInput(SpaceShipServer::UP, onoff);
return true;
}
else if (ea.getKey() == GUIEventAdapter::KEY_Down) {
ship->sendInput(SpaceShipServer::DOWN, onoff);
return true;
}
else if (ea.getKey() == GUIEventAdapter::KEY_S) {
ship->sendInput(SpaceShipServer::BACK, onoff);
return true;
}
}
return false;
}
bool KeySwitchMatrixManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter& aa)
{
if (!_current) return false;
bool handled = false;
if (!ea.getHandled() && ea.getEventType()==GUIEventAdapter::KEYDOWN)
{
KeyManipMap::iterator it=_manips.find(ea.getKey());
if(it != _manips.end())
{
CameraManipulator* selectedManipulator = it->second.second.get();
if (selectedManipulator!=_current)
{
OSG_INFO<<"Switching to manipulator: "<<it->second.first<<std::endl;
if ( !selectedManipulator->getNode() )
{
selectedManipulator->setNode(_current->getNode());
}
selectedManipulator->setByMatrix(_current->getMatrix());
selectedManipulator->init(ea,aa);
_current = selectedManipulator;
}
handled = true;
}
}
return _current->handle(ea,aa) || handled;
}
bool StateSetManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter& aa)
{
if(!_stateset.valid()) return false;
if (!_initialized)
{
_initialized = true;
_backface = (_stateset->getMode(GL_CULL_FACE)&osg::StateAttribute::ON);
_lighting =(_stateset->getMode(GL_LIGHTING)&osg::StateAttribute::ON);
unsigned int mode = osg::StateAttribute::INHERIT|osg::StateAttribute::ON;
_texture = (_stateset->getTextureMode(0,GL_TEXTURE_2D)&mode)!=0 ||
(_stateset->getTextureMode(0,GL_TEXTURE_3D)&mode)!=0 ||
(_stateset->getTextureMode(0,GL_TEXTURE_RECTANGLE)&mode)!=0 ||
(_stateset->getTextureMode(0,GL_TEXTURE_CUBE_MAP)&mode)!=0;
#if !defined(OSG_GLES1_AVAILABLE) && !defined(OSG_GLES2_AVAILABLE)
_texture |= ((_stateset->getTextureMode(0,GL_TEXTURE_1D)&mode)!=0);
#endif
}
if (ea.getHandled()) return false;
if (ea.getEventType()==osgGA::GUIEventAdapter::KEYDOWN)
{
if ( ea.getKey() == _keyEventToggleBackfaceCulling )
{
setBackfaceEnabled(!getBackfaceEnabled());
aa.requestRedraw();
return true;
}
if ( ea.getKey() == _keyEventToggleLighting )
{
setLightingEnabled(!getLightingEnabled());
aa.requestRedraw();
return true;
}
if ( ea.getKey() == _keyEventToggleTexturing )
{
setTextureEnabled(!getTextureEnabled());
aa.requestRedraw();
return true;
}
if ( ea.getKey() == _keyEventCyclePolygonMode )
{
cyclePolygonMode();
aa.requestRedraw();
return true;
}
}
return false;
}
void GliderManipulator::init(const GUIEventAdapter& ea,GUIActionAdapter& us)
{
flushMouseEventStack();
us.requestContinuousUpdate(false);
_velocity = 0.2f;
if (ea.getEventType()!=GUIEventAdapter::RESIZE)
{
us.requestWarpPointer((ea.getXmin()+ea.getXmax())/2.0f,(ea.getYmin()+ea.getYmax())/2.0f);
}
}
void PanoManipulator::init(const GUIEventAdapter& ea,GUIActionAdapter& us)
{
flushMouseEventStack();
us.requestContinuousUpdate(false);
_velocity = 0.0f;
if (ea.getEventType()!=GUIEventAdapter::RESIZE)
{
// warp pointer no longer needed
//us.requestWarpPointer((ea.getXmin()+ea.getXmax())/2.0f,(ea.getYmin()+ea.getYmax())/2.0f);
} // if
} // PanoManipulator::init
bool Head::handle( const GUIEventAdapter & ea, GUIActionAdapter & aa )
{
switch ( ea.getEventType() )
{
case osgGA::GUIEventAdapter::KEYDOWN:
switch ( ea.getKey() )
{
case '1':
shape->setColor(Vec4(1.0f, 0.0f, 0.0f, 1.0f));
break;
case '0': case '2': case '3': case '4':
case '5': case '6': case '7': case '8':
case '9':
shape->setColor(Vec4(1.0f, 1.0f, 1.0f, 1.0f));
break;
}
}
return false;
}
bool KeyboardEventHandler::handle(const GUIEventAdapter& ea, GUIActionAdapter&)
{
switch(ea.getEventType())
{
case GUIEventAdapter::KEYDOWN :
{
//to pull up help menu and pause running state
if(ea.getKey() == 'h' || ea.getKey() == 'H')
{
if(GLOBAL->gSimState & RUNNING)
{ //show help and pause
GLOBAL->gHUD_HelpGeode->setNodeMask(0xFFFFFF);
GLOBAL->gHUD_HelpTextGeode->setNodeMask(0xFFFFFF);
GLOBAL->gSimState ^= RUNNING;
GLOBAL->gHUD_TimeText->setText("Firing Paused");
}
else {
GLOBAL->gSimState |= RUNNING;
GLOBAL->gHUD_HelpGeode->setNodeMask(0);
GLOBAL->gHUD_HelpTextGeode->setNodeMask(0);
}
}
//only accept all other key input if running
if(GLOBAL->gSimState & RUNNING)
switch(ea.getKey())
{
//FILTERING CONTROLS
case ( 'N' ) :
ToggleVisibility(GLOBAL->gSomaGeode.get());
break;
case ( 'n' ) :
ToggleVisibility(GLOBAL->gSynapseGeode.get());
break;
case ( 'l' ) :
ToggleVisibility(GLOBAL->gLinesGeode.get());
break;
case ( 'v' ) :
FilterSynapses();
break;
case ( 'V' ) :
FilterSomas();
break;
//MOTION CONTROLS
//translations
case 'w' :
case 'W' :
_fpm->moveForward(GLOBAL->gCamSpeed);
break;
case 'a':
case 'A':
_fpm->moveRight(-GLOBAL->gCamSpeed);
break;
case 's' :
case 'S' :
_fpm->moveForward(-GLOBAL->gCamSpeed);
break;
case 'd' :
case 'D' :
_fpm->moveRight(GLOBAL->gCamSpeed);
break;
case 'e' :
case 'E' :
_fpm->moveUp(GLOBAL->gCamSpeed/2);
break;
case 'x' :
case 'X' :
_fpm->moveUp(-GLOBAL->gCamSpeed/2);
break;
//rotations
case ( osgGA::GUIEventAdapter::KEY_Up ) :
_fpm->rotateUp(GLOBAL->gCamRotSpeed);
break;
case ( osgGA::GUIEventAdapter::KEY_Down ) :
_fpm->rotateDown(GLOBAL->gCamRotSpeed);
break;
case ( osgGA::GUIEventAdapter::KEY_Left ) :
_fpm->rotateLeft(GLOBAL->gCamRotSpeed);
break;
case ( osgGA::GUIEventAdapter::KEY_Right ) :
_fpm->rotateRight(GLOBAL->gCamRotSpeed);
break;
//speed control
case ( '-' ) :
GLOBAL->gCamSpeed *= 0.5;
break;
case ( '=' ) :
GLOBAL->gCamSpeed *=1.5;
break;
case ( '_' ) :
GLOBAL->gCamRotSpeed *= 0.5;
break;
case ( '+' ) :
GLOBAL->gCamRotSpeed *= 1.5;
break;
//firing control
case 'g' ://start/pause
if(GLOBAL->gSimState & FIRING_ACTIVE)
{
GLOBAL->gSimState ^= FIRING_ACTIVE;
GLOBAL->gHUD_TimeText->setText("Firing Paused");
}
else GLOBAL->gSimState |= FIRING_ACTIVE;
break;
case 'G' ://reset
GLOBAL->gFiringTimeElapsed = 0;
break;
case 'c':
GLOBAL->SetCenter();
break;
case 'C':
case osgGA::GUIEventAdapter::KEY_Space :
GLOBAL->gOrbitCenter = Vec3d(0,0,0);
GLOBAL->gOrbitManipulator->setCenter(GLOBAL->gOrbitCenter);
break;
default:
break;
}
break;
}
default:
break;
}
return false;
}
bool RightLeg::handle(const GUIEventAdapter & ea, GUIActionAdapter & aa)
{
Matrix matX, matY, matZ;
switch ( ea.getEventType() )
{
case osgGA::GUIEventAdapter::KEYDOWN:
switch ( ea.getKey() )
{
case GUIEventAdapter::KEY_Shift_L:case GUIEventAdapter::KEY_Shift_R:
isShiftKeyPressed = true;
break;
case GUIEventAdapter::KEY_Right:
if(isSelected && !isShiftKeyPressed)
{
if(rotationAngleY < DegreesToRadians(45.0)){
rotationAngleY += PI/180;
matY = Matrix::rotate(PI/180, rotationVectorY);
transform->setMatrix(matY*transform->getMatrix());
}
}
if(isSelected && isShiftKeyPressed)
{
if(rotationAngleZ < DegreesToRadians(10.0))
{
rotationAngleZ += PI/180;
matZ = Matrix::rotate(PI/180, rotationVectorZ);
transform->setMatrix(matZ*transform->getMatrix());
}
}
break;
case GUIEventAdapter::KEY_Left:
if(isSelected && !isShiftKeyPressed)
{
if(rotationAngleY > DegreesToRadians(0.0f)){
rotationAngleY -= PI/180;
matY = Matrix::rotate(-PI/180, rotationVectorY);
transform->setMatrix(matY*transform->getMatrix());
}
}
if(isSelected && isShiftKeyPressed)
{
if(rotationAngleZ > DegreesToRadians(0.0f)){
rotationAngleZ -= PI/180;
matZ = Matrix::rotate(-PI/180, rotationVectorZ);
transform->setMatrix(matZ*transform->getMatrix());
}
}
break;
case GUIEventAdapter::KEY_Up:
if(isSelected)
{
if(rotationAngleX < DegreesToRadians(90.0))
{
rotationAngleX += PI/180;
matX = Matrix::rotate(PI/180, rotationVectorX);
transform->setMatrix(matX*transform->getMatrix());
}
}
break;
case GUIEventAdapter::KEY_Down:
if(isSelected)
{
if(rotationAngleX > DegreesToRadians(0.0f))
{
rotationAngleX -= PI/180;
matX = Matrix::rotate(-PI/180, rotationVectorX);
transform->setMatrix(matX*transform->getMatrix());
}
}
break;
case '7':
shape->setColor(Vec4(1.0f, 0.0f, 0.0f, 1.0f));
isSelected = true;
break;
case '1': case '2': case '3': case '4':
case '5': case '6': case '9': case '8':
case '0':
shape->setColor(Vec4(1.0f, 1.0f, 1.0f, 1.0f));
isSelected = false;
break;
}
break;
case GUIEventAdapter::KEYUP:
if(ea.getKey() == GUIEventAdapter::KEY_Shift_L || ea.getKey() == GUIEventAdapter::KEY_Shift_R)
isShiftKeyPressed = false;
break;
}
return false;
}
bool TerrainManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter& us)
{
switch(ea.getEventType())
{
case(GUIEventAdapter::FRAME):
if (_thrown)
{
if (calcMovement()) us.requestRedraw();
}
return false;
default:
break;
}
if (ea.getHandled()) return false;
switch(ea.getEventType())
{
case(GUIEventAdapter::PUSH):
{
flushMouseEventStack();
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
return true;
}
case(GUIEventAdapter::RELEASE):
{
if (ea.getButtonMask()==0)
{
if (isMouseMoving())
{
if (calcMovement())
{
us.requestRedraw();
us.requestContinuousUpdate(true);
_thrown = true;
}
}
else
{
flushMouseEventStack();
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
}
}
else
{
flushMouseEventStack();
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
}
return true;
}
case(GUIEventAdapter::DRAG):
{
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
return true;
}
case(GUIEventAdapter::MOVE):
{
return false;
}
case(GUIEventAdapter::KEYDOWN):
if (ea.getKey()== GUIEventAdapter::KEY_Space)
{
flushMouseEventStack();
_thrown = false;
home(ea,us);
us.requestRedraw();
us.requestContinuousUpdate(false);
return true;
}
return false;
default:
return false;
}
}
// --------------------------------------------------------------------------------------------------
bool SphericalManipulator::handle(const GUIEventAdapter &ea, GUIActionAdapter &us)
{
switch (ea.getEventType())
{
case (GUIEventAdapter::FRAME):
{
double current_frame_time = ea.getTime();
_delta_frame_time = current_frame_time - _last_frame_time;
_last_frame_time = current_frame_time;
if (_thrown)
{
if (calcMovement())
us.requestRedraw();
}
return false;
}
default:
break;
}
if (ea.getHandled())
return false;
switch (ea.getEventType())
{
case (GUIEventAdapter::PUSH):
{
flushMouseEventStack();
addMouseEvent(ea);
us.requestContinuousUpdate(false);
_thrown = false;
return true;
}
case (GUIEventAdapter::RELEASE):
{
if (ea.getButtonMask() == 0)
{
double timeSinceLastRecordEvent = _ga_t0.valid() ? (ea.getTime() - _ga_t0->getTime()) : DBL_MAX;
if (timeSinceLastRecordEvent > 0.02)
flushMouseEventStack();
if (isMouseMoving())
{
if (calcMovement())
{
us.requestRedraw();
us.requestContinuousUpdate(true);
_thrown = _allowThrow;
}
}
else
{
flushMouseEventStack();
addMouseEvent(ea);
if (calcMovement())
us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
}
}
else
{
flushMouseEventStack();
addMouseEvent(ea);
if (calcMovement())
us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
}
return true;
}
case (GUIEventAdapter::DRAG):
case (GUIEventAdapter::SCROLL):
{
addMouseEvent(ea);
if (calcMovement())
us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
return true;
}
case (GUIEventAdapter::MOVE):
{
return false;
}
case (GUIEventAdapter::KEYDOWN):
if (ea.getKey() == GUIEventAdapter::KEY_Space)
{
flushMouseEventStack();
_thrown = false;
home(ea, us);
return true;
}
return false;
case (GUIEventAdapter::FRAME):
if (_thrown)
{
if (calcMovement())
us.requestRedraw();
}
return false;
default:
return false;
}
return false;
}
bool GliderManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter& us)
{
switch(ea.getEventType())
{
#if 0
case(GUIEventAdapter::PUSH):
{
addMouseEvent(ea);
us.requestContinuousUpdate(true);
if (calcMovement()) us.requestRedraw();
return true;
}
case(GUIEventAdapter::RELEASE):
{
addMouseEvent(ea);
us.requestContinuousUpdate(true);
// if (calcMovement()) us.requestRedraw();
return true;
}
case(GUIEventAdapter::DRAG):
{
addMouseEvent(ea);
us.requestContinuousUpdate(true);
// if (calcMovement()) us.requestRedraw();
return true;
}
case(GUIEventAdapter::MOVE):
{
addMouseEvent(ea);
us.requestContinuousUpdate(true);
// if (calcMovement()) us.requestRedraw();
return true;
}
#endif
case(GUIEventAdapter::KEYDOWN):
if (ea.getKey()==' ')
{
flushMouseEventStack();
home(ea,us);
us.requestRedraw();
us.requestContinuousUpdate(false);
return true;
}
else if (ea.getKey()=='q')
{
_yawMode = YAW_AUTOMATICALLY_WHEN_BANKED;
return true;
}
else if (ea.getKey()=='a')
{
_yawMode = NO_AUTOMATIC_YAW;
return true;
}
return false;
case(GUIEventAdapter::FRAME):
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
return true;
case(GUIEventAdapter::RESIZE):
init(ea,us);
us.requestRedraw();
return true;
default:
return false;
}
}
bool LeftHand::handle(const GUIEventAdapter & ea, GUIActionAdapter & aa)
{
Matrix matrixX, matrixY;
switch ( ea.getEventType() )
{
case osgGA::GUIEventAdapter::KEYDOWN:
switch ( ea.getKey() )
{
case GUIEventAdapter::KEY_Up:
if(isSelected)
{
if(rotationAngleX < DegreesToRadians(90.0)){
rotationAngleX += PI/180;
matrixX = Matrix::rotate(Quat(PI/180, rotationAxisX));
transform->setMatrix(matrixX*matrixY*transform->getMatrix());
}
}
break;
case GUIEventAdapter::KEY_Down:
if(isSelected)
{
if(rotationAngleX > DegreesToRadians(0.0f)){
rotationAngleX -= PI/180;
matrixX = Matrix::rotate(Quat(-PI/180, rotationAxisX));
transform->setMatrix(matrixX*matrixY*transform->getMatrix());
}
}
break;
case GUIEventAdapter::KEY_Left:
if(isSelected)
{
if(rotationAngleY < DegreesToRadians(45.0))
{
rotationAngleY += PI/180;
matrixY = Matrix::rotate(Quat(PI/180, rotationAxisY));
transform->setMatrix(matrixY*matrixX*transform->getMatrix());
}
}
break;
case GUIEventAdapter::KEY_Right:
if(isSelected)
{
if(rotationAngleY > DegreesToRadians(0.0))
{
rotationAngleY -= PI/180;
matrixY = Matrix::rotate(Quat(-PI/180, rotationAxisY));
transform->setMatrix(matrixY*matrixX*transform->getMatrix());
}
}
break;
case '2':
shape->setColor(Vec4(1.0f, 0.0f, 0.0f, 1.0f));
isSelected = true;
break;
case '1': case '9': case '3': case '4':
case '5': case '6': case '7': case '8':
case '0':
shape->setColor(Vec4(1.0f, 1.0f, 1.0f, 1.0f));
isSelected = false;
break;
}
}
return false;
}
bool KeyboardHandler::handle( const GUIEventAdapter& ea, GUIActionAdapter& aa)
{
switch(ea.getEventType())
{
case(osgGA::GUIEventAdapter::KEYDOWN):
//Enleve les avertissements a l'ecran lors de la prochaine touche enfoncé
_hud->selectAPhysic(false);
switch(ea.getKey())
{
// Fleche : Rotation///////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_Up :
_world->getSelected()->event_RotationHaut(true);
return false;
case osgGA::GUIEventAdapter::KEY_Right :
_world->getSelected()->event_RotationDroite(true);
return false;
case osgGA::GUIEventAdapter::KEY_Left :
_world->getSelected()->event_RotationGauche(true);
return false;
case osgGA::GUIEventAdapter::KEY_Down :
_world->getSelected()->event_RotationBas(true);
return false;
// a : Effet Sable/////////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_A :
//_world->getSelected()->restoreSubdivision();
_world->setSandWorld();
_hud->setColorHud(Vec4(1.0f, 1.0f, 1.0f, 1.0f));
return false;
// z : Effet Fireworks/////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_Z :
//_world->getSelected()->restoreSubdivision();
_world->setFireworksWorld();
_hud->setColorHud(Vec4(1.0f, 1.0f, 1.0f, 1.0f));
return false;
// q : Effet Explosion/////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_E :
//_world->getSelected()->restoreSubdivision();
_world->setExplosionWorld();
_hud->setColorHud(Vec4(1.0f, 1.0f, 1.0f, 1.0f));
return false;
// s : Effet Vague/////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_R :
//_world->getSelected()->restoreSubdivision();
_world->setWaveWorld();
_hud->setColorHud(Vec4(1.0f, 1.0f, 1.0f, 1.0f));
return false;
// s : Effet Battement coeur/////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_T :
//_world->getSelected()->restoreSubdivision();
_world->setHeartWorld();
_hud->setColorHud(Vec4(1.0f, 1.0f, 1.0f, 1.0f));
return false;
// s : Effet Bizarre/////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_Y :
//_world->getSelected()->restoreSubdivision();
_world->setWeirdWorld();
_hud->setColorHud(Vec4(0.0f, 0.0f, 0.0f, 1.0f));
return false;
// r : Rejouer animation///////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_Space :
_world->restoreSelected();
return false;
// w : Cube////////////////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_W :
_hud->loading(true);
_viewer->frame();
_world->setModelName("cubeOSG");
_world->loadModel();
_hud->loading(false);
return false;
// x : Icosphere///////////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_X :
_hud->loading(true);
_viewer->frame();
_world->setModelName("icosphere");
_world->loadModel();
_hud->loading(false);
return false;
// c : Suzanne/////////////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_C :
_hud->loading(true);
_viewer->frame();
_world->setModelName("suzanne");
_world->loadModel();
_hud->loading(false);
return false;
// v : Coeur//////////////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_V :
_hud->loading(true);
_viewer->frame();
_world->setModelName("coeur");
_world->loadModel();
_hud->loading(false);
return false;
// + : Nombre subdiv ++///////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_KP_Add :
case osgGA::GUIEventAdapter::KEY_Plus :
_world->subPlus();
_hud->update();
return false;
// - : Nombre subdiv --///////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_KP_Subtract :
case osgGA::GUIEventAdapter::KEY_Minus :
_world->subMoins();
_hud->update();
return false;
// entrer : sub OK////////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_Return :
_hud->subdivisionInProgress(true);
_viewer->frame(); //Actualise l'image pour afficher "Subdivision en cours..." avant la subdivision
_world->subOK();
_hud->subdivisionInProgress(false);
return false;
// tab : stop physique////////////////////////////////////////////////////////////////////////////////
case osgGA::GUIEventAdapter::KEY_Tab :
if(_world->getPhysics() != NULL)
{
_world->pausePhys();
_hud->updatePause();
}
else
_hud->selectAPhysic(true);
return false;
default:
break;
}
default:
return false;
}
}
bool PanoManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter& us)
{
if(StartMoment == 0.0) // only do this once at actual startup of drawing
{
ClearStartMoment();
} // if
unsigned int buttonMask = ea.getButtonMask();
switch(ea.getEventType())
{
case(GUIEventAdapter::PUSH):
{
GlobalTipSupport->HideBalloonTip();
if(GetGlobalViewer())
{
SetCapture(GetGlobalViewerHWND());
} // if
if((buttonMask & GUIEventAdapter::LEFT_MOUSE_BUTTON) && (Navigation::GetCurrentNavMode() == Navigation::NAV_NM_QUERY))
{
PossibleQueryInitiating = true;
} // if
else
{
if(buttonMask & GUIEventAdapter::MIDDLE_MOUSE_BUTTON)
{ // determine and record orbit point
osg::Vec3 NewOrbitCenter;
if(GetFirstTangibleHitLocation(ea.getX(), ea.getY(), NewOrbitCenter))
{
SetOrbitCenter(NewOrbitCenter);
} // if
else
{
ClearOrbitCenter();
} // else
} // if
PossibleQueryInitiating = false;
addMouseEvent(ea);
us.requestContinuousUpdate(true);
if(GetDelayedGoto())
{
Goto(ea.getX(), ea.getY());
} // if
else
{
if (calcMovement(ea, us)) us.requestRedraw();
} // else
} // if
return true;
} // PUSH
case(GUIEventAdapter::RELEASE):
{
if(buttonMask & GUIEventAdapter::MIDDLE_MOUSE_BUTTON)
{
ClearOrbitCenter();
} // if
if(GetGlobalViewer())
{
if(GetCapture() == GetGlobalViewerHWND())
{
ReleaseCapture();
} // if
} // if
addMouseEvent(ea);
us.requestContinuousUpdate(true);
if(Navigation::GetCurrentNavMode() == Navigation::NAV_NM_QUERY)
{
#ifdef NVW_SUPPORT_QUERYACTION
// Query/Action fires on mouseUP, to no weird state is interfering with newly-opened windows
if(PossibleQueryInitiating) PerformQueryAction(ea.getX(), ea.getY(), false);
#endif // NVW_SUPPORT_QUERYACTION
} // if
else
{
PossibleQueryInitiating = false;
if (calcMovement(ea, us)) us.requestRedraw();
} // else
return true;
} // RELEASE
case(GUIEventAdapter::DRAG):
{
addMouseEvent(ea);
us.requestContinuousUpdate(true);
if (calcMovement(ea, us)) us.requestRedraw();
return true;
} // DRAG
case(GUIEventAdapter::MOVE):
{
MarkLastMouseMoveMoment();
addMouseEvent(ea);
us.requestContinuousUpdate(true);
if (calcMovement(ea, us)) us.requestRedraw();
return true;
} // MOVE
case(GUIEventAdapter::KEYDOWN):
{
if (ea.getKey()==' ')
{
GlobalTipSupport->HideBalloonTip();
EventDispatcher::DispatchEvent(EventDispatcher::NVW_EC_NAVIGATION, EventDispatcher::NVW_ESC_NAVIGATION_THROTTLE, EventDispatcher::NVW_PC_ZERO);
flushMouseEventStack();
home(ea,us);
us.requestRedraw();
us.requestContinuousUpdate(false);
return true;
} // if
if (ea.getKey()=='.')
{
GlobalTipSupport->HideBalloonTip();
EventDispatcher::DispatchEvent(EventDispatcher::NVW_EC_NAVIGATION, EventDispatcher::NVW_ESC_NAVIGATION_THROTTLE, EventDispatcher::NVW_PC_ZERO);
flushMouseEventStack();
halt(ea,us);
us.requestRedraw();
us.requestContinuousUpdate(false);
return true;
} // if
return false;
} // KEYDOWN
case(GUIEventAdapter::FRAME):
{
if(!GetMouseInactiveOneShot() && GetMouseInactiveTime() > NVW_PANOMANIPULATOR_MOUSE_INACTIVE_TIME_SECONDS && (GetSystemTimeFP() - GetLastMovementMoment()) > NVW_PANOMANIPULATOR_MOUSE_INACTIVE_TIME_SECONDS)
{
SetMouseInactiveOneShot(true); // make it only fire once
EventDispatcher::DispatchEvent(EventDispatcher::NVW_EC_ACTION, EventDispatcher::NVW_ESC_ACTION_QUERYHERE, EventDispatcher::NVW_PC_LESS);
} // if
GlobalTipSupport->HandleBalloonTipTimeout();
addMouseEvent(ea);
if(GetTourInProgress())
{
GlobalTipSupport->HideBalloonTip();
InternalTour();
// we don't redraw, as the animation part of the tour is handled by Transition code, below
} // if
if(GetTransitionInProgress())
{
GlobalTipSupport->HideBalloonTip();
InternalTrans();
us.requestRedraw();
} // if
else if(GetAnimationInProgress())
{
GlobalTipSupport->HideBalloonTip();
InternalAnim();
us.requestRedraw();
} // if
else
{
// handle HotNav disk
if(MasterScene.GetHotNavFwdBackAmount() != 0.0 || MasterScene.GetHotNavSideAmount() != 0.0 )
{
GlobalTipSupport->HideBalloonTip();
ExecuteMovement(MasterScene.GetHotNavSideAmount(), MasterScene.GetHotNavFwdBackAmount(), 0.0);
us.requestRedraw();
} // if
// handle HotTurn disk
if(MasterScene.GetHotTurnHAmount() != 0.0 || MasterScene.GetHotTurnVAmount() != 0.0 )
{
// hot turn is too hot without the constant scaling factor
GlobalTipSupport->HideBalloonTip();
ExecuteRotate(MasterScene.GetHotTurnHAmount() * .01, 0.0, MasterScene.GetHotTurnVAmount() * .01);
us.requestRedraw();
} // if
if (calcMovement(ea, us)) us.requestRedraw();
} // else
return true;
} // FRAME
case(GUIEventAdapter::RESIZE):
{
GlobalTipSupport->HideBalloonTip();
init(ea,us);
us.requestRedraw();
return true;
} // RESIZE
default:
return false;
} // switch
} // PanoManipulator::handle
//Event Listener
bool ViroManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter& us){
_lastFrameTime = ea.getTime();
switch( ea.getEventType() ){
case(GUIEventAdapter::FRAME):{
addMouseEvent(ea);
// Main auto-management engine
if (RollWithYaw >0.0 || isEnabled(COLLISIONS)) AutoControl( ea.time() );
// Check if Trace is needed
if ( _bNeedUpdateTrace ) Trace();
// Handle Fly-To if any
if (_bFlying) handleFlyToTransition( ea.time() );
if ( MouseListener() ) us.requestRedraw();
us.requestContinuousUpdate(true);
return false;
}
case(GUIEventAdapter::RESIZE):{
init(ea,us);
us.requestRedraw();
return true;
}
case(GUIEventAdapter::MOVE):{
addMouseEvent(ea);
if ( MouseListener() ) us.requestRedraw();
us.requestContinuousUpdate(true);
return true;
}
case(GUIEventAdapter::SCROLL):{
//addMouseEvent(ea);
//osg::notify(ALWAYS) << "Scroll\n";
switch (ea.getScrollingMotion()){
case(GUIEventAdapter::SCROLL_UP):{
addMouseEvent(ea);
osg::notify(ALWAYS) << "Scroll-up\n";
if ( MouseListener() ) us.requestRedraw();
us.requestContinuousUpdate(true);
return true;
}
case(GUIEventAdapter::SCROLL_DOWN):{
addMouseEvent(ea);
osg::notify(ALWAYS) << "Scroll-down\n";
if ( MouseListener() ) us.requestRedraw();
us.requestContinuousUpdate(true);
return true;
}
}
//if ( MouseListener() ) us.requestRedraw();
//us.requestContinuousUpdate(true);
//return true;
}
/* OLD IMPLEMENTATION for OSG 1.0
case(GUIEventAdapter::SCROLL_UP):{
addMouseEvent(ea);
osg::notify(ALWAYS) << "Scroll-up\n";
if ( MouseListener() ) us.requestRedraw();
us.requestContinuousUpdate(true);
return true;
}
case(GUIEventAdapter::SCROLL_DOWN):{
addMouseEvent(ea);
osg::notify(ALWAYS) << "Scroll-down\n";
if ( MouseListener() ) us.requestRedraw();
us.requestContinuousUpdate(true);
return true;
}
*/
// double click
/*
case(GUIEventAdapter::DOUBLECLICK):{
osg::notify(DEBUG_INFO)<<"Double Left click.\n";
_bSatMode = false;
if (handlePick(_ev0->getXnormalized(),_ev0->getYnormalized())&&!_bFlying) FlyTo(ea.time());
}
*/
// Mouse Button Push
case(GUIEventAdapter::PUSH):{
//addMouseEvent(ea);
// Mid Button
if (ea.getButtonMask() == GUIEventAdapter::MIDDLE_MOUSE_BUTTON){
//osg::notify(DEBUG_INFO)<<"Mid-Mouse pressed.\n";
//_bSatMode = false;
_bMidButton = true;
// During a Fly-To, stop flying...
if (_bFlying){
_speed = 0.0;
_bFlying = false;
Disable(PERIPHERAL_LOCK);
}
else {
float a = 0.4;
if (_bHoldCTRL) a = 0.0;
if (!_Viewer && handlePick(_ev0->getX() ,_ev0->getY(),a) &&!_bFlying) FlyTo(ea.time());
else if (handlePick(_ev0->getXnormalized(),_ev0->getYnormalized(),a) &&!_bFlying) FlyTo(ea.time());
}
}
// Left Button
else if (ea.getButtonMask() == GUIEventAdapter::LEFT_MOUSE_BUTTON){
// Double-Click
/*
if ((ea.time() -_tLastLMB) < 0.4){
osg::notify(DEBUG_INFO)<<"Double Left click.\n";
_bSatMode = false;
//if (handlePick(_ev0->getXnormalized(),_ev0->getYnormalized())&&!_bFlying) FlyTo(ea.time());
//if (handlePick(_ev0->getX(),_ev0->getY())&&!_bFlying) FlyTo(ea.time());
if (!_Viewer && handlePick(_ev0->getX() ,_ev0->getY())&&!_bFlying) FlyTo(ea.time());
else if (handlePick(_ev0->getXnormalized(),_ev0->getYnormalized())&&!_bFlying) FlyTo(ea.time());
}
*/
// Single Click
/* else */ {
osg::notify(DEBUG_INFO)<<"Left Button pressed.\n";
// During a Fly-To, stop flying...
if (_bFlying){
_bFlying = false;
//Disable(PERIPHERAL_LOCK);
}
_speed = 0.0;
_UserControlPercentage = 1.0;
}
_tLastLMB = ea.time(); // Update time last LMB.
}
// Right Button
else if (ea.getButtonMask() == GUIEventAdapter::RIGHT_MOUSE_BUTTON){
Disable(PERIPHERAL_LOCK);
/*
if (_bHoldCTRL){
if (!_bFlying && handlePick(_ev0->getXnormalized(),_ev0->getYnormalized())) _vLastPickedPoint = _vStoredEye[TO];
}
*/
}
if ( MouseListener() ) us.requestRedraw();
//us.requestContinuousUpdate(true);
return true;
}
case(GUIEventAdapter::RELEASE):{
Enable(PERIPHERAL_LOCK);
if (ea.getButtonMask() == GUIEventAdapter::MIDDLE_MOUSE_BUTTON){
_bMidButton = false;
}
//handleRelease( ea );
us.requestContinuousUpdate(false);
return true;
}
// Keyboard
case(GUIEventAdapter::KEYDOWN):{
//osg::notify(DEBUG_INFO) << "A key has been pressed...\n";
if (ea.getKey()==GUIEventAdapter::KEY_Control_L){
_bHoldCTRL = true;
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()==' '){
flushMouseEventStack();
//home(ea,us);
requestFlyToHome();
FlyTo( ea.getTime() );
us.requestRedraw();
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== 'v'){
flushMouseEventStack();
//_vStoredEye[ViroManipulator::TO] = _vEye; OLD
//_qStoredRotation[ViroManipulator::TO] = _qRotation; OLD
storeView();
osg::notify(ALWAYS) << "Position stored. Press 'c' when you want to recall it.\n";
us.requestContinuousUpdate(false);
return true;
}
/*
if (ea.getKey()== 'c'){
flushMouseEventStack();
osg::notify(ALWAYS) << "Recalled stored position.\n";
//FlyTo( ea.time() ); OLD
reloadView();
us.requestRedraw();
us.requestContinuousUpdate(false);
return true;
}
*/
if (ea.getKey()== 'S'){
flushMouseEventStack();
Invert(SPIDERMAN_PICKING);
if (isEnabled(SPIDERMAN_PICKING)) osg::notify(ALWAYS) << "SpiderMan Mode ON.\n";
else osg::notify(ALWAYS) << "SpiderMan Mode OFF.\n";
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== GUIEventAdapter::KEY_Up){
_padEvent = NAVPAD_FORWARD;
us.requestContinuousUpdate(false);
}
if (ea.getKey()== GUIEventAdapter::KEY_Down){
_padEvent = NAVPAD_BACKWARD;
us.requestContinuousUpdate(false);
}
if (ea.getKey()== GUIEventAdapter::KEY_Page_Up){
_padEvent = NAVPAD_UP;
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== GUIEventAdapter::KEY_Left){
_padEvent = NAVPAD_STRAFELEFT;
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== GUIEventAdapter::KEY_Right){
_padEvent = NAVPAD_STRAFERIGHT;
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== GUIEventAdapter::KEY_Page_Down){
_padEvent = NAVPAD_DOWN;
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== 'f'){
// TODO : Switch Fullscreen ON/OFF
return true;
}
if (ea.getKey()== 'l' || ea.getKey()== 'L'){
/*
_HeadLight->getLight()->setLightNum(3);
_HeadLight->getLight()->setDiffuse( Vec4(1,1,1, 0) );
_HeadLight->getLight()->setDirection( _vLook );
_HeadLight->getLight()->setPosition( Vec4(_vEye.x(),_vEye.y(),_vEye.z(), 0) );
*/
//_bLockZ = !_bLockZ;
Invert(Z_LOCK);
if ( isEnabled(Z_LOCK) ){
_zLock = _vEye.z();
/*
SyncData();
osg::Vec3d D = _vLook;
D.normalize();
_vLockDir = D;
*/
}
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== 'c' || ea.getKey()== 'C'){
flushMouseEventStack();
Invert(COLLISIONS);
//if (isEnabled(COLLISIONS)) osg::notify(ALWAYS) << "Model Collision ON.\n";
//else osg::notify(ALWAYS) << "Model Collision OFF.\n";
us.requestContinuousUpdate(false);
return true;
}
/*
if (ea.getKey()== 'i'){
flushMouseEventStack();
_Viewer->getCamera()->setProjectionMatrixAsPerspective(30.0,3, 0.01,50);
us.requestContinuousUpdate(false);
return true;
}
*/
if (ea.getKey()== 'g' || ea.getKey()== 'w'){
flushMouseEventStack();
Invert(GRAVITY);
//if (isEnabled(GRAVITY)) osg::notify(ALWAYS) << "Gravity ON.\n";
//else osg::notify(ALWAYS) << "Gravity OFF.\n";
us.requestContinuousUpdate(false);
return true;
}
// Keyboard navigation
if (ea.getKey()== 'a'){
/*
//flushMouseEventStack();
Enable(PERIPHERAL_LOCK);
double d = 50.;
turn( d*getDtime(), 0.0);
SyncData();
*/
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== 'd'){
/*
//flushMouseEventStack();
Enable(PERIPHERAL_LOCK);
double d = 50.;
turn(-d* getDtime(), 0.0);
SyncData();
*/
us.requestContinuousUpdate(false);
return true;
}
if (0&& ea.getKey()== 'w'){
/*
//flushMouseEventStack();
Enable(PERIPHERAL_LOCK);
_speed += Acceleration * getDtime();
boost();
SyncData();
*/
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== 's'){
/*
//flushMouseEventStack();
Enable(PERIPHERAL_LOCK);
_speed = 0.0;
*/
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== 'x'){
/*
//flushMouseEventStack();
Enable(PERIPHERAL_LOCK);
_speed -= Acceleration * getDtime();
boost();
SyncData();
*/
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== '+'){
double l,r,b,t,z,Z;
_Viewer->getCamera()->getProjectionMatrixAsFrustum(l,r,b,t,z,Z);
l *= 0.9;
r *= 0.9;
b *= 0.9;
t *= 0.9;
_Viewer->getCamera()->setProjectionMatrixAsFrustum(l,r,b,t,z,Z);
us.requestContinuousUpdate(false);
return true;
}
if (ea.getKey()== '-'){
double l,r,b,t,z,Z;
_Viewer->getCamera()->getProjectionMatrixAsFrustum(l,r,b,t,z,Z);
l *= 1.1;
r *= 1.1;
b *= 1.1;
t *= 1.1;
_Viewer->getCamera()->setProjectionMatrixAsFrustum(l,r,b,t,z,Z);
us.requestContinuousUpdate(false);
return true;
}
return true;
}
case(GUIEventAdapter::KEYUP):{
_padEvent = NAVPAD_NONE;
if (ea.getKey()==GUIEventAdapter::KEY_Control_L){
_bHoldCTRL = false;
us.requestContinuousUpdate(false);
return true;
}
return true;
}
default: return false;
}
// return false;
}
void DriveManipulator::init(const GUIEventAdapter& ea,GUIActionAdapter& us)
{
flushMouseEventStack();
us.requestContinuousUpdate(false);
_velocity = 0.0;
osg::Vec3d ep = _eye;
osg::CoordinateFrame cf=getCoordinateFrame(ep);
Matrixd rotation_matrix;
rotation_matrix.makeRotate(_rotation);
osg::Vec3d sv = osg::Vec3d(1.0,0.0,0.0) * rotation_matrix;
osg::Vec3d bp = ep;
bp -= getUpVector(cf)*_modelScale;
bool positionSet = false;
osg::Vec3d ip, np;
if (intersect(ep, bp, ip, np))
{
osg::Vec3d uv;
if (np*getUpVector(cf)>0.0) uv = np;
else uv = -np;
ep = ip+uv*_height;
osg::Vec3d lv = uv^sv;
computePosition(ep,ep+lv,uv);
positionSet = true;
}
if (!positionSet)
{
bp = ep;
bp += getUpVector(cf)*_modelScale;
if (intersect(ep, bp, ip, np))
{
osg::Vec3d uv;
if (np*getUpVector(cf)>0.0f) uv = np;
else uv = -np;
ep = ip+uv*_height;
osg::Vec3d lv = uv^sv;
computePosition(ep,ep+lv,uv);
positionSet = true;
}
}
if (ea.getEventType()!=GUIEventAdapter::RESIZE)
{
us.requestWarpPointer((ea.getXmin()+ea.getXmax())/2.0f,(ea.getYmin()+ea.getYmax())/2.0f);
}
}
bool DriveManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter& us)
{
switch(ea.getEventType())
{
case(GUIEventAdapter::FRAME):
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
return false;
case(GUIEventAdapter::RESIZE):
init(ea,us);
us.requestRedraw();
return true;
default:
break;
}
if (ea.getHandled()) return false;
switch(ea.getEventType())
{
case(GUIEventAdapter::PUSH):
{
addMouseEvent(ea);
us.requestContinuousUpdate(true);
if (calcMovement()) us.requestRedraw();
return true;
}
case(GUIEventAdapter::RELEASE):
{
addMouseEvent(ea);
us.requestContinuousUpdate(true);
if (calcMovement()) us.requestRedraw();
return true;
}
case(GUIEventAdapter::DRAG):
{
addMouseEvent(ea);
us.requestContinuousUpdate(true);
if (calcMovement()) us.requestRedraw();
return true;
}
case(GUIEventAdapter::MOVE):
{
addMouseEvent(ea);
us.requestContinuousUpdate(true);
if (calcMovement()) us.requestRedraw();
return true;
}
case(GUIEventAdapter::KEYDOWN):
{
if (ea.getKey()==GUIEventAdapter::KEY_Space)
{
flushMouseEventStack();
home(ea,us);
return true;
}
else if (ea.getKey()=='q')
{
_speedMode = USE_MOUSE_Y_FOR_SPEED;
return true;
}
else if (ea.getKey()=='a')
{
_speedMode = USE_MOUSE_BUTTONS_FOR_SPEED;
return true;
}
#ifdef KEYBOARD_PITCH
else if (ea.getKey()==osgGA::GUIEventAdapter::KEY_Up ||
ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Up ||
ea.getKey()=='9')
{
_pitchUpKeyPressed = true;
return true;
}
else if (ea.getKey()==osgGA::GUIEventAdapter::KEY_Down ||
ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Down ||
ea.getKey()=='6')
{
_pitchDownKeyPressed = true;
return true;
}
#endif
return false;
}
case(GUIEventAdapter::KEYUP):
{
#ifdef KEYBOARD_PITCH
if (ea.getKey()==osgGA::GUIEventAdapter::KEY_Up ||
ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Up ||
ea.getKey()=='9')
{
_pitchUpKeyPressed = false;
return true;
}
else if (ea.getKey()==osgGA::GUIEventAdapter::KEY_Down ||
ea.getKey()==osgGA::GUIEventAdapter::KEY_KP_Down ||
ea.getKey()=='6')
{
_pitchDownKeyPressed = false;
return true;
}
#endif
return false;
}
default:
return false;
}
}
bool SceneGraphManipulator::handle(const GUIEventAdapter& ea,GUIActionAdapter& us)
{
if (ea.getHandled()) return false;
BaseViewer *v = dynamic_cast<BaseViewer*>(&us);
if (!v)
return false;
else if (!_init) {_sceneGraph = dynamic_cast<SceneGraph*>(getUserData()); _init=true;}
Viewer2D3D *v2d3d = dynamic_cast<Viewer2D3D*>(v->getGraphicsViewer());
if (!v2d3d)
return false;
if(_sceneGraph.valid() && _sceneGraph->getScene())
setInteractionMode(v2d3d->getProjectionType(), (_sceneGraph->getScene()->getBound()).center(), v2d3d->getZoom());
switch(ea.getEventType())
{
case(GUIEventAdapter::PUSH):
flushMouseEventStack();
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
return true;
case(GUIEventAdapter::RELEASE):
if (ea.getButtonMask()==0)
if (isMouseMoving())
{
if (calcMovement())
{
us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
}
}
else
{
flushMouseEventStack();
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
}
else
{
flushMouseEventStack();
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
}
return true;
case(GUIEventAdapter::DRAG):
addMouseEvent(ea);
if (calcMovement()) us.requestRedraw();
us.requestContinuousUpdate(false);
_thrown = false;
return true;
case(GUIEventAdapter::MOVE):
return false;
case(GUIEventAdapter::KEYDOWN):
if (ea.getKey()== _resetCameraKey) // reset camera
{
flushMouseEventStack();
_thrown = false;
home(ea,us);
us.requestRedraw();
us.requestContinuousUpdate(false);
return true;
}
else if(ea.getKey() >= 0xFFE1 && ea.getKey() <= 0xFFEE)
{ // modifier keys
_currentModifier = ea.getKey();
return true;
}
return false;
case(GUIEventAdapter::KEYUP):
{
if(ea.getKey() == _currentModifier)
{
_currentModifier = 0;
return true;
}
return false;
}
case(GUIEventAdapter::FRAME):
if (_thrown && calcMovement()) us.requestRedraw();
return false;
default:
return false;
}
}
