VRUT: /cygdrive/d/src/svn/vrut/trunk/modules/navigation/navigation.cpp Source File

00001 /*
00002  * $Id: navigation.cpp 319 2008-11-04 15:24:38Z stezkm1 $
00003  *
00004  * Description  : One line description of file.
00005  * Author       : Milan Stezka <mail: stezkm1@fel.cvut.cz>
00006  *
00007  * Purpose      :
00008  *     Long description of what the file is for.
00009  */
00010 
00011 
00012 #include "navigation.h"
00013 #include "../../core/src/kernel.h"
00014 
00015 #include <wx/utils.h>
00016 
00017 using namespace VRUT;
00018 
00019 
00020 Navigation::Navigation(const MODULE_ID & _id, const wxString & _name, EventHandler * msgSink)
00021               : CameraModule(_id, _name, 0, msgSink),
00022               navigationStyleCameraManipulatorSpecific(_id, _name, this),
00023               navigationStyleCATIASpecific(_id, _name, this),
00024               navigationStyleCortonaSpecific(_id, _name, this),
00025               navigationStyleCinema4DSpecific(_id, _name, this),
00026               navigationStyleMayaSpecific(_id, _name, this),
00027               navigationStyleDeltaViewSpecific(_id, _name, this),
00028               navigationStyleICEMSurfSpecific(_id, _name, this),
00029               navigationStyleVD2Specific(_id, _name, this)
00030 {
00031        //navigationStyleDefinition.push_back(&navigationStyleCameraManipulatorSpecific);
00032        navigationStyleDefinition.push_back(&navigationStyleCATIASpecific);
00033        navigationStyleDefinition.push_back(&navigationStyleCortonaSpecific);
00034        navigationStyleDefinition.push_back(&navigationStyleCinema4DSpecific);
00035        navigationStyleDefinition.push_back(&navigationStyleMayaSpecific);
00036        navigationStyleDefinition.push_back(&navigationStyleDeltaViewSpecific);
00037        navigationStyleDefinition.push_back(&navigationStyleICEMSurfSpecific);
00038        navigationStyleDefinition.push_back(&navigationStyleVD2Specific);
00039 
00040        for (NavigationStyleVector::iterator i = navigationStyleDefinition.begin(); i != navigationStyleDefinition.end(); i++)
00041        {
00042               navigationStyleString.Add((*i)->getStyleName());
00043        }
00044 
00045        //activeNavigationStyle = &navigationStyleCameraManipulatorSpecific;
00046        activeNavigationStyle = &navigationStyleVD2Specific;
00047 
00048        SET_DEFAULT_PARAM(eventTimeoutParamID, wxT("0"));
00049        SET_DEFAULT_PARAM(keyEventTimeoutParamID, wxT("0"));
00050        defaultMouseEventTimeout = wxT("50");
00051        SET_DEFAULT_PARAM(msEventTimeoutParamID, defaultMouseEventTimeout);
00052 
00053        fov = 0.0f;
00054        nearPlane = 0.0f;
00055        farPlane = 0.0f;
00056        rotspeed = 5e-3f;
00057        zoomspeed = 2e-1f;
00058        cruisespeed = 6e-2f;
00059        panspeed = 0.06f;
00060        zoomStep = 10.0f;
00061        flySpeedStep = 0.05f;
00062 
00063        selectedObject = NODE_ID_NONE;
00064 
00065        scenePivotWasSet = false;
00066        fovChangeOperationStarted = false;
00067 
00068        registerGUI();
00069 
00070        REGISTER_LISTENER(Event::EVT_SCENE_CAM_PROJECTION_CHANGED);
00071        //REGISTER_LISTENER(Event::EVT_SCENE_NODE_TRANSFORMED);
00072 }
00073 
00074 void Navigation::registerGUI()
00075 {
00076        registerCommonGUIControls();
00077        activeNavigationStyle->registerButtons();
00078 }
00079 
00080 void Navigation::refreshGUI()
00081 {
00082        Parameter::ParameterIdentificator param = eventTimeoutParamID; //Any parameter ID can be here as long it is from this module. All I need it for is the module name and instance number.
00083        param.paramName = wxT("*");
00084        wxCommandEvent paramGuiEvt = Event::GET_EVT_PARAM_GUIUNREGISTER(param);
00085        PostToKernel(paramGuiEvt);
00086        registerGUI();
00087 }
00088 
00089 wxString Navigation::buildCurrentCameraString(const SceneNode *node)
00090 {
00091        wxString id;
00092        if (node && node->IsOfType(SceneNode::CAMERA))
00093        {
00094               id << node->GetName() << wxT(" [id = ") << node->GetID() << wxT("]");
00095        }
00096        return id;
00097 }
00098 
00099 void Navigation::registerCommonGUIControls()
00100 {
00101        wxString paramValue;
00102        REGISTER_PARAM_GUI_TEXTCONTROL(sceneIDParamID, wxT("sceneID"), wxString::Format(wxT("%i"), sceneID), wxT("ID of scene to handle."));
00103        REGISTER_PARAM_GUI_TEXTCONTROL(windowIDParamID, wxT("windowID"), wxString::Format(wxT("%i"), windowID), wxT("ID of renderer window."));
00104        REGISTER_PARAM_GUI_COMBOBOX(navigationStyleParamID, wxT("navigationStyle"), activeNavigationStyle->getStyleName(), navigationStyleString, wxT("Style of navigation."));
00105 
00106        wxString cameraCenterDistanceValue, fovValue, nearPlaneValue, farPlaneValue, zero(wxT("0.0"));
00107 
00108        wxString currentCameraName;
00109 
00110        if (sceneMgr)
00111        {
00112               const Scene * scene = GetSceneMgr()->GetScene(getSceneID());
00113               if (scene)
00114               {
00115                      const SceneNode * camNode = scene->GetNode(getCameraID());
00116                      if (camNode && camNode->IsOfType(SceneNode::CAMERA))
00117                      {
00118                             ReadLocker rLock(*camNode);
00119                             cameraCenterDistanceValue = wxString::Format(wxT("%g"), ((Camera *)camNode)->GetCenterDist());
00120                             fovValue = wxString::Format(wxT("%g"), ((Camera *)camNode)->GetFOV());
00121                             nearPlaneValue = wxString::Format(wxT("%g"), ((Camera *)camNode)->GetNearPlane());
00122                             farPlaneValue = wxString::Format(wxT("%g"), ((Camera *)camNode)->GetFarPlane());
00123                             currentCameraName = buildCurrentCameraString(scene->GetNode(getCameraID()));
00124                      }
00125               }
00126        }
00127        else
00128        {
00129               cameraCenterDistanceValue = zero;
00130               fovValue = zero;
00131               nearPlaneValue = zero;
00132               farPlaneValue = zero;
00133        }
00134 
00135        findCameras(cameras);
00136        cameraString.clear();
00137        for (SceneNodeVector::iterator i = cameras.begin(); i != cameras.end(); i++)
00138        {
00139               LOGDEBUG(wxT("Navigation found a camera named: ")+buildCurrentCameraString((*i)));
00140               cameraString.Add(buildCurrentCameraString((*i)));
00141        }
00142        REGISTER_PARAM_GUI_COMBOBOX(selectedCameraParamID, wxT("selectedCamera"), currentCameraName, cameraString, wxT("Camera node used to view."));
00143 
00144        REGISTER_PARAM_GUI_TEXTCONTROL(cameraCenterDistanceParamID, wxT("cameraCenterDistance"), cameraCenterDistanceValue, wxT("cameraCenterDistance"));
00145        REGISTER_PARAM_GUI_TEXTCONTROL(fovParamID, wxT("FOV"), fovValue, wxT("Field of view."));
00146        REGISTER_PARAM_GUI_TEXTCONTROL(nearPlaneParamID, wxT("nearPlane"), nearPlaneValue, wxT("Near clipping plane."));
00147        REGISTER_PARAM_GUI_TEXTCONTROL(farPlaneParamID, wxT("farPlane"), farPlaneValue, wxT("Far clipping plane."));
00148 
00149        paramValue << rotspeed;
00150        REGISTER_PARAM_GUI_TEXTCONTROL(rotspeedParamID, wxT("rotspeed"), paramValue, wxT("Speed of rotation."));
00151        paramValue.clear();
00152        paramValue << zoomspeed;
00153        REGISTER_PARAM_GUI_TEXTCONTROL(zoomspeedParamID, wxT("zoomspeed"), paramValue, wxT("Speed of zoom."));
00154        paramValue.clear();
00155        paramValue << cruisespeed;
00156        REGISTER_PARAM_GUI_TEXTCONTROL(cruisespeedParamID, wxT("cruisespeed"), paramValue, wxT("cruisespeed"));
00157        paramValue.clear();
00158        paramValue << panspeed;
00159        REGISTER_PARAM_GUI_TEXTCONTROL(panspeedParamID, wxT("panspeed"), paramValue, wxT("Speed of pannign."));
00160 }
00161 
00162 Navigation::~Navigation()
00163 {
00164 }
00165 
00166 void Navigation::findCameras(SceneNodeVector & cameras)
00167 {
00168        if (sceneMgr)
00169        {
00170               const Scene * scene = GetSceneMgr()->GetScene(getSceneID());
00171               if (scene)
00172               {
00173                      std::vector<NODE_ID> nodes;
00174                      scene->GetNodeIDs(&nodes);
00175                      cameras.clear();
00176                      for (std::vector<NODE_ID>::iterator i = nodes.begin(); i != nodes.end(); i++)
00177                      {
00178                             const SceneNode * camNode = scene->GetNode(*i);
00179                             if (camNode && camNode->IsOfType(SceneNode::CAMERA))
00180                             {
00181                                    cameras.push_back(camNode);
00182                             }
00183                      }
00184               }
00185        }
00186 }
00187 
00188 NavigationStyleInterface *Navigation::resolveStyleFromString(const wxString& string) const
00189 {
00190        for (NavigationStyleVector::const_iterator i = navigationStyleDefinition.begin(); i != navigationStyleDefinition.end(); i++)
00191        {
00192               if ( (*i)->getStyleName() == string )
00193               {
00194                      return *i;
00195               }
00196        }
00197        return 0;
00198 }
00199 
00200 void Navigation::registerButtonList(ParameterIdentificatorList & buttonList)
00201 {
00202        for (ParameterIdentificatorList::iterator i = buttonList.begin(); i != buttonList.end(); i++)
00203        {
00204               REGISTER_PARAM_GUI_BUTTON(i->paramId, i->paramId.paramName, i->paramId.description);
00205        }
00206 }
00207 
00208 bool Navigation::getAndFixButtonValues(const wxCommandEvent & evt, ParameterIdentificatorList & buttonList)
00209 {
00210        bool changed = false;
00211        for (ParameterIdentificatorList::iterator i = buttonList.begin(); i != buttonList.end(); i++)
00212        {
00213               if (Parameter::ParameterIdentificator::FromEvent(evt) == i->paramId)
00214               {
00215                      i->paramValue = !i->paramValue;
00216                      changed = true;
00217               }
00218        }
00219        return changed;
00220 }
00221 
00222 void Navigation::registerTextControl(Parameter::ParameterIdentificator & paramID, const wxString & value)
00223 {
00224        REGISTER_PARAM_GUI_TEXTCONTROL(paramID, paramID.paramName, value, paramID.description);
00225 }
00226 
00227 void Navigation::registerButton(Parameter::ParameterIdentificator & paramID)
00228 {
00229        wxCommandEvent paramEvt = Event::GET_EVT_PARAM_REGISTER(paramID, wxT("0"));
00230        PostToKernel(paramEvt);
00231        GUIEnvironment::GUIParamInfo guiPI(paramID, GUIEnvironment::GUIParamInfo::GUI_TYPE_BUTTON);
00232        wxCommandEvent paramGuiEvt = Event::GET_EVT_PARAM_GUIREGISTER(guiPI, wxT("0"));
00233        PostToKernel(paramGuiEvt);
00234 }
00235 
00236 void Navigation::processEvent(wxCommandEvent & evt)
00237 {
00238        CameraModule::processEvent(evt);
00239        bool updateCamParams = false;
00240        switch (evt.GetEventType())
00241        {
00242        case Event::EVT_SCENE_CAM_PROJECTION_CHANGED:
00243               updateCamParams = ((evt.GetId() == int(getSceneID())) && (evt.GetInt() == int(getCameraID())) && !fovChangeOperationStarted);
00244               break;
00245        case Event::EVT_PARAM_SET:
00246               {
00247                      Parameter::ParameterIdentificator fromEventIdentificator = Parameter::ParameterIdentificator::FromEvent(evt);
00248                      if (fromEventIdentificator == nodeIDParamID)
00249                      {
00250                             updateCamParams = true;     
00251                      }
00252                      else
00253                      {
00254                             wxString selectedNavigationStyleString;
00255                             UPDATE_PARAM_FROM_EVENT_STRING(navigationStyleParamID, selectedNavigationStyleString, evt);
00256 
00257                             if (fromEventIdentificator == navigationStyleParamID)
00258                             {
00259                                    NavigationStyleInterface *newStyle = resolveStyleFromString(selectedNavigationStyleString);
00260                                    if (newStyle != activeNavigationStyle)
00261                                    {
00262                                           activeNavigationStyle = newStyle;
00263                                           refreshGUI();
00264                                    }
00265                             }
00266 
00267                             activeNavigationStyle->getAndFixButtonValues(evt);
00268 
00269                             UPDATE_PARAM_FROM_EVENT_FLOAT(rotspeedParamID, rotspeed, evt);
00270                             UPDATE_PARAM_FROM_EVENT_FLOAT(zoomspeedParamID, zoomspeed, evt);
00271                             UPDATE_PARAM_FROM_EVENT_FLOAT(cruisespeedParamID, cruisespeed, evt);
00272                             UPDATE_PARAM_FROM_EVENT_FLOAT(panspeedParamID, panspeed, evt);
00273                             float cameraCenterDistance = 0.0f;
00274                             UPDATE_PARAM_FROM_EVENT_FLOAT(cameraCenterDistanceParamID, cameraCenterDistance, evt);
00275                             UPDATE_PARAM_FROM_EVENT_FLOAT(fovParamID, fov, evt);
00276                             UPDATE_PARAM_FROM_EVENT_FLOAT(nearPlaneParamID, nearPlane, evt);
00277                             UPDATE_PARAM_FROM_EVENT_FLOAT(farPlaneParamID, farPlane, evt);
00278 
00279                             activeNavigationStyle->updateParams(evt);
00280 
00281                             if (fromEventIdentificator == sceneIDParamID) //Scene is assigned
00282                             {
00283                                    refreshGUI();
00284                                    scenePivotWasSet = false;
00285                             }
00286 
00287                             if (fromEventIdentificator == selectedCameraParamID)
00288                             {
00289                                    wxString selectedCamera;
00290                                    UPDATE_PARAM_FROM_EVENT_STRING(selectedCameraParamID, selectedCamera, evt);
00291                                    for (SceneNodeVector::iterator i = cameras.begin(); i != cameras.end(); i++)
00292                                    {
00293                                           if ((*i)->GetName() == selectedCamera)
00294                                           {
00295                                                  wxCommandEvent ev = Event::GET_EVT_PARAM_SET_DO(nodeIDParamID, wxString::Format(wxT("%i"), (*i)->GetID()));
00296                                                  PostToKernel(ev);
00297                                           }
00298                                    }
00299                             }
00300 
00301                             processNavigationOperationButtonEvent();
00302 
00303                             if ( (fov || nearPlane || farPlane)
00304                                           && (getSceneID() != SCENE_ID_NONE)
00305                                           && (getCameraID() != NODE_ID_NONE) )
00306                             {
00307                                    wxCommandEvent camEvt = Event::GET_EVT_SCENE_CAM_PROJECTION_SET(getSceneID(), getCameraID(), 0, 0, nearPlane, farPlane, fov);
00308                                    PostToKernel(camEvt, true);
00310                                    WaitForEvent(Event::EVT_SCENE_CAM_PROJECTION_CHANGED, 100, int(getSceneID()), int(getCameraID()));
00311                             }
00312                             if (fromEventIdentificator == cameraCenterDistanceParamID)
00313                             {
00314                                    Scene * scene = GetSceneMgr()->GetScene(getSceneID());
00315                                    if (scene)
00316                                    {
00317                                           NODE_ID cameraID = getCameraID();
00318                                           const SceneNode * camNode = scene->GetNode(cameraID);
00319                                           if (camNode && camNode->IsOfType(SceneNode::CAMERA))
00320                                           {
00321                                                  Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
00322                                                  WriteLocker camLock(*camera);
00323                                                  camera->SetCenterDist(cameraCenterDistance);
00324                                           }
00325                                    }
00326                             }
00327                      }
00328               }
00329               break;
00330        default:
00331               break;
00332        }
00333        if (updateCamParams)
00334        {
00335               const Scene * scene = GetSceneMgr()->GetScene(getSceneID());
00336               if (scene)
00337               {
00338                      const SceneNode * camNode = scene->GetNode(getCameraID());
00339                      if (camNode && camNode->IsOfType(SceneNode::CAMERA))
00340                      {
00341                             ReadLocker rLock(*camNode);
00342                             wxCommandEvent ev1 = Event::GET_EVT_PARAM_SET_DO(fovParamID, wxString::Format(wxT("%g"), ((Camera *)camNode)->GetFOV()));
00343                             PostToKernel(ev1);
00344                             wxCommandEvent ev2 = Event::GET_EVT_PARAM_SET_DO(nearPlaneParamID, wxString::Format(wxT("%g"), ((Camera *)camNode)->GetNearPlane()));
00345                             PostToKernel(ev2);
00346                             wxCommandEvent ev3 = Event::GET_EVT_PARAM_SET_DO(farPlaneParamID, wxString::Format(wxT("%g"), ((Camera *)camNode)->GetFarPlane()));
00347                             PostToKernel(ev3);
00348                             wxCommandEvent ev4 = Event::GET_EVT_PARAM_SET_DO(cameraCenterDistanceParamID, wxString::Format(wxT("%g"), ((Camera *)camNode)->GetCenterDist()));
00349                             PostToKernel(ev4);
00350                      }
00351               }
00352        }
00353 }
00354 
00355 void Navigation::processNavigationOperationButtonEvent()
00356 {
00357        activeNavigationStyle->buttonEvent();
00358 }
00359 
00360 bool Navigation::isAnyButtonSelected(const ParameterIdentificatorList & buttonList) const
00361 {
00362        for (ParameterIdentificatorList::const_iterator i = buttonList.begin(); i != buttonList.end(); i++)
00363        {
00364               if (i->paramValue)
00365               {
00366                      return true;
00367               }
00368        }
00369        return false;
00370 }
00371 
00372 /*Navigation::NavigationOperation Navigation::getButtonOperation(const ParameterIdentificatorList & buttonList) const
00373 {
00374        for (ParameterIdentificatorList::const_iterator i = buttonList.begin(); i != buttonList.end(); i++)
00375        {
00376               if (i->paramValue)
00377               {
00378                      return i->first;
00379               }
00380        }
00381        return NO_OP;
00382 }*/
00383 
00384 void Navigation::clearButtonValues(ParameterIdentificatorList &buttonList)
00385 {
00386        for (ParameterIdentificatorList::iterator i = buttonList.begin(); i != buttonList.end(); i++)
00387        {
00388               i->paramValue = 0;
00389        }
00390 }
00391 
00392 void Navigation::clearButtonValuesConditional(const wxCommandEvent & evt, ParameterIdentificatorList &buttonList)
00393 {
00394        bool clear = false;
00395        for (ParameterIdentificatorList::iterator i = buttonList.begin(); i != buttonList.end(); i++)
00396        {
00397               if (Parameter::ParameterIdentificator::FromEvent(evt) == i->paramId)
00398               {
00399                      clear = true;
00400                      break;
00401               }
00402        }
00403        if (clear)
00404        {
00405               for (ParameterIdentificatorList::iterator i = buttonList.begin(); i != buttonList.end(); i++)
00406               {
00407                      i->paramValue = 0;
00408               }
00409        }
00410 }
00411 
00412 void Navigation::pan(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speed)
00413 {
00414        VECTOR3 camUp = camera->GetUp().Normalize();
00415        VECTOR3 move = mouseDelta.x * camUp.Cross(camera->GetView()).Normalize();
00416        move += mouseDelta.y * camUp;
00417        move *= speed;
00418        scene->Transform(cameraID, MATRIX::Translation(move));
00419        scene->UpdateTransformation(cameraID);
00420        if (!KERNEL)
00421        {
00422               wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(scene->GetID());
00423               PostToKernel(ev, true);
00424        }
00425 }
00426 
00427 void Navigation::rotate(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseAbsolute, const wxPoint& mouseDelta, bool rollControl, bool yAlignedUpVector, bool rotateAroundScenePivot)
00428 {
00429        //unsigned int windowWidth, windowHeight;
00430        //camera->GetWidthHeight(&windowWidth, &windowHeight);
00431        //VECTOR3 mouse(mouseAbsolute.x-(int)windowWidth/2, mouseAbsolute.y-(int)windowHeight/2, 0); //I am using a 3d vector because the 2d equivalent has no length() method.
00432        //unsigned int trackballRadius = windowHeight / 3;
00433 
00434        //if (mouse.Length()<trackballRadius || !rollControl) //yaw and pitch
00435        //{
00436        float angleX = mouseDelta.x * rotspeed;
00437        float angleY = -mouseDelta.y * rotspeed;
00438        VECTOR3 camUp = camera->GetUp().Normalize();
00439        VECTOR3 center = camera->GetCenterPoint();
00440        MATRIX m;
00441 
00442        if (rotateAroundScenePivot)
00443               m *= MATRIX::Translation(-scenePivot);
00444 
00445        if (angleX)
00446        {
00447               m *= MATRIX::RotationAxis(yAlignedUpVector ? VECTOR3(0.0f, 1.0f, 0.0f) : camUp, angleX);
00448        }
00449        if (angleY)
00450        {
00451               m *= MATRIX::RotationAxis(camUp.Cross(camera->GetView()).Normalize(), angleY);
00452        }
00453 
00454        if (rotateAroundScenePivot)
00455               m *= MATRIX::Translation(scenePivot);
00456 
00457        if (angleX || angleY)
00458        {
00459               scene->Transform(cameraID, m);
00460               scene->UpdateTransformation(cameraID);
00461        }
00462 
00463        if (!rotateAroundScenePivot)
00464        {
00465               scene->TranslateAbs(cameraID, center - camera->GetView().Normalize()*camera->GetCenterDist());
00466               scene->UpdateTransformation(cameraID);
00467        }
00468        //}
00469 
00470        //Deprecated. But the code still might come in handy while coding the navigation emulation of 3DS Max in the future
00471 
00472        //else //roll
00473        //     //TODO: draw a circle to show where the roll area starts
00474        //{
00475        //     VECTOR3 prevMouseCoord(mouse);
00476        //     prevMouseCoord -= VECTOR3(mouseDelta.x, mouseDelta.y, 0);
00477        //     //Assume a 2D space divided by a prevMouseCoord vector into two half spaces.
00478        //     //We have to check in which half space the current mouse coordinate lies in, to determine the rotation direction.
00479 
00480        //     //First, we compute the prevMouseCoord vector normal so that we can insert the current mouse coord into the line equation ax+by=0
00481        //     //The c parameter is 0 because the line goes through the origin.
00482        //     VECTOR3 prevMouseCoordNormal(-prevMouseCoord.y, prevMouseCoord.x);
00483        //     prevMouseCoordNormal = prevMouseCoordNormal.Normalize();
00484        //     //This dot product is the insertion of values into the equation. Result is the signed distance from the prevMouseCoord vector.
00485        //     float distance = prevMouseCoordNormal.x*mouse.x+prevMouseCoordNormal.y*mouse.y;
00486 
00487        //     roll(scene, camera, cameraID, wxPoint(1, 0), rotspeed * distance);
00488        //}
00489 
00490        if (!KERNEL)
00491        {
00492               wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(scene->GetID());
00493               PostToKernel(ev, true);
00494        }
00495 }
00496 
00497 void Navigation::turnHead(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, bool yAlignedUpVector)
00498 {
00499        float angleX = mouseDelta.x * rotspeed;
00500        float angleY = -mouseDelta.y * rotspeed;
00501        VECTOR3 camUp = camera->GetUp().Normalize();
00502 
00503        VECTOR3 position = camera->GetWorldTransMatrix()->ExtractTranslation();
00504 
00505        if (angleX)
00506        {
00507               scene->Transform(cameraID, MATRIX::RotationAxis(yAlignedUpVector ? VECTOR3(0.0f, 1.0f, 0.0f) : camUp, angleX));
00508               scene->UpdateTransformation(cameraID);
00509        }
00510        if (angleY)
00511        {
00512               scene->Transform(cameraID, MATRIX::RotationAxis(camUp.Cross(camera->GetView()).Normalize(), angleY));
00513               scene->UpdateTransformation(cameraID);
00514        }
00515 
00516        scene->TranslateAbs(cameraID, position);
00517        scene->UpdateTransformation(cameraID);
00518 
00519        if (!KERNEL)
00520        {
00521               wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(scene->GetID());
00522               PostToKernel(ev, true);
00523        }
00524 }
00525 
00526 void Navigation::fly(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta)
00527 {
00528        turnHead(scene, camera, cameraID, mouseDelta, false);
00529        zoom(scene, camera, cameraID, 1, -cruisespeed);
00530 }
00531 
00532 void Navigation::turnHeadLeftRightWithYAlignedUpVector(Scene * scene, Camera * camera, const NODE_ID& cameraID, int mouseXDelta, float speed)
00533 {
00534        float angleX = mouseXDelta * rotspeed * speed;
00535        VECTOR3 camUp = camera->GetUp().Normalize();
00536 
00537        VECTOR3 position = camera->GetWorldTransMatrix()->ExtractTranslation();
00538        scene->TranslateAbs(cameraID, VECTOR3());
00539        scene->UpdateTransformation(cameraID);
00540 
00541        if (angleX)
00542        {
00543               scene->Transform(cameraID, MATRIX::RotationAxis(VECTOR3(0.0f, 1.0f, 0.0f), angleX));
00544               scene->UpdateTransformation(cameraID);
00545        }
00546 
00547        scene->TranslateAbs(cameraID, position);
00548        scene->UpdateTransformation(cameraID);
00549 }
00550 
00551 void Navigation::moveWithCollisionTesting(Scene * scene, Camera * camera, const NODE_ID& cameraID, const VECTOR3& walkDirection, float speedModifier, float maxStepHeight, float avatarHeight)
00552 {
00553        VECTOR3 direction = walkDirection * cruisespeed * speedModifier;
00554        VECTOR3 directionNormalized = direction.Normalize();
00555        VECTOR3 cameraOrigin = camera->GetWorldTransMatrix()->ExtractTranslation();
00556 
00557        RayIntersectionInfo info;
00558        if (scene->GetBVH())
00559        {
00560               Ray forwardRay(cameraOrigin, directionNormalized);
00561               wxString ss;
00562               forwardRay.origin.y += maxStepHeight;
00563               if (scene->GetBVH() && scene->GetBVH()->CastRay(forwardRay, info))
00564               {
00565                      //wall in front of us
00566                      if (info.dist < direction.Length())
00567                      {
00568                             //we ll hit it
00569                             direction = directionNormalized * (info.dist - 0.001f);
00570                      }
00571               }
00572               vector3 tmp1(cameraOrigin + direction);
00573               vector3 tmp2(0.0f, -1.0f, 0.0f);
00574               Ray gravityRay(tmp1, tmp2);
00575               gravityRay.origin.y += maxStepHeight;
00576               if (scene->GetBVH()->CastRay(gravityRay, info))
00577               {
00578                      //there will be ground under our feet
00579                      const SceneNode * node = scene->GetNode(info.nodeID);
00580                      if (node)
00581                      {
00582                             VECTOR3 collisionPosition = gravityRay.origin + gravityRay.direction * info.dist;
00583                             collisionPosition.y += avatarHeight;
00584                             scene->TranslateAbs(cameraID, collisionPosition);
00585                             scene->UpdateTransformation(cameraID);
00586                      }
00587               }
00588               else
00589               {
00590                      //we are above an infinite void space - so we ll just float above it
00591                      scene->Transform(cameraID, MATRIX::Translation(direction));
00592                      scene->UpdateTransformation(cameraID);
00593               }
00594        }
00595 
00596        if (!KERNEL)
00597        {
00598               wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(scene->GetID());
00599               PostToKernel(ev, true);
00600        }
00601 }
00602 
00603 void Navigation::planWalk(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier, float maxStepHeight, float avatarHeight)
00604 {
00605        //LOGDEBUG(wxT("planWalk"));
00606 
00607        turnHeadLeftRightWithYAlignedUpVector(scene, camera, cameraID, mouseDelta.x, speedModifier);
00608 
00609        VECTOR3 camUp = camera->GetUp().Normalize();
00610        VECTOR3 normalizedView = camera->GetView().Normalize();
00611        VECTOR3 pitchAxis = camUp.Cross(normalizedView);
00612        VECTOR3 walkDirection = VECTOR3(0.0f, 1.0f, 0.0f).Cross(pitchAxis) * mouseDelta.y;
00613 
00614        moveWithCollisionTesting(scene, camera, cameraID, walkDirection, speedModifier, maxStepHeight, avatarHeight);
00615        
00616 }
00617 
00618 void Navigation::panWalk(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier, float maxStepHeight, float avatarHeight)
00619 {
00620        VECTOR3 up(0.0f, 1.0f, 0.0f);
00621        VECTOR3 camUp = camera->GetUp().Normalize();
00622        VECTOR3 normalizedView = camera->GetView().Normalize();
00623        VECTOR3 pitchAxis = camUp.Cross(normalizedView);
00624        VECTOR3 walkDirection = up.Cross(pitchAxis) * mouseDelta.y;
00625 
00626        VECTOR3 viewAxis = normalizedView.Cross(up) * mouseDelta.x;
00627        walkDirection += viewAxis;
00628 
00629        moveWithCollisionTesting(scene, camera, cameraID, walkDirection, speedModifier, maxStepHeight, avatarHeight);
00630        
00631 }
00632 
00633 void Navigation::turnWalk(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier)
00634 {
00635        float angleX = mouseDelta.x * rotspeed * speedModifier;
00636        float angleY = -mouseDelta.y * rotspeed * speedModifier;
00637        VECTOR3 camUp = camera->GetUp().Normalize();
00638        VECTOR3 center = camera->GetCenterPoint();
00639 
00640        VECTOR3 position = camera->GetWorldTransMatrix()->ExtractTranslation();
00641        scene->TranslateAbs(cameraID, VECTOR3());
00642        scene->UpdateTransformation(cameraID);
00643 
00644        if (angleX)
00645        {
00646               scene->Transform(cameraID, MATRIX::RotationAxis(VECTOR3(0.0f, 1.0f, 0.0f), angleX));
00647               scene->UpdateTransformation(cameraID);
00648        }
00649        if (angleY)
00650        {
00651               scene->Transform(cameraID, MATRIX::RotationAxis(camUp.Cross(camera->GetView()).Normalize(), angleY));
00652               scene->UpdateTransformation(cameraID);
00653        }
00654 
00655        scene->TranslateAbs(cameraID, position);
00656        scene->UpdateTransformation(cameraID);
00657 
00658        if (!KERNEL)
00659        {
00660               wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(scene->GetID());
00661               PostToKernel(ev, true);
00662        }
00663 }
00664 
00665 void Navigation::planFly(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier)
00666 {
00667        turnHeadLeftRightWithYAlignedUpVector(scene, camera, cameraID, mouseDelta.x, speedModifier);
00668        zoom(scene, camera, cameraID, mouseDelta.y, cruisespeed * speedModifier);
00669 }
00670 
00671 void Navigation::panFly(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier)
00672 {
00673        float panspeedTemp = panspeed;
00674        panspeed *= speedModifier;
00675        pan(scene, camera, cameraID, wxPoint(-mouseDelta.x, -mouseDelta.y), panspeed);
00676        panspeed = panspeedTemp;
00677 }
00678 
00679 void Navigation::turnFly(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier)
00680 {
00681        float rotspeedTemp = rotspeed;
00682        rotspeed *= speedModifier;
00683        turnHead(scene, camera, cameraID, mouseDelta, false);
00684        rotspeed = rotspeedTemp;
00685 }
00686 
00687 void Navigation::rollFly(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier)
00688 {
00689        float rotspeedTemp = rotspeed;
00690        rotspeed *= speedModifier;
00691        turnHead(scene, camera, cameraID, wxPoint(0, mouseDelta.y), false);
00692        rotspeed = rotspeedTemp;
00693 
00694        roll(scene, camera, cameraID, -mouseDelta.x, rotspeed * speedModifier, false);
00695 }
00696 
00697 void Navigation::planStudy(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier)
00698 {
00699        float rotspeedTemp = rotspeed;
00700        rotspeed *= speedModifier;
00701        rotate(scene, camera, cameraID, wxPoint(), wxPoint(mouseDelta.x, 0), false, false, false);
00702        rotspeed = rotspeedTemp;
00703        zoom(scene, camera, cameraID, mouseDelta.y, cruisespeed * speedModifier);
00704 }
00705 
00706 void Navigation::panStudy(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier)
00707 {
00708        float panspeedTemp = panspeed;
00709        panspeed *= speedModifier;
00710        pan(scene, camera, cameraID, wxPoint(-mouseDelta.x, -mouseDelta.y), panspeed);
00711        panspeed = panspeedTemp;
00712 }
00713 
00714 void Navigation::turnStudy(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier)
00715 {
00716        float rotspeedTemp = rotspeed;
00717        rotspeed *= speedModifier;
00718        rotate(scene, camera, cameraID, wxPoint(), mouseDelta, false, false, false);
00719        rotspeed = rotspeedTemp;
00720 }
00721 
00722 void Navigation::rollStudy(Scene * scene, Camera * camera, const NODE_ID& cameraID, const wxPoint& mouseDelta, float speedModifier)
00723 {
00724        float rotspeedTemp = rotspeed;
00725        rotspeed *= speedModifier;
00726        rotate(scene, camera, cameraID, wxPoint(), wxPoint(0, mouseDelta.y), false, false, false);
00727        rotspeed = rotspeedTemp;
00728 
00729        roll(scene, camera, cameraID, -mouseDelta.x, rotspeed * speedModifier, false);
00730 }
00731 
00732 void Navigation::select(Scene * scene, Camera * camera, wxMouseEvent & evt)
00733 {
00734        unsigned width, height;
00735        camera->GetWidthHeight(&width, &height);
00736 
00737        float px = ((( 2.0f * evt.GetPosition().x) / width) - 1.0f) / camera->GetProjectionMatrix()->_m11;
00738        float py = (((-2.0f * evt.GetPosition().y) / height) + 1.0f) / camera->GetProjectionMatrix()->_m22;
00739 
00740        VECTOR3 origin(0, 0, 0);
00741        VECTOR3 direction(px, py, -1.0f);
00742 
00743        origin = camera->GetWorldTransMatrix()->TransformCoord(origin);
00744        direction = camera->GetWorldTransMatrix()->TransformNormal(direction).Normalize();
00745        Ray ray(origin, direction);
00746 
00747        BVH::IntersectionInfo info;
00748 
00749        if (scene->GetBVH())
00750        {
00751               if (scene->GetBVH()->BoundProbe(ray, &info))
00752               {
00753                      const SceneNode * node = scene->GetNode(info.nodeID);
00754                      if (node)
00755                      {
00756                             selectedObject = node->GetID();
00757                             LOGDEBUG(wxString::Format(wxT("Selected object ID=%i, Name=%s"), info.nodeID, node->GetName().c_str()));
00758                      }
00759               }
00760               else
00761               {
00762                      selectedObject = NODE_ID_NONE;
00763                      LOGDEBUG(wxT("No object selected"));
00764               }
00765        }
00766 }
00767 
00768 void Navigation::pickScenePivot(Scene * scene, Camera * camera, const NODE_ID& cameraID, wxMouseEvent & evt)
00769 {
00770        unsigned width, height;
00771        camera->GetWidthHeight(&width, &height);
00772 
00773        float px = ((( 2.0f * evt.GetPosition().x) / width) - 1.0f) / camera->GetProjectionMatrix()->_m11;
00774        float py = (((-2.0f * evt.GetPosition().y) / height) + 1.0f) / camera->GetProjectionMatrix()->_m22;
00775 
00776        VECTOR3 origin(0, 0, 0);
00777        VECTOR3 direction(px, py, -1.0f);
00778 
00779        origin = camera->GetWorldTransMatrix()->TransformCoord(origin);
00780        direction = camera->GetWorldTransMatrix()->TransformNormal(direction).Normalize();
00781        Ray ray(origin, direction);
00782 
00783        RayIntersectionInfo info;
00784        if (scene->GetBVH() && scene->GetBVH()->CastRay(ray, info))
00785        {
00786               const SceneNode * node = scene->GetNode(info.nodeID);
00787               if (node)
00788               {
00789                      scenePivot = origin + direction * info.dist;
00790                      LOGDEBUG(wxT("scenePivot was set"));
00791               }
00792        }
00793 }
00794 
00795 void Navigation::translateCameraCenterToSelection(Scene * scene, Camera * camera, const NODE_ID& cameraID, wxMouseEvent & evt)
00796 {
00797        unsigned width, height;
00798        camera->GetWidthHeight(&width, &height);
00799 
00800        float px = ((( 2.0f * evt.GetPosition().x) / width) - 1.0f) / camera->GetProjectionMatrix()->_m11;
00801        float py = (((-2.0f * evt.GetPosition().y) / height) + 1.0f) / camera->GetProjectionMatrix()->_m22;
00802 
00803        VECTOR3 origin(0, 0, 0);
00804        VECTOR3 direction(px, py, -1.0f);
00805 
00806        origin = camera->GetWorldTransMatrix()->TransformCoord(origin);
00807        direction = camera->GetWorldTransMatrix()->TransformNormal(direction).Normalize();
00808        Ray ray(origin, direction);
00809 
00810        RayIntersectionInfo info;
00811        if (scene->GetBVH() && scene->GetBVH()->CastRay(ray, info))
00812        {
00813               const SceneNode * node = scene->GetNode(info.nodeID);
00814               if (node)
00815               {
00816                      scene->Transform(cameraID, MATRIX::Translation((origin + direction * info.dist) - camera->GetCenterPoint()));
00817                      scene->UpdateTransformation(cameraID);
00818               }
00819        }
00820 }
00821 
00822 void Navigation::zoom(Scene * scene, Camera * camera, const NODE_ID& cameraID, int mouseDelta, float speed)
00823 {
00824        float moveY = -mouseDelta * speed;
00825        if (moveY)
00826        {
00827               VECTOR3 camView = camera->GetView().Normalize();
00828               float dist = camera->GetCenterDist();
00829               camera->SetCenterDist(dist - moveY);
00830               scene->Transform(cameraID, MATRIX::Translation(camera->GetView().Normalize() * moveY));
00831               scene->UpdateTransformation(cameraID);
00832               if (!KERNEL)
00833               {
00834                      wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(scene->GetID());
00835                      PostToKernel(ev, true);
00836               }
00837        }
00838 }
00839 
00840 void Navigation::roll(Scene * scene, Camera * camera, const NODE_ID& cameraID, int mouseDelta, float speed, bool rotateAroundScenePivot)
00841 {
00842        VECTOR3 position = camera->GetWorldTransMatrix()->ExtractTranslation();
00843 
00844        MATRIX m;
00845 
00846        if (rotateAroundScenePivot)
00847               m *= MATRIX::Translation(-scenePivot);
00848 
00849        m *= MATRIX::RotationAxis(camera->GetView().Normalize(), mouseDelta * speed);
00850 
00851        if (rotateAroundScenePivot)
00852               m *= MATRIX::Translation(scenePivot);
00853 
00854        scene->Transform(cameraID, m);
00855        scene->UpdateTransformation(cameraID);
00856 
00857        if (!rotateAroundScenePivot)
00858        {
00859               scene->TranslateAbs(cameraID, position);
00860               scene->UpdateTransformation(cameraID);
00861        }
00862 }
00863 
00864 void Navigation::processKeyEvent(wxKeyEvent & evt)
00865 {
00866 #ifdef EVENT_DEBUG
00867        LOGERROR(wxT("<Navigation>Received key event"));
00868 #endif
00869        activeNavigationStyle->keyStyle(evt);
00870 }
00871 
00872 
00873 void Navigation::processMouseEvent(wxMouseEvent & evt)
00874 {
00875        if (int(windowID) != evt.GetId())
00876               return;
00877 
00878        NODE_ID cameraID = getCameraID();
00879        Scene * scene = GetSceneMgr()->GetScene(getSceneID());
00880        if (!scene)
00881               return;
00882 
00883        const SceneNode * camNode = scene->GetNode(cameraID);
00884        if (!camNode || !camNode->IsOfType(SceneNode::CAMERA))
00885               return;
00886 
00887        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
00888        WriteLocker camLock(*camera);
00889 
00890        scene->UpdateTransformation(cameraID);
00891 
00892        activeNavigationStyle->mouseStyle(evt);
00893 }
00894 
00895 void Navigation::run()
00896 {
00897        if (navigationStyleCATIASpecific.fly)
00898        {
00899               wxMilliSleep(10);  //10ms is a compromise between an interactive frame rate and a low cpu load
00900 
00901               NODE_ID cameraID = getCameraID();
00902               Scene * scene = GetSceneMgr()->GetScene(getSceneID());
00903               if (!scene)
00904                      return;
00905 
00906               const SceneNode * camNode = scene->GetNode(cameraID);
00907               if (!camNode || !camNode->IsOfType(SceneNode::CAMERA))
00908                      return;
00909 
00910               Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
00911               WriteLocker camLock(*camera);
00912               scene->UpdateTransformation(cameraID);
00913 
00914               fly(scene, camera, cameraID, mouseDelta);
00915               mouseDelta = wxPoint(0, 0);
00916        }
00917 
00918        if (navigationStyleCortonaSpecific.operationStarted)
00919        {
00920               wxMilliSleep(10);
00921 
00922               NODE_ID cameraID = getCameraID();
00923               Scene * scene = GetSceneMgr()->GetScene(getSceneID());
00924               if (!scene)
00925                      return;
00926 
00927               const SceneNode * camNode = scene->GetNode(cameraID);
00928               if (!camNode || !camNode->IsOfType(SceneNode::CAMERA))
00929                      return;
00930 
00931               Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
00932               WriteLocker camLock(*camera);
00933               scene->UpdateTransformation(cameraID);
00934 
00935               int cortonaWalk = navigationStyleCortonaSpecific.walkButtonIter->paramValue;
00936               int cortonaFly = navigationStyleCortonaSpecific.flyButtonIter->paramValue;
00937               int cortonaStudy = navigationStyleCortonaSpecific.studyButtonIter->paramValue;
00938 
00939               if (navigationStyleCortonaSpecific.planWalkButtonIter->paramValue && cortonaWalk)
00940               {
00941                      planWalk(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation, navigationStyleCortonaSpecific.maxStepHeight, navigationStyleCortonaSpecific.avatarHeight);
00942               }
00943               else if (navigationStyleCortonaSpecific.panWalkButtonIter->paramValue && cortonaWalk)
00944               {
00945                      panWalk(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation, navigationStyleCortonaSpecific.maxStepHeight, navigationStyleCortonaSpecific.avatarHeight);
00946               }
00947               else if (navigationStyleCortonaSpecific.turnWalkButtonIter->paramValue && cortonaWalk)
00948               {
00949                      turnWalk(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation);
00950               }
00951               
00952               if (navigationStyleCortonaSpecific.planFlyButtonIter->paramValue && cortonaFly)
00953               {
00954                      planFly(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation);
00955               }
00956               else if (navigationStyleCortonaSpecific.panFlyButtonIter->paramValue && cortonaFly)
00957               {
00958                      panFly(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation);
00959               }
00960               else if (navigationStyleCortonaSpecific.turnFlyButtonIter->paramValue && cortonaFly)
00961               {
00962                      turnFly(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation);
00963               }
00964               else if (navigationStyleCortonaSpecific.rollFlyButtonIter->paramValue && cortonaFly)
00965               {
00966                      rollFly(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation);
00967               }
00968 
00969               if (navigationStyleCortonaSpecific.planStudyButtonIter->paramValue && cortonaStudy)
00970               {
00971                      planStudy(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation);
00972               }
00973               else if (navigationStyleCortonaSpecific.panStudyButtonIter->paramValue && cortonaStudy)
00974               {
00975                      panStudy(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation);
00976               }
00977               else if (navigationStyleCortonaSpecific.turnStudyButtonIter->paramValue && cortonaStudy)
00978               {
00979                      turnStudy(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation);
00980               }
00981               else if (navigationStyleCortonaSpecific.rollStudyButtonIter->paramValue && cortonaStudy)
00982               {
00983                      rollStudy(scene, camera, cameraID, mouseDelta, navigationStyleCortonaSpecific.speedCompensation);
00984               }
00985        }
00986 
00987        if (navigationStyleCortonaSpecific.altDown || navigationStyleCortonaSpecific.spaceDown)
00988        {
00989               int cortonaWalk = navigationStyleCortonaSpecific.walkButtonIter->paramValue;
00990               int cortonaFly = navigationStyleCortonaSpecific.flyButtonIter->paramValue;
00991               int cortonaStudy = navigationStyleCortonaSpecific.studyButtonIter->paramValue;
00992 
00993               if (cortonaWalk)
00994               {
00995                      //LOGDEBUG(wxT("walk"));
00996                      clearButtonValues(navigationStyleCortonaSpecific.walkButtonsInfo);
00997                      if (navigationStyleCortonaSpecific.altDown && navigationStyleCortonaSpecific.spaceDown)
00998                             navigationStyleCortonaSpecific.turnWalkButtonIter->paramValue = 1;
00999                      else if (navigationStyleCortonaSpecific.altDown)
01000                             navigationStyleCortonaSpecific.panWalkButtonIter->paramValue = 1;
01001                      else if (navigationStyleCortonaSpecific.spaceDown)
01002                             //LOGDEBUG(wxT("space"));
01003                             navigationStyleCortonaSpecific.turnWalkButtonIter->paramValue = 1;
01004               }
01005               if (cortonaFly)
01006               {
01007                      clearButtonValues(navigationStyleCortonaSpecific.flyButtonsInfo);
01008                      if (navigationStyleCortonaSpecific.altDown && navigationStyleCortonaSpecific.spaceDown)
01009                             navigationStyleCortonaSpecific.rollFlyButtonIter->paramValue = 1;
01010                      else if (navigationStyleCortonaSpecific.altDown)
01011                             navigationStyleCortonaSpecific.panFlyButtonIter->paramValue = 1;
01012                      else if (navigationStyleCortonaSpecific.spaceDown)
01013                             navigationStyleCortonaSpecific.turnFlyButtonIter->paramValue = 1;
01014               }
01015               if (cortonaStudy)
01016               {
01017                      clearButtonValues(navigationStyleCortonaSpecific.studyButtonsInfo);
01018                      if (navigationStyleCortonaSpecific.altDown && navigationStyleCortonaSpecific.spaceDown)
01019                             navigationStyleCortonaSpecific.rollStudyButtonIter->paramValue = 1;
01020                      else if (navigationStyleCortonaSpecific.altDown)
01021                             navigationStyleCortonaSpecific.panStudyButtonIter->paramValue = 1;
01022                      else if (navigationStyleCortonaSpecific.spaceDown)
01023                             navigationStyleCortonaSpecific.planStudyButtonIter->paramValue = 1;
01024               }
01025        }
01026        if (!scenePivotWasSet) //When the sceneID changes in the processEvent, the BVH does not exist yet, so i keep checking here
01027        {
01028               setInitialScenePivot();
01029               scenePivotWasSet = true;
01030        }
01031 }
01032 
01033 void Navigation::setInitialScenePivot()
01034 {
01035        if (sceneMgr && (getSceneID() != SCENE_ID_NONE))
01036        {
01037               const Scene * scene = GetSceneMgr()->GetScene(getSceneID());
01038               if (scene && scene->GetBVH())
01039               {
01040                      scenePivot = scene->GetBVH()->GetRoot()->GetBSphere()->Center;
01041               }
01042        }
01043 }
01044 
01045 void Navigation::removePitch()
01046 {
01047        NODE_ID cameraID = getCameraID();
01048        Scene * scene = GetSceneMgr()->GetScene(getSceneID());
01049        const SceneNode * camNode = scene->GetNode(cameraID);
01050        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
01051        VECTOR3 camView = camera->GetView().Normalize();
01052        VECTOR3 camUp = camera->GetUp().Normalize();
01053        VECTOR3 camPosition = camera->GetWorldTransMatrix()->ExtractTranslation();
01054        float angle = camUp.Dot(VECTOR3(0.0f, 1.0f, 0.0f));
01055        if (angle<-1.0f)
01056               angle = -1.0f;
01057        if (angle>1.0f)
01058               angle = 1.0f;
01059        angle = acos(angle);
01061        angle = camView.Dot(VECTOR3(0.0f, 1.0f, 0.0f))>0 ? -angle : angle;
01062        scene->Transform(cameraID, MATRIX::RotationAxis(camUp.Cross(camView), angle));
01063        scene->UpdateTransformation(cameraID);
01064        scene->TranslateAbs(cameraID, camPosition);
01065        scene->UpdateTransformation(cameraID);
01066 }
01067 
01068 #define M_PI_2     1.57079632679489661923
01069 
01070 void Navigation::alignView(ViewName name)
01071 {
01072        NODE_ID cameraID = getCameraID();
01073        Scene * scene = GetSceneMgr()->GetScene(getSceneID());
01074        if (!scene)
01075               return;
01076 
01077        const SceneNode * camNode = scene->GetNode(cameraID);
01078        if (!camNode || !camNode->IsOfType(SceneNode::CAMERA))
01079               return;
01080 
01081        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
01082        WriteLocker camLock(*camera);
01083 
01084        MATRIX m;
01085 
01086        switch(name)
01087        {
01088        case SIDE:
01089               m *= MATRIX::RotationY(M_PI_2);
01090               break;
01091        case TOP:
01092               m *= MATRIX::RotationX(M_PI_2);
01093               break;
01094        case REAR:
01095               m *= MATRIX::RotationY(M_PI);
01096               break;
01097        };
01098 
01099        scene->SetTransformation(cameraID, m);
01100        scene->UpdateTransformation(cameraID);
01101        scene->Fit(cameraID);
01102 }
01103 
01104 #undef M_PI_2
01105 
01106 wxString Navigation::GetDesc() const
01107 {
01108        return wxT("Process input events and manipulate associated camera");
01109 }
01110 
01111 void Navigation::lowMouseEventTimeout()
01112 {
01113        wxCommandEvent paramEvt = Event::GET_EVT_PARAM_SET_DO(msEventTimeoutParamID, wxT("0"), false);
01114        PostToKernel(paramEvt);
01115 }
01116 
01117 void Navigation::highMouseEventTimeout()
01118 {
01119        wxCommandEvent paramEvt = Event::GET_EVT_PARAM_SET_DO(msEventTimeoutParamID, defaultMouseEventTimeout, false);
01120        PostToKernel(paramEvt);
01121 }
01122 
01124 //Camera Manipulator
01126 
01127 Navigation::NavigationStyleCameraManipulatorSpecific::NavigationStyleCameraManipulatorSpecific(const MODULE_ID & _id, const wxString & _name, Navigation *navigation)
01128 : NavigationStyleInterface(wxT("Default"))
01129 {
01130        this->navigation = navigation;
01131 }
01132 
01133 void Navigation::NavigationStyleCameraManipulatorSpecific::keyStyle(wxKeyEvent & evt)
01134 {
01135        if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_UP)
01136        {
01137               switch (evt.GetKeyCode())
01138               {
01139               case WXK_SPACE:
01140                      {
01141                             wxCommandEvent fsEvt = Event::GET_EVT_RENDER_FULLSCREEN_TOGGLE(navigation->windowID);
01142                             navigation->PostToKernel(fsEvt);
01143                      }
01144                      break;
01145               case WXK_ESCAPE:
01146                      {
01147                             wxCommandEvent fsEvt = Event::GET_EVT_RENDER_FULLSCREEN_SET(navigation->windowID, false);
01148                             navigation->PostToKernel(fsEvt);
01149                      }
01150                      break;
01151               }
01152        }
01153 }
01154 
01155 void Navigation::NavigationStyleCameraManipulatorSpecific::mouseStyle(wxMouseEvent & evt)
01156 {
01157        NODE_ID cameraID = navigation->getCameraID();
01158        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
01159        const SceneNode * camNode = scene->GetNode(cameraID);
01160        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
01161 
01162        if (evt.LeftDClick() && !evt.Moving())
01163        {
01164               navigation->select(scene, camera, evt);
01165        }
01166 
01167        navigation->mouseDelta = wxPoint(evt.GetPosition().x - navigation->lastPos.x, evt.GetPosition().y - navigation->lastPos.y);
01168        if (evt.Dragging() && evt.MiddleIsDown())
01169        {
01170               navigation->zoom(scene, camera, cameraID, navigation->mouseDelta.y, navigation->zoomspeed);
01171        }
01172        else if (evt.Dragging() && evt.RightIsDown())
01173        {
01174               navigation->pan(scene, camera, cameraID, navigation->mouseDelta, navigation->panspeed);
01175        }
01176        else if (evt.Dragging() && evt.LeftIsDown())
01177        {
01178               navigation->rotate(scene, camera, cameraID, evt.GetPosition(), navigation->mouseDelta, false, false, false);
01179        }
01180        else
01181               evt.Skip();
01182 
01183        navigation->lastPos = evt.GetPosition();
01184 }
01185 
01187 //CATIA
01189 
01190 Navigation::NavigationStyleCATIASpecific::NavigationStyleCATIASpecific(const MODULE_ID & _id, const wxString & _name, Navigation *navigation)
01191 : NavigationStyleInterface(wxT("CATIA"))
01192 {
01193        this->navigation = navigation;
01194 
01195        wasLeftOrRightButtonDownWhilePanning = false;
01196        wasDragging = false;
01197        buttonOperationStarted = false;
01198        fly = false;
01199 
01200        flyModeButton = NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("flyMode"), _id),0);
01201        fitAllInButton = NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("fitAllIn"), _id),0);
01202 
01203        panButtonIter = examineButtonsInfo.insert(examineButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("pan"), _id),0)));
01204        rotateButtonIter = examineButtonsInfo.insert(examineButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("rotate"), _id),0)));
01205        zoomInButtonIter = examineButtonsInfo.insert(examineButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("zoomIn"), _id),0)));
01206        zoomOutButtonIter = examineButtonsInfo.insert(examineButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("zoomOut"), _id),0)));
01207 
01208        turnHeadButtonIter = flyModeButtonsInfo.insert(flyModeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("turnHead"), _id),0)));
01209        flyButtonIter = flyModeButtonsInfo.insert(flyModeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("fly"), _id),0)));
01210        accelerateButtonIter = flyModeButtonsInfo.insert(flyModeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("accelerate"), _id),0)));
01211        decelerateButtonIter = flyModeButtonsInfo.insert(flyModeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("decelerate"), _id),0)));
01212 
01213 }
01214 
01215 void Navigation::NavigationStyleCATIASpecific::getAndFixFlyModeButtonValue(const wxCommandEvent & evt)
01216 {
01217        int previousValue = flyModeButton.paramValue;
01218        UPDATE_PARAM_FROM_EVENT_INT(flyModeButton.paramId, flyModeButton.paramValue, evt);
01219        if ( flyModeButton.paramValue != previousValue)
01220        {
01221               flyModeButton.paramValue = !previousValue;
01222               navigation->clearButtonValues(examineButtonsInfo);
01223               navigation->clearButtonValues(flyModeButtonsInfo);
01224               navigation->refreshGUI();
01225        }
01226 }
01227 
01228 void Navigation::NavigationStyleCATIASpecific::getAndFixFitAllInButtonValue(const wxCommandEvent & evt)
01229 {
01230        int previousValue = fitAllInButton.paramValue;
01231        UPDATE_PARAM_FROM_EVENT_INT(fitAllInButton.paramId, fitAllInButton.paramValue, evt);
01232        if ( fitAllInButton.paramValue != previousValue)
01233        {
01234               fitAllInButton.paramValue = !previousValue;
01235        }
01236 }
01237 
01238 void Navigation::NavigationStyleCATIASpecific::getAndFixButtonValues(const wxCommandEvent & evt)
01239 {
01240        navigation->getAndFixButtonValues(evt, examineButtonsInfo);
01241        navigation->getAndFixButtonValues(evt, flyModeButtonsInfo);
01242        getAndFixFlyModeButtonValue(evt);
01243        getAndFixFitAllInButtonValue(evt);
01244 }
01245 
01246 void Navigation::NavigationStyleCATIASpecific::registerButtons()
01247 {
01248        navigation->registerButton(flyModeButton.paramId);
01249        navigation->registerButton(fitAllInButton.paramId);
01250        if (flyModeButton.paramValue)
01251        {
01252               navigation->registerButtonList(flyModeButtonsInfo);
01253        }
01254        else
01255        {
01256               navigation->registerButtonList(examineButtonsInfo);
01257        }
01258 }
01259 
01260 bool Navigation::NavigationStyleCATIASpecific::isCATIAFlyModeEnabled() const
01261 {
01262        return flyModeButton.paramValue ? true : false;
01263 }
01264 
01265 bool Navigation::NavigationStyleCATIASpecific::isAnyButtonSelected() const
01266 {
01267        return navigation->isAnyButtonSelected(examineButtonsInfo) || navigation->isAnyButtonSelected(flyModeButtonsInfo);
01268 }
01269 
01270 void Navigation::NavigationStyleCATIASpecific::buttonEvent()
01271 {
01272        NODE_ID cameraID = navigation->getCameraID();
01273        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
01274        if (!scene)
01275               return;
01276 
01277        const SceneNode * camNode = scene->GetNode(cameraID);
01278        if (!camNode || !camNode->IsOfType(SceneNode::CAMERA))
01279               return;
01280 
01281        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
01282        WriteLocker camLock(*camera);
01283 
01284        if (zoomInButtonIter->paramValue)
01285        {
01286               navigation->zoom(scene, camera, cameraID, 1, -navigation->zoomStep);
01287               navigation->clearButtonValues(examineButtonsInfo);
01288        }
01289        if (zoomOutButtonIter->paramValue)
01290        {
01291               navigation->zoom(scene, camera, cameraID, 1, navigation->zoomStep);
01292               navigation->clearButtonValues(examineButtonsInfo);
01293        }
01294 
01295        if (accelerateButtonIter->paramValue)
01296        {
01297               wxCommandEvent ev = Event::GET_EVT_PARAM_SET_DO(navigation->cruisespeedParamID, wxString::Format(wxT("%g"), navigation->cruisespeed + navigation->flySpeedStep));
01298               navigation->PostToKernel(ev);
01299               navigation->clearButtonValues(flyModeButtonsInfo);
01300        }
01301 
01302        if (decelerateButtonIter->paramValue)
01303        {
01304               wxCommandEvent ev = Event::GET_EVT_PARAM_SET_DO(navigation->cruisespeedParamID, wxString::Format(wxT("%g"), navigation->cruisespeed - navigation->flySpeedStep));
01305               navigation->PostToKernel(ev);
01306               navigation->clearButtonValues(flyModeButtonsInfo);
01307        }
01308        if (fitAllInButton.paramValue)
01309        {
01310               NODE_ID cameraID = navigation->getCameraID();
01311               Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
01312               scene->Fit(cameraID);
01313               fitAllInButton.paramValue = 0;
01314        }
01315 }
01316 
01317 void Navigation::NavigationStyleCATIASpecific::keyStyle(wxKeyEvent & evt)
01318 {
01319        
01320 }
01321 
01322 void Navigation::NavigationStyleCATIASpecific::mouseStyle(wxMouseEvent & evt)
01323 {
01324        NODE_ID cameraID = navigation->getCameraID();
01325        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
01326        const SceneNode * camNode = scene->GetNode(cameraID);
01327        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
01328 
01329        navigation->mouseDelta = wxPoint(evt.GetPosition().x - navigation->lastPos.x, evt.GetPosition().y - navigation->lastPos.y);
01330        if (!isAnyButtonSelected()) //Navigation purely by mouse
01331        {
01332               //LOGDEBUG(wxT("handling pure mouse navigation"));
01333               if (evt.Dragging())
01334               {
01335                      wasDragging = true;
01336               }
01337               else if (evt.MiddleUp() && !wasDragging)
01338               {
01339                      navigation->translateCameraCenterToSelection(scene, camera, cameraID, evt);
01340               }
01341               else if (evt.MiddleUp() && wasDragging)
01342               {
01343                      wasDragging = false;
01344               }
01345 
01346               if (evt.MiddleIsDown())
01347               {
01348                      if (evt.LeftIsDown() || evt.RightIsDown())
01349                      {
01350                             wasLeftOrRightButtonDownWhilePanning = true;
01351                             if (isCATIAFlyModeEnabled())
01352                             {
01353                                    navigation->turnHead(scene, camera, cameraID, navigation->mouseDelta, false);
01354                             }
01355                             else
01356                             {
01357                                    navigation->rotate(scene, camera, cameraID, evt.GetPosition(), navigation->mouseDelta, true, false, false);
01358                             }
01359                      }
01360                      else if (!wasLeftOrRightButtonDownWhilePanning)
01361                      {
01362                             navigation->pan(scene, camera, cameraID, navigation->mouseDelta, navigation->panspeed);
01363                      }
01364                      else if (wasLeftOrRightButtonDownWhilePanning)
01365                      {
01366                             navigation->zoom(scene, camera, cameraID, navigation->mouseDelta.y, navigation->zoomspeed);
01367                      }
01368               }
01369               else if (evt.LeftDown() && !evt.Moving())
01370               {
01371                      navigation->select(scene, camera, evt);
01372               }
01373               else
01374               {
01375                      wasLeftOrRightButtonDownWhilePanning = false;
01376                      evt.Skip();
01377               }
01378        }
01379        else //Navigation by buttons and a following mouse action
01380        {
01381               //LOGDEBUG(wxT("handling button navigation"));
01382               if (evt.LeftIsDown())
01383               {
01384                      buttonOperationStarted = true;
01385                      if (!isCATIAFlyModeEnabled())
01386                      {
01387                             if (panButtonIter->paramValue)
01388                             {
01389                                    navigation->pan(scene, camera, cameraID, navigation->mouseDelta, navigation->panspeed);
01390                             }
01391                             if (rotateButtonIter->paramValue)
01392                             {
01393                                    navigation->rotate(scene, camera, cameraID, evt.GetPosition(), navigation->mouseDelta, true, false, false);
01394                             }
01395                      }
01396                      else
01397                      {
01398                             if (flyButtonIter->paramValue)
01399                             {
01400                                    fly = true;
01401                                    //It seems the mouse event is generated only when the mouse cursor is moved, not when just the button is pressed.
01402                                    //When there is no event in the queue, the run methos is not called frequently. This behavior causes changes of flight
01403                                    //speed depending on whether the user only holds the mouse button or moves the mouse and holds the button.
01404                                    //This fixes the problem.
01405                                    navigation->lowMouseEventTimeout();
01406                             }
01407                             if (turnHeadButtonIter->paramValue)
01408                             {
01409                                    navigation->turnHead(scene, camera, cameraID, navigation->mouseDelta, false);
01410                             }
01411                      }
01412               }
01413               else if (buttonOperationStarted)
01414               {
01415                      buttonOperationStarted = false;
01416                      fly = false;
01417                      navigation->clearButtonValues(examineButtonsInfo);
01418                      navigation->clearButtonValues(flyModeButtonsInfo);
01419                      navigation->highMouseEventTimeout();
01420               }
01421        }
01422 
01423        navigation->lastPos = evt.GetPosition();
01424 }
01425 
01427 //Cortona
01429 
01430 Navigation::NavigationStyleCortonaSpecific::NavigationStyleCortonaSpecific(const MODULE_ID & _id, const wxString & _name, Navigation *navigation)
01431 : NavigationStyleInterface(wxT("Cortona")),
01432 avatarHeightParamID(_name, wxT("avatarHeightCortona"), _id)
01433 {
01434        this->navigation = navigation;
01435 
01436        avatarHeight = 10.0f;
01437        maxStepHeight = 5.0f;
01438        wxCommandEvent paramEvt = Event::GET_EVT_PARAM_SET_DO(avatarHeightParamID, wxString::Format(wxT("%g"),avatarHeight), true);
01439        navigation->PostToKernel(paramEvt);
01440 
01441        walkButtonIter = modeButtonsInfo.insert(modeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("walkCortona"), _id),1)));
01442        flyButtonIter = modeButtonsInfo.insert(modeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("flyCortona"), _id),0)));
01443        studyButtonIter = modeButtonsInfo.insert(modeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("studyCortona"), _id),0)));
01444 
01445        planWalkButtonIter = walkButtonsInfo.insert(walkButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("planWalkCortona"), _id),1)));
01446        panWalkButtonIter = walkButtonsInfo.insert(walkButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("panWalkCortona"), _id),0)));
01447        turnWalkButtonIter = walkButtonsInfo.insert(walkButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("turnWalkCortona"), _id),0)));
01448 
01449        planFlyButtonIter = flyButtonsInfo.insert(flyButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("planFlyCortona"), _id),1)));
01450        panFlyButtonIter = flyButtonsInfo.insert(flyButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("panFlyCortona"), _id),0)));
01451        turnFlyButtonIter = flyButtonsInfo.insert(flyButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("turnFlyCortona"), _id),0)));
01452        rollFlyButtonIter = flyButtonsInfo.insert(flyButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("rollFlyCortona"), _id),0)));
01453 
01454        planStudyButtonIter = studyButtonsInfo.insert(studyButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("planStudyCortona"), _id),0)));
01455        panStudyButtonIter = studyButtonsInfo.insert(studyButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("panStudyCortona"), _id),0)));
01456        turnStudyButtonIter = studyButtonsInfo.insert(studyButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("turnStudyCortona"), _id),1)));
01457        rollStudyButtonIter = studyButtonsInfo.insert(studyButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("rollStudyCortona"), _id),0)));
01458 
01459        fitAllInButtonIter = otherButtonsInfo.insert(otherButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("fitAllInCortona"), _id),0)));
01460        goToButtonIter = otherButtonsInfo.insert(otherButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("goToCortona"), _id),0)));
01461        alignButtonIter = otherButtonsInfo.insert(otherButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("alignCortona"), _id),0)));
01462 
01463        operationStarted = false;
01464        gotoOperationStarted = false;
01465        altDown = false;
01466        spaceDown = false;
01467        speedCompensation = 0.01f;
01468 
01469 }
01470 
01471 void Navigation::NavigationStyleCortonaSpecific::getAndFixButtonValues(const wxCommandEvent & evt)
01472 {
01473        navigation->clearButtonValuesConditional(evt, modeButtonsInfo);
01474        bool modeChanged = navigation->getAndFixButtonValues(evt, modeButtonsInfo);
01475        navigation->clearButtonValuesConditional(evt, walkButtonsInfo);
01476        navigation->clearButtonValuesConditional(evt, flyButtonsInfo);
01477        navigation->clearButtonValuesConditional(evt, studyButtonsInfo);
01478        navigation->getAndFixButtonValues(evt, walkButtonsInfo);
01479        navigation->getAndFixButtonValues(evt, flyButtonsInfo);
01480        navigation->getAndFixButtonValues(evt, studyButtonsInfo);
01481        navigation->getAndFixButtonValues(evt, otherButtonsInfo);
01482        if (modeChanged)
01483        {
01484               navigation->refreshGUI();
01485        }
01486 }
01487 
01488 void Navigation::NavigationStyleCortonaSpecific::updateParams(const wxCommandEvent & evt)
01489 {
01490        UPDATE_PARAM_FROM_EVENT_FLOAT(avatarHeightParamID, avatarHeight, evt);
01491 }
01492 
01493 void Navigation::NavigationStyleCortonaSpecific::registerButtons()
01494 {
01495        navigation->registerTextControl(avatarHeightParamID, wxString::Format(wxT("%g"), avatarHeight));
01496 
01497        navigation->registerButtonList(modeButtonsInfo);
01498 
01499        if (walkButtonIter->paramValue)
01500        {
01501               navigation->registerButtonList(walkButtonsInfo);
01502        }
01503        else if (flyButtonIter->paramValue)
01504        {
01505               navigation->registerButtonList(flyButtonsInfo);
01506        }
01507        else if (studyButtonIter->paramValue)
01508        {
01509               navigation->registerButtonList(studyButtonsInfo);
01510        }
01511        navigation->registerButtonList(otherButtonsInfo);
01512 }
01513 
01514 void Navigation::NavigationStyleCortonaSpecific::buttonEvent()
01515 {
01516        if (fitAllInButtonIter->paramValue)
01517        {
01518               NODE_ID cameraID = navigation->getCameraID();
01519               Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
01520               scene->Fit(cameraID);
01521               fitAllInButtonIter->paramValue = 0;
01522        }
01523        if (goToButtonIter->paramValue)
01524        {
01525               gotoOperationStarted = true;
01526               goToButtonIter->paramValue = 0;
01527        }
01528        if (alignButtonIter->paramValue)
01529        {
01530               navigation->removePitch();
01531               alignButtonIter->paramValue = 0;
01532        }
01533 }
01534 
01535 wxPoint Navigation::NavigationStyleCortonaSpecific::getMouseDelta(const wxMouseEvent & evt) const
01536 {
01537        return wxPoint(
01538               evt.GetPosition().x - mouseOperationOrigin.x,
01539               evt.GetPosition().y - mouseOperationOrigin.y);
01540 }
01541 
01542 void Navigation::NavigationStyleCortonaSpecific::keyStyle(wxKeyEvent & evt)
01543 {
01544        if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_DOWN)
01545        {
01546               switch (evt.GetKeyCode())
01547               {
01548               case WXK_ALT: //Alt key is used in cortona, but in vrut, the alt key accesses the applicaction menu which causes interruption in navigation
01549                      {
01550                             altDown = true;
01551                      }
01552                      break;
01553               case WXK_SPACE:
01554                      {
01555                             spaceDown = true;
01556                      }
01557                      break;
01558               }
01559        }
01560        else if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_UP)
01561        {
01562               int cortonaWalk = walkButtonIter->paramValue;
01563               int cortonaFly = flyButtonIter->paramValue;
01564               int cortonaStudy = studyButtonIter->paramValue;
01565 
01566               switch (evt.GetKeyCode())
01567               {
01568               case WXK_ALT:
01569                      altDown = false;
01570                      break;
01571               case WXK_SPACE:
01572                      spaceDown = false;
01573                      break;
01574               }
01575 
01576               switch (evt.GetKeyCode())
01577               {
01578               case WXK_ALT:
01579               case WXK_SPACE:
01580                      if (cortonaWalk)
01581                      {
01582                             navigation->clearButtonValues(walkButtonsInfo);
01583                             planWalkButtonIter->paramValue = 1;
01584                      }
01585                      else if (cortonaFly)
01586                      {
01587                             navigation->clearButtonValues(flyButtonsInfo);
01588                             planFlyButtonIter->paramValue = 1;
01589                      }
01590                      else if (cortonaStudy)
01591                      {
01592                             navigation->clearButtonValues(studyButtonsInfo);
01593                             turnStudyButtonIter->paramValue = 1;
01594                      }
01595                      break;
01596               }
01597        }
01598 }
01599 
01600 void Navigation::NavigationStyleCortonaSpecific::mouseStyle(wxMouseEvent & evt)
01601 {
01602        NODE_ID cameraID = navigation->getCameraID();
01603        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
01604        const SceneNode * camNode = scene->GetNode(cameraID);
01605        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
01606 
01607        navigation->mouseDelta = getMouseDelta(evt);
01608 
01609        if (evt.LeftIsDown())
01610        {
01611               if (gotoOperationStarted)
01612               {
01613                      navigation->translateCameraCenterToSelection(scene, camera, cameraID, evt);
01614                      gotoOperationStarted = false;
01615               }
01616               if (!operationStarted)
01617               {
01618                      mouseOperationOrigin = evt.GetPosition();
01619                      navigation->mouseDelta = getMouseDelta(evt);
01620                      navigation->lowMouseEventTimeout();
01621                      operationStarted = true;
01622               }
01623        }
01624        else
01625        {
01626               if (operationStarted)
01627               {
01628                      operationStarted = false;
01629                      navigation->highMouseEventTimeout();
01630               }
01631               evt.Skip();
01632        }
01633 }
01634 
01636 //CINEMA4D
01638 
01639 Navigation::NavigationStyleCinema4DSpecific::NavigationStyleCinema4DSpecific(const MODULE_ID & _id, const wxString & _name, Navigation *navigation)
01640 : NavigationStyleInterface(wxT("Cinema4D"))
01641 {
01642        this->navigation = navigation;
01643 
01644        panButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("panCinema4D"), _id),1)));
01645        zoomButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("zoomCinema4D"), _id),0)));
01646        rotateButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("rotateCinema4D"), _id),0)));
01647 
01648        ctrlDown = false;
01649        wasDragging = false;
01650 }
01651 
01652 void Navigation::NavigationStyleCinema4DSpecific::getAndFixButtonValues(const wxCommandEvent & evt)
01653 {
01654        navigation->clearButtonValuesConditional(evt, navigationButtonsInfo);
01655        navigation->getAndFixButtonValues(evt, navigationButtonsInfo);
01656 }
01657 
01658 void Navigation::NavigationStyleCinema4DSpecific::registerButtons()
01659 {
01660        navigation->registerButtonList(navigationButtonsInfo);
01661 }
01662 
01663 void Navigation::NavigationStyleCinema4DSpecific::buttonEvent()
01664 {
01665        
01666 }
01667 
01668 void Navigation::NavigationStyleCinema4DSpecific::keyStyle(wxKeyEvent & evt)
01669 {
01670        if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_DOWN)
01671        {
01672               switch (evt.GetKeyCode())
01673               {
01674               case WXK_NUMPAD1:
01675                      {
01676                             navigation->clearButtonValues(navigationButtonsInfo);
01677                             panButtonIter->paramValue = 1;
01678                      }
01679                      break;
01680               case WXK_NUMPAD2:
01681                      {
01682                             navigation->clearButtonValues(navigationButtonsInfo);
01683                             zoomButtonIter->paramValue = 1;
01684                      }
01685                      break;
01686               case WXK_NUMPAD3:
01687                      {
01688                             navigation->clearButtonValues(navigationButtonsInfo);
01689                             rotateButtonIter->paramValue = 1;
01690                      }
01691                      break;
01692               case WXK_CONTROL:
01693                      {
01694                             ctrlDown = true;
01695                      }
01696                      break;
01697               }
01698        }
01699        else if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_UP)
01700        {
01701               switch (evt.GetKeyCode())
01702               {
01703               case WXK_CONTROL:
01704                      {
01705                             ctrlDown = false;
01706                      }
01707                      break;
01708               }
01709        }
01710 }
01711 
01712 void Navigation::NavigationStyleCinema4DSpecific::selectionClick(wxMouseEvent & evt, Scene * scene, Camera * camera)
01713 {
01714        if (evt.Dragging())
01715        {
01716               wasDragging = true;
01717        }
01718        else if (evt.LeftUp() && !wasDragging)
01719        {
01720               navigation->select(scene, camera, evt);
01721               const SceneNode *node = scene->GetNode(navigation->selectedObject);
01722               if (node)
01723               {
01724                      navigation->scenePivot = node->GetWorldTransMatrix()->ExtractTranslation();
01725               }
01726               else
01727               {
01728                      navigation->scenePivotWasSet = false;
01729               }
01730        }
01731        else if (evt.LeftUp() && wasDragging)
01732        {
01733               wasDragging = false;
01734        }
01735 }
01736 
01737 void Navigation::NavigationStyleCinema4DSpecific::mouseStyle(wxMouseEvent & evt)
01738 {
01739        NODE_ID cameraID = navigation->getCameraID();
01740        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
01741        const SceneNode * camNode = scene->GetNode(cameraID);
01742        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
01743 
01744        selectionClick(evt, scene, camera);
01745 
01746        navigation->mouseDelta = wxPoint(evt.GetPosition().x - navigation->lastPos.x, evt.GetPosition().y - navigation->lastPos.y);
01747 
01748        if (evt.GetEventType() == wxEVT_MOUSEWHEEL)
01749        {
01750               navigation->zoom(scene, camera, cameraID, -evt.GetWheelRotation(), navigation->zoomspeed);
01751        }
01752 
01753        if (panButtonIter->paramValue)
01754        {
01755               if (evt.Dragging() && (evt.LeftIsDown() || evt.MiddleIsDown()))
01756               {
01757                      navigation->pan(scene, camera, cameraID, navigation->mouseDelta, navigation->panspeed);
01758               }
01759               else if (evt.Dragging() && evt.RightIsDown())
01760               {
01761                      navigation->zoom(scene, camera, cameraID, -navigation->mouseDelta.x, navigation->zoomspeed);
01762               }
01763        }
01764        else if (zoomButtonIter->paramValue)
01765        {
01766               if (evt.Dragging() && (evt.LeftIsDown() || evt.MiddleIsDown()))
01767               {
01768                      navigation->zoom(scene, camera, cameraID, -navigation->mouseDelta.x, navigation->zoomspeed);
01769               }
01770               else if (evt.Dragging() && evt.RightIsDown())
01771               {
01772                      navigation->fovChangeOperationStarted = true;
01773 
01774                      float previousFov = navigation->fov;
01775                      navigation->fov -= navigation->mouseDelta.x;
01776                      if (navigation->fov > 180.0f)
01777                             navigation->fov = 180.0f;
01778                      if (navigation->fov < 0.0f)
01779                             navigation->fov = 0.0f;
01780 
01781                      wxCommandEvent camEvt = Event::GET_EVT_SCENE_CAM_PROJECTION_SET(navigation->getSceneID(), navigation->getCameraID(), 0, 0, navigation->nearPlane, navigation->farPlane, navigation->fov);
01782                      navigation->PostToKernel(camEvt, true);
01784                      if (previousFov != navigation->fov)
01785                             navigation->WaitForEvent(Event::EVT_SCENE_CAM_PROJECTION_CHANGED, 100, int(navigation->getSceneID()), int(navigation->getCameraID()));
01786               }
01787        }
01788        else if (rotateButtonIter->paramValue)
01789        {
01790               if (!ctrlDown)
01791               {
01792                      if (evt.Dragging() && (evt.LeftIsDown() || evt.MiddleIsDown()))
01793                      {
01794                             navigation->rotate(scene, camera, cameraID, evt.GetPosition(), navigation->mouseDelta, false, true, true);
01795                      }
01796                      else if (evt.Dragging() && evt.RightIsDown())
01797                      {
01798                             navigation->roll(scene, camera, cameraID, -navigation->mouseDelta.x, navigation->rotspeed, true);
01799                      }
01800               }
01801               else
01802               {
01803                      if (evt.Dragging() && (evt.LeftIsDown() || evt.MiddleIsDown()))
01804                      {
01805                             navigation->turnHead(scene, camera, cameraID, navigation->mouseDelta, true);
01806                      }
01807                      else if (evt.Dragging() && evt.RightIsDown())
01808                      {
01809                             navigation->roll(scene, camera, cameraID, -navigation->mouseDelta.x, navigation->rotspeed, false);
01810                      }
01811               }
01812        }
01813        else
01814               evt.Skip();
01815 
01816        //update the fov param id only when the user releases the button
01817        if (navigation->fovChangeOperationStarted && !evt.RightIsDown())
01818        {
01819               navigation->fovChangeOperationStarted = false;
01820               ReadLocker rLock(*camNode);
01821               wxCommandEvent ev1 = Event::GET_EVT_PARAM_SET_DO(navigation->fovParamID, wxString::Format(wxT("%g"), ((Camera *)camNode)->GetFOV()));
01822               navigation->PostToKernel(ev1);
01823        }
01824 
01825        navigation->lastPos = evt.GetPosition();
01826 }
01827 
01829 //MAYA
01831 
01832 Navigation::NavigationStyleMayaSpecific::NavigationStyleMayaSpecific(const MODULE_ID & _id, const wxString & _name, Navigation *navigation)
01833 : NavigationStyleInterface(wxT("Maya"))
01834 {
01835        this->navigation = navigation;
01836 
01837        selectButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("selectMaya"), _id),1)));
01838        tumbleButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("tumbleMaya"), _id),0)));
01839        trackButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("trackMaya"), _id),0)));
01840        dollyButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("dollyMaya"), _id),0)));
01841        zoomButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("zoomMaya"), _id),0)));
01842        rollButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("rollMaya"), _id),0)));
01843        azimuthElevationButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("azimuthElevationMaya"), _id),0)));
01844        yawPitchButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("yawPitchMaya"), _id),0)));
01845        flyButtonIter = navigationButtonsInfo.insert(navigationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("flyMaya"), _id),0)));
01846 
01847        altDown = false;
01848        shiftDown = false;
01849        axisAlignedRotateOperationStarted = false;
01850        axisAlignedXaxis = false;
01851 }
01852 
01853 void Navigation::NavigationStyleMayaSpecific::getAndFixButtonValues(const wxCommandEvent & evt)
01854 {
01855        navigation->clearButtonValuesConditional(evt, navigationButtonsInfo);
01856        navigation->getAndFixButtonValues(evt, navigationButtonsInfo);
01857 }
01858 
01859 void Navigation::NavigationStyleMayaSpecific::registerButtons()
01860 {
01861        navigation->registerButtonList(navigationButtonsInfo);
01862 }
01863 
01864 void Navigation::NavigationStyleMayaSpecific::buttonEvent()
01865 {
01866        
01867 }
01868 
01869 void Navigation::NavigationStyleMayaSpecific::keyStyle(wxKeyEvent & evt)
01870 {
01871        if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_DOWN)
01872        {
01873               NODE_ID cameraID = navigation->getCameraID();
01874               Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
01875               if (!scene)
01876                      return;
01877 
01878               const SceneNode * camNode = scene->GetNode(cameraID);
01879               if (!camNode || !camNode->IsOfType(SceneNode::CAMERA))
01880                      return;
01881 
01882               Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
01883               
01884               if (evt.GetUnicodeKey() == wxChar(L'F'))
01885               {
01886                      scene->Fit(cameraID);
01887               }
01888 
01889               switch (evt.GetKeyCode())
01890               {
01891               case WXK_ALT:
01892                      {
01893                             altDown = true;
01894                      }
01895                      break;
01896               case WXK_SHIFT:
01897                      {
01898                             shiftDown = true;
01899                      }
01900                      break;
01901               }
01902        }
01903        else if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_UP)
01904        {
01905               switch (evt.GetKeyCode())
01906               {
01907               case WXK_ALT:
01908                      {
01909                             altDown = false;
01910                      }
01911                      break;
01912               case WXK_SHIFT:
01913                      {
01914                             shiftDown = false;
01915                      }
01916                      break;
01917               }
01918        }
01919 }
01920 
01921 void Navigation::NavigationStyleMayaSpecific::mouseStyle(wxMouseEvent & evt)
01922 {
01923        NODE_ID cameraID = navigation->getCameraID();
01924        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
01925        const SceneNode * camNode = scene->GetNode(cameraID);
01926        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
01927 
01928        navigation->mouseDelta = wxPoint(evt.GetPosition().x - navigation->lastPos.x, evt.GetPosition().y - navigation->lastPos.y);
01929 
01930        if (evt.GetEventType() == wxEVT_MOUSEWHEEL)
01931        {
01932               navigation->zoom(scene, camera, cameraID, -evt.GetWheelRotation(), navigation->zoomspeed);
01933        }
01934 
01935 
01936        if (shiftDown)
01937        {
01938               if (!axisAlignedRotateOperationStarted)
01939               {
01940                      axisAlignedRotateOperationStarted = true;
01941                      if (abs(navigation->mouseDelta.x) > abs(navigation->mouseDelta.y))
01942                      {
01943                             axisAlignedXaxis = true;
01944                      }
01945                      else
01946                      {
01947                             axisAlignedXaxis = false;
01948                      }
01949                      LOGDEBUG(wxT("axis set"));
01950               }
01951               navigation->mouseDelta = wxPoint(axisAlignedXaxis ? navigation->mouseDelta.x : 0, axisAlignedXaxis ? 0 : navigation->mouseDelta.y);
01952        }
01953        else
01954        {
01955               axisAlignedRotateOperationStarted = false;
01956        }
01957        if (evt.LeftUp() || evt.MiddleUp() || evt.RightUp())
01958        {
01959               axisAlignedRotateOperationStarted = false;
01960        }
01961               
01962 
01963        if (altDown)
01964        {
01965               if (evt.Dragging() && evt.LeftIsDown())
01966               {
01967                      navigation->rotate(scene, camera, cameraID, evt.GetPosition(), navigation->mouseDelta, false, true, false);
01968               }
01969               else if (evt.Dragging() && evt.MiddleIsDown())
01970               {
01971                      navigation->pan(scene, camera, cameraID, navigation->mouseDelta, navigation->panspeed);
01972               }
01973               else if (evt.Dragging() && evt.RightIsDown())
01974               {
01975                      navigation->zoom(scene, camera, cameraID, -navigation->mouseDelta.x, navigation->zoomspeed);
01976               }
01977        }
01978        else {
01979 
01980               if (evt.LeftIsDown() && !evt.Dragging() && selectButtonIter->paramValue)
01981               {
01982                      navigation->select(scene, camera, evt);
01983               }
01984 
01985               if (flyButtonIter->paramValue)
01986               {
01987                      if (evt.Dragging() && evt.LeftIsDown())
01988                      {
01989                             navigation->turnHead(scene, camera, cameraID, navigation->mouseDelta, true);
01990                      }
01991               }
01992 
01993               if (evt.Dragging() && (evt.LeftIsDown() || evt.MiddleIsDown()))
01994               {
01995                      if (tumbleButtonIter->paramValue)
01996                      {
01997                             navigation->rotate(scene, camera, cameraID, evt.GetPosition(), navigation->mouseDelta, false, true, false);
01998                      }
01999                      else if (trackButtonIter->paramValue)
02000                      {
02001                             navigation->pan(scene, camera, cameraID, navigation->mouseDelta, navigation->panspeed);
02002                      }
02003                      else if (dollyButtonIter->paramValue)
02004                      {
02005                             navigation->zoom(scene, camera, cameraID, -navigation->mouseDelta.x, navigation->zoomspeed);
02006                      }
02007                      else if (zoomButtonIter->paramValue)
02008                      {
02009                             navigation->fovChangeOperationStarted = true;
02010 
02011                             float previousFov = navigation->fov;
02012                             navigation->fov -= navigation->mouseDelta.x;
02013                             if (navigation->fov > 180.0f)
02014                                    navigation->fov = 180.0f;
02015                             if (navigation->fov < 0.0f)
02016                                    navigation->fov = 0.0f;
02017 
02018                             wxCommandEvent camEvt = Event::GET_EVT_SCENE_CAM_PROJECTION_SET(navigation->getSceneID(), navigation->getCameraID(), 0, 0, navigation->nearPlane, navigation->farPlane, navigation->fov);
02019                             navigation->PostToKernel(camEvt, true);
02021                             if (previousFov != navigation->fov) //Event occurs only when the value changed otherwise it is discarded. If nothing changed we would be waiting 100ms which is causing an enormous lag.
02022                                    navigation->WaitForEvent(Event::EVT_SCENE_CAM_PROJECTION_CHANGED, 100, int(navigation->getSceneID()), int(navigation->getCameraID()));
02023                      }
02024                      else if (rollButtonIter->paramValue)
02025                      {
02026                             navigation->roll(scene, camera, cameraID, -navigation->mouseDelta.x, navigation->rotspeed, false);
02027                      }
02028                      else if (azimuthElevationButtonIter->paramValue)
02029                      {
02030                             navigation->rotate(scene, camera, cameraID, evt.GetPosition(), navigation->mouseDelta, false, false, false);
02031                      }
02032                      else if (yawPitchButtonIter->paramValue)
02033                      {
02034                             navigation->turnHead(scene, camera, cameraID, wxPoint(navigation->mouseDelta.x, -navigation->mouseDelta.y), true);
02035                      }
02036               }
02037               else
02038                      evt.Skip();
02039        }
02040 
02041        //update the fov param id only when the user releases the button
02042        if (navigation->fovChangeOperationStarted && !(evt.LeftIsDown() || evt.MiddleIsDown()))
02043        {
02044               navigation->fovChangeOperationStarted = false;
02045               ReadLocker rLock(*camNode);
02046               wxCommandEvent ev1 = Event::GET_EVT_PARAM_SET_DO(navigation->fovParamID, wxString::Format(wxT("%g"), ((Camera *)camNode)->GetFOV()));
02047               navigation->PostToKernel(ev1);
02048        }
02049 
02050        navigation->lastPos = evt.GetPosition();
02051 }
02052 
02054 //DeltaView
02056 
02057 Navigation::NavigationStyleDeltaViewSpecific::NavigationStyleDeltaViewSpecific(const MODULE_ID & _id, const wxString & _name, Navigation *navigation)
02058 : NavigationStyleInterface(wxT("DeltaView"))
02059 {
02060        this->navigation = navigation;
02061 
02062        altDown = false;
02063        ctrlDown = false;
02064        shiftDown = false;
02065        axisAlignedRotateOperationStarted = false;
02066        axisAlignedXaxis = false;
02067 }
02068 
02069 void Navigation::NavigationStyleDeltaViewSpecific::getAndFixButtonValues(const wxCommandEvent & evt)
02070 {
02071 
02072 }
02073 
02074 void Navigation::NavigationStyleDeltaViewSpecific::registerButtons()
02075 {
02076 
02077 }
02078 
02079 void Navigation::NavigationStyleDeltaViewSpecific::buttonEvent()
02080 {
02081        
02082 }
02083 
02084 void Navigation::NavigationStyleDeltaViewSpecific::keyStyle(wxKeyEvent & evt)
02085 {
02086        if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_DOWN)
02087        {
02088               switch (evt.GetKeyCode())
02089               {
02090               case WXK_ALT:
02091                      {
02092                             altDown = true;
02093                      }
02094                      break;
02095               case WXK_CONTROL:
02096                      {
02097                             ctrlDown = true;
02098                      }
02099                      break;
02100               case WXK_SHIFT:
02101                      {
02102                             shiftDown = true;
02103                      }
02104                      break;
02105               }
02106        }
02107        else if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_UP)
02108        {
02109               switch (evt.GetKeyCode())
02110               {
02111               case WXK_ALT:
02112                      {
02113                             altDown = false;
02114                      }
02115                      break;
02116               case WXK_CONTROL:
02117                      {
02118                             ctrlDown = false;
02119                      }
02120                      break;
02121               case WXK_SHIFT:
02122                      {
02123                             shiftDown = false;
02124                      }
02125                      break;
02126               }
02127        }
02128 }
02129 
02130 void Navigation::NavigationStyleDeltaViewSpecific::mouseStyle(wxMouseEvent & evt)
02131 {
02132        NODE_ID cameraID = navigation->getCameraID();
02133        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
02134        const SceneNode * camNode = scene->GetNode(cameraID);
02135        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
02136 
02137        navigation->mouseDelta = wxPoint(evt.GetPosition().x - navigation->lastPos.x, evt.GetPosition().y - navigation->lastPos.y);
02138 
02139        if (ctrlDown && !altDown && !shiftDown)
02140        {
02141               if (evt.Dragging())
02142               {
02143                      if (evt.LeftIsDown())
02144                      {
02145                             navigation->rotate(scene, camera, cameraID, evt.GetPosition(), navigation->mouseDelta, false, true, true);
02146                      }
02147                      else if (evt.MiddleIsDown())
02148                      {
02149                             navigation->pan(scene, camera, cameraID, navigation->mouseDelta, navigation->panspeed);
02150                      }
02151                      else if (evt.RightIsDown())
02152                      {
02153                             navigation->zoom(scene, camera, cameraID, -navigation->mouseDelta.y, navigation->zoomspeed);
02154                      }
02155               }
02156        }
02157 
02158        if (shiftDown && !ctrlDown && !altDown)
02159        {
02160               if (evt.RightIsDown())
02161               {
02162                      navigation->pickScenePivot(scene, camera, cameraID, evt);
02163               }
02164        }
02165 
02166        if (ctrlDown && altDown && !shiftDown)
02167        {
02168               if (evt.Dragging())
02169               {
02170                      if (!axisAlignedRotateOperationStarted)
02171                      {
02172                             axisAlignedRotateOperationStarted = true;
02173                             if (abs(navigation->mouseDelta.x) > abs(navigation->mouseDelta.y))
02174                             {
02175                                    axisAlignedXaxis = true;
02176                             }
02177                             else
02178                             {
02179                                    axisAlignedXaxis = false;
02180                             }
02181                      }
02182 
02183                      wxPoint axisAlignedDelta = wxPoint(axisAlignedXaxis ? navigation->mouseDelta.x : 0, axisAlignedXaxis ? 0 : navigation->mouseDelta.y);
02184                      
02185                      if (evt.LeftIsDown())
02186                      {
02187                             navigation->rotate(scene, camera, cameraID, evt.GetPosition(), axisAlignedDelta, false, true, true);
02188                      }
02189                      if (evt.RightIsDown()) //DeltaView uses middle button, but this triggers the wxWidgets About window.
02190                      {
02191                             navigation->pan(scene, camera, cameraID, axisAlignedDelta, navigation->panspeed);
02192                      }
02193               }
02194               else
02195               {
02196                      axisAlignedRotateOperationStarted = false;
02197               }
02198        }
02199 
02200        if (ctrlDown && !altDown && shiftDown)
02201        {
02202               if (evt.Dragging() && evt.LeftIsDown())
02203               {
02204                      navigation->turnHead(scene, camera, cameraID, navigation->mouseDelta, true); 
02205               }
02206        }
02207 
02208        if (!ctrlDown && altDown && !shiftDown)
02209        {
02210               if (evt.RightIsDown())
02211               {
02212                      scene->Fit(cameraID);
02213               }
02214        }
02215 
02216        navigation->lastPos = evt.GetPosition();
02217 }
02218 
02220 //ICEM Surf
02222 
02223 Navigation::NavigationStyleICEMSurfSpecific::NavigationStyleICEMSurfSpecific(const MODULE_ID & _id, const wxString & _name, Navigation *navigation)
02224 : NavigationStyleInterface(wxT("ICEM Surf"))
02225 {
02226        this->navigation = navigation;
02227 
02228        freeButtonIter = navigationModeButtonsInfo.insert(navigationModeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("freeICEMSurf"), _id),1)));
02229        walkButtonIter = navigationModeButtonsInfo.insert(navigationModeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("walkICEMSurf"), _id),0)));
02230        flyButtonIter = navigationModeButtonsInfo.insert(navigationModeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("flyICEMSurf"), _id),0)));
02231        turnHeadButtonIter = navigationModeButtonsInfo.insert(navigationModeButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("turnHeadICEMSurf"), _id),0)));
02232 
02233        zoomOutButtonIter = otherButtonsInfo.insert(otherButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("zoomOutICEMSurf"), _id),0)));
02234        zoomInButtonIter = otherButtonsInfo.insert(otherButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("zoomInICEMSurf"), _id),0)));
02235        sideViewButtonIter = otherButtonsInfo.insert(otherButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("sideViewICEMSurf"), _id),0)));
02236        topViewButtonIter = otherButtonsInfo.insert(otherButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("topViewICEMSurf"), _id),0)));
02237        frontViewButtonIter = otherButtonsInfo.insert(otherButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("frontViewICEMSurf"), _id),0)));
02238        rearViewButtonIter = otherButtonsInfo.insert(otherButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("rearViewICEMSurf"), _id),0)));
02239 
02240        centerOfGeometryButtonIter = centerOfRotationButtonsInfo.insert(centerOfRotationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("centreOfGeometryCentreOfRotationICEMSurf"), _id),0)));
02241        dynamicButtonIter = centerOfRotationButtonsInfo.insert(centerOfRotationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("dynamicCentreOfRotationICEMSurf"), _id),0)));
02242        referencePointButtonIter = centerOfRotationButtonsInfo.insert(centerOfRotationButtonsInfo.begin(), ParameterIdentificatorList::value_type(NavigationOperationPair(Parameter::ParameterIdentificator(_name, wxT("referencePointCentreOfRotationICEMSurf"), _id),1)));
02243 
02244        ctrlDown = false;
02245        shiftDown = false;
02246        magnifyingGlass = false;
02247        axisAlignedRotateOperationStarted = false;
02248        axisAlignedXaxis = false;
02249        rotateOperationStarted = false;
02250 }
02251 
02252 void Navigation::NavigationStyleICEMSurfSpecific::getAndFixButtonValues(const wxCommandEvent & evt)
02253 {
02254        navigation->clearButtonValuesConditional(evt, navigationModeButtonsInfo);
02255        navigation->getAndFixButtonValues(evt, navigationModeButtonsInfo);
02256 
02257        navigation->clearButtonValuesConditional(evt, centerOfRotationButtonsInfo);
02258        navigation->getAndFixButtonValues(evt, centerOfRotationButtonsInfo);
02259 
02260        navigation->clearButtonValuesConditional(evt, otherButtonsInfo);
02261        navigation->getAndFixButtonValues(evt, otherButtonsInfo);
02262 }
02263 
02264 void Navigation::NavigationStyleICEMSurfSpecific::registerButtons()
02265 {
02266        navigation->registerButtonList(navigationModeButtonsInfo);
02267        navigation->registerButtonList(centerOfRotationButtonsInfo);
02268        navigation->registerButtonList(otherButtonsInfo);
02269 }
02270 
02271 void Navigation::NavigationStyleICEMSurfSpecific::buttonEvent()
02272 {
02273        NODE_ID cameraID = navigation->getCameraID();
02274        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
02275        if (!scene)
02276               return;
02277 
02278        const SceneNode * camNode = scene->GetNode(cameraID);
02279        if (!camNode || !camNode->IsOfType(SceneNode::CAMERA))
02280               return;
02281 
02282        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
02283        WriteLocker camLock(*camera);
02284 
02285        if (zoomInButtonIter->paramValue)
02286        {
02287               navigation->zoom(scene, camera, cameraID, 1, -navigation->zoomStep);
02288               zoomInButtonIter->paramValue = 0;
02289        }
02290        if (zoomOutButtonIter->paramValue)
02291        {
02292               navigation->zoom(scene, camera, cameraID, 1, navigation->zoomStep);
02293               zoomOutButtonIter->paramValue = 0;
02294        }
02295 
02296        if (centerOfGeometryButtonIter->paramValue)
02297        {
02298               navigation->scenePivotWasSet = false;
02299        }
02300 
02301        if (sideViewButtonIter->paramValue)
02302        {
02303               navigation->alignView(SIDE);
02304        }
02305        if (topViewButtonIter->paramValue)
02306        {
02307               navigation->alignView(TOP);
02308        }
02309        if (frontViewButtonIter->paramValue)
02310        {
02311               navigation->alignView(FRONT);
02312        }
02313        if (rearViewButtonIter->paramValue)
02314        {
02315               navigation->alignView(REAR);
02316        }
02317 }
02318 
02319 void Navigation::NavigationStyleICEMSurfSpecific::keyStyle(wxKeyEvent & evt)
02320 {
02321        if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_DOWN)
02322        {
02323               switch (evt.GetKeyCode())
02324               {
02325               case WXK_CONTROL:
02326                      {
02327                             ctrlDown = true;
02328                             
02329                      }
02330                      break;
02331               case WXK_SHIFT:
02332                      {
02333                             if (ctrlDown && !shiftDown)
02334                             {
02335                                    magnifyingGlass = true;
02336                                    LOGDEBUG(wxT("Magnifying glass enabled"));
02337                             }
02338                             shiftDown = true;
02339                      }
02340                      break;
02341               }
02342        }
02343        else if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_UP)
02344        {
02345               switch (evt.GetKeyCode())
02346               {
02347               case WXK_CONTROL:
02348                      {
02349                             ctrlDown = false;
02350                             magnifyingGlass = false;
02351                      }
02352                      break;
02353               case WXK_SHIFT:
02354                      {
02355                             shiftDown = false;
02356                             magnifyingGlass = false;
02357                      }
02358                      break;
02359               }
02360        }
02361 }
02362 
02363 /*void Navigation::NavigationStyleICEMSurfSpecific::selectionClick(wxMouseEvent & evt, Scene * scene, Camera * camera)
02364 {
02365        if (evt.Dragging())
02366        {
02367               wasDragging = true;
02368        }
02369        else if (evt.LeftUp() && !wasDragging)
02370        {
02371               navigation->select(scene, camera, evt);
02372               const SceneNode *node = scene->GetNode(navigation->selectedObject);
02373               if (node)
02374               {
02375                      navigation->scenePivot = node->GetWorldTransMatrix()->ExtractTranslation();
02376               }
02377               else
02378               {
02379                      navigation->scenePivotWasSet = false;
02380               }
02381        }
02382        else if (evt.LeftUp() && wasDragging)
02383        {
02384               wasDragging = false;
02385        }
02386 }*/
02387 
02388 void Navigation::NavigationStyleICEMSurfSpecific::mouseStyle(wxMouseEvent & evt)
02389 {
02390        NODE_ID cameraID = navigation->getCameraID();
02391        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
02392        const SceneNode * camNode = scene->GetNode(cameraID);
02393        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
02394 
02395        //selectionClick(evt, scene, camera);
02396 
02397        navigation->mouseDelta = wxPoint(evt.GetPosition().x - navigation->lastPos.x, evt.GetPosition().y - navigation->lastPos.y);
02398 
02399        if (evt.GetEventType() == wxEVT_MOUSEWHEEL)
02400        {
02401               navigation->zoom(scene, camera, cameraID, -evt.GetWheelRotation(), navigation->zoomspeed);
02402        }
02403 
02404        if (shiftDown && ctrlDown && !magnifyingGlass && evt.Dragging())
02405        {
02406               if (!axisAlignedRotateOperationStarted)
02407               {
02408                      axisAlignedRotateOperationStarted = true;
02409                      if (abs(navigation->mouseDelta.x) > abs(navigation->mouseDelta.y))
02410                      {
02411                             axisAlignedXaxis = true;
02412                      }
02413                      else
02414                      {
02415                             axisAlignedXaxis = false;
02416                      }
02417                      LOGDEBUG(wxT("axis set"));
02418               }
02419               navigation->mouseDelta = wxPoint(axisAlignedXaxis ? navigation->mouseDelta.x : 0, axisAlignedXaxis ? 0 : navigation->mouseDelta.y);
02420        }
02421        else
02422        {
02423               axisAlignedRotateOperationStarted = false;
02424        }
02425 
02426        if (shiftDown && !magnifyingGlass)
02427        {
02428               if (evt.Dragging())
02429               {
02430                      if (evt.LeftIsDown())
02431                      {
02432                             if (turnHeadButtonIter->paramValue)
02433                             {
02434                                    navigation->turnHead(scene, camera, cameraID, navigation->mouseDelta, true);
02435                             }
02436                             else
02437                             {
02438                                    if (!rotateOperationStarted && dynamicButtonIter->paramValue)
02439                                    {
02440                                           LOGDEBUG(wxT("Scene pivot pick"));
02441                                           rotateOperationStarted = true;
02442                                           navigation->pickScenePivot(scene, camera, cameraID, evt);
02443                                    }
02444                                    bool rotateAroundScenePivot = (centerOfGeometryButtonIter->paramValue || dynamicButtonIter->paramValue) ? true : false;
02445                                    navigation->rotate(scene, camera, cameraID, evt.GetPosition(), wxPoint(navigation->mouseDelta.x, walkButtonIter->paramValue ? 0 : navigation->mouseDelta.y), false, walkButtonIter->paramValue ? true : false, rotateAroundScenePivot);
02446                             }
02447                      }
02448                      else if (evt.MiddleIsDown())
02449                      {
02450                             navigation->pan(scene, camera, cameraID, navigation->mouseDelta, navigation->panspeed);
02451                      }
02452                      else if (evt.RightIsDown())
02453                      {
02454                             if (freeButtonIter->paramValue || turnHeadButtonIter->paramValue)
02455                             {
02456                                    navigation->fovChangeOperationStarted = true;
02457 
02458                                    float previousFov = navigation->fov;
02459                                    navigation->fov -= navigation->mouseDelta.x;
02460                                    if (navigation->fov > 180.0f)
02461                                           navigation->fov = 180.0f;
02462                                    if (navigation->fov < 0.0f)
02463                                           navigation->fov = 0.0f;
02464 
02465                                    wxCommandEvent camEvt = Event::GET_EVT_SCENE_CAM_PROJECTION_SET(navigation->getSceneID(), navigation->getCameraID(), 0, 0, navigation->nearPlane, navigation->farPlane, navigation->fov);
02466                                    navigation->PostToKernel(camEvt, true);
02468                                    if (previousFov != navigation->fov)
02469                                           navigation->WaitForEvent(Event::EVT_SCENE_CAM_PROJECTION_CHANGED, 100, int(navigation->getSceneID()), int(navigation->getCameraID()));
02470                             }
02471                             else if (walkButtonIter->paramValue || flyButtonIter->paramValue)
02472                             {
02473                                    navigation->zoom(scene, camera, cameraID, navigation->mouseDelta.y, navigation->zoomspeed);
02474                             }
02475                      }
02476               }
02477               else {
02478                      rotateOperationStarted = false;
02479               }
02480        }
02481        else
02482               evt.Skip();
02483 
02484        //update the fov param id only when the user releases the button
02485        if (navigation->fovChangeOperationStarted && !evt.RightIsDown())
02486        {
02487               navigation->fovChangeOperationStarted = false;
02488               ReadLocker rLock(*camNode);
02489               wxCommandEvent ev1 = Event::GET_EVT_PARAM_SET_DO(navigation->fovParamID, wxString::Format(wxT("%g"), ((Camera *)camNode)->GetFOV()));
02490               navigation->PostToKernel(ev1);
02491        }
02492 
02493        navigation->lastPos = evt.GetPosition();
02494 }
02495 
02497 //VRCOM Virtual Design 2
02499 
02500 Navigation::NavigationStyleVD2Specific::NavigationStyleVD2Specific(const MODULE_ID & _id, const wxString & _name, Navigation *navigation)
02501 : NavigationStyleInterface(wxT("Virtual Design 2"))
02502 {
02503        this->navigation = navigation;
02504        centerPickOperationStarted = false;
02505 }
02506 
02507 void Navigation::NavigationStyleVD2Specific::keyStyle(wxKeyEvent & evt)
02508 {
02509        if (int(navigation->windowID) == evt.GetId() && evt.GetEventType() == wxEVT_KEY_UP)
02510        {
02511               if (evt.GetUnicodeKey() == wxChar(L'V'))
02512               {
02513                      LOG(wxT("Pick the new pivot"));
02514                      centerPickOperationStarted = true;
02515               }
02516 
02517               switch (evt.GetKeyCode())
02518               {
02519               case WXK_SPACE:
02520                      {
02521                             wxCommandEvent fsEvt = Event::GET_EVT_RENDER_FULLSCREEN_TOGGLE(navigation->windowID);
02522                             navigation->PostToKernel(fsEvt);
02523                      }
02524                      break;
02525               case WXK_ESCAPE:
02526                      {
02527                             wxCommandEvent fsEvt = Event::GET_EVT_RENDER_FULLSCREEN_SET(navigation->windowID, false);
02528                             navigation->PostToKernel(fsEvt);
02529                      }
02530                      break;
02531               }
02532        }
02533 }
02534 
02535 void Navigation::NavigationStyleVD2Specific::mouseStyle(wxMouseEvent & evt)
02536 {
02537        NODE_ID cameraID = navigation->getCameraID();
02538        Scene * scene = navigation->GetSceneMgr()->GetScene(navigation->getSceneID());
02539        const SceneNode * camNode = scene->GetNode(cameraID);
02540        Camera * camera = (Camera *)(const_cast<SceneNode *>(camNode));
02541 
02542        if (evt.LeftDClick() && !evt.Moving())
02543        {
02544               navigation->select(scene, camera, evt);
02545        }
02546 
02547        if (centerPickOperationStarted && evt.LeftIsDown())
02548        {
02549               navigation->pickScenePivot(scene, camera, cameraID, evt);
02550               navigation->translateCameraCenterToSelection(scene, camera, cameraID, evt);
02551               centerPickOperationStarted = false;
02552        }
02553 
02554        navigation->mouseDelta = wxPoint(evt.GetPosition().x - navigation->lastPos.x, evt.GetPosition().y - navigation->lastPos.y);
02555 
02556        PLANE p;
02557        p = p.FromPointNorm(camera->GetWorldTransMatrix()->ExtractTranslation(), camera->GetView().Normalize());
02558        float speedModifier = fabs(p.DotCoord(navigation->scenePivot) * 0.01f); //If we are getting near to the scene pivot it get smaller
02559 
02560        if (evt.Dragging() && evt.MiddleIsDown())
02561        {
02562               navigation->zoom(scene, camera, cameraID, navigation->mouseDelta.y, navigation->zoomspeed * speedModifier);
02563        }
02564        else if (evt.Dragging() && evt.RightIsDown())
02565        {
02566               navigation->pan(scene, camera, cameraID, navigation->mouseDelta, navigation->panspeed * speedModifier);
02567        }
02568        else if (evt.Dragging() && evt.LeftIsDown())
02569        {
02570               navigation->rotate(scene, camera, cameraID, evt.GetPosition(), navigation->mouseDelta, false, false, true);
02571        }
02572        else
02573               evt.Skip();
02574 
02575        navigation->lastPos = evt.GetPosition();
02576 }