one global pickmanager

SamGondelman committed 9 years ago

Commit d7745ef1 parent 3572f7f14 files · +417 −416Browse files

Showing the changes to interface/src/Application.cpp (1 of 14 files). Show all

Unified · Split

 #include <raypick/RayPickScriptingInterface.h>
 #include <raypick/LaserPointerScriptingInterface.h>
+#include <raypick/MouseRayPick.h>
 #include <FadeEffect.h>
     _notifiedPacketVersionMismatchThisDomain(false),
     _maxOctreePPS(maxOctreePacketsPerSecond.get()),
     _lastFaceTrackerUpdate(0),
-    _snapshotSound(nullptr)
+    _snapshotSound(nullptr) {
-{
     auto steamClient = PluginManager::getInstance()->getSteamClientPlugin();
     setProperty(hifi::properties::STEAM, (steamClient && steamClient->isRunning()));
     setProperty(hifi::properties::CRASHED, _previousSessionCrashed);
     installNativeEventFilter(&MyNativeEventFilter::getInstance());
 #endif
     _logger = new FileLogger(this);
     qInstallMessageHandler(messageHandler);
     auto audioIO = DependencyManager::get<AudioClient>();
-    audioIO->setPositionGetter([]{
+    audioIO->setPositionGetter([] {
         auto avatarManager = DependencyManager::get<AvatarManager>();
         auto myAvatar = avatarManager ? avatarManager->getMyAvatar() : nullptr;
         return myAvatar ? myAvatar->getPositionForAudio() : Vectors::ZERO;
     });
-    audioIO->setOrientationGetter([]{
+    audioIO->setOrientationGetter([] {
         auto avatarManager = DependencyManager::get<AvatarManager>();
         auto myAvatar = avatarManager ? avatarManager->getMyAvatar() : nullptr;
         audioIO->handleRecordedAudioInput(frame->data);
     });
-    connect(audioIO.data(), &AudioClient::inputReceived, [](const QByteArray& audio){
+    connect(audioIO.data(), &AudioClient::inputReceived, [](const QByteArray& audio) {
         static auto recorder = DependencyManager::get<recording::Recorder>();
         if (recorder->isRecording()) {
             static const recording::FrameType AUDIO_FRAME_TYPE = recording::Frame::registerFrameType(AudioConstants::getAudioFrameName());
     auto addressManager = DependencyManager::get<AddressManager>();
     // use our MyAvatar position and quat for address manager path
-    addressManager->setPositionGetter([this]{ return getMyAvatar()->getPosition(); });
+    addressManager->setPositionGetter([this] { return getMyAvatar()->getPosition(); });
-    addressManager->setOrientationGetter([this]{ return getMyAvatar()->getOrientation(); });
+    addressManager->setOrientationGetter([this] { return getMyAvatar()->getOrientation(); });
     connect(addressManager.data(), &AddressManager::hostChanged, this, &Application::updateWindowTitle);
     connect(this, &QCoreApplication::aboutToQuit, addressManager.data(), &AddressManager::storeCurrentAddress);
     connect(this, &Application::activeDisplayPluginChanged, this, &Application::updateThreadPoolCount);
-    connect(this, &Application::activeDisplayPluginChanged, this, [](){
+    connect(this, &Application::activeDisplayPluginChanged, this, []() {
         qApp->setProperty(hifi::properties::HMD, qApp->isHMDMode());
     });
     connect(this, &Application::activeDisplayPluginChanged, this, &Application::updateSystemTabletMode);
         DependencyManager::get<AddressManager>().data(), &AddressManager::storeCurrentAddress);
     auto scriptEngines = DependencyManager::get<ScriptEngines>().data();
-    scriptEngines->registerScriptInitializer([this](ScriptEnginePointer engine){
+    scriptEngines->registerScriptInitializer([this](ScriptEnginePointer engine) {
         registerScriptEngineWithApplicationServices(engine);
     });
     }, Qt::QueuedConnection);
     connect(scriptEngines, &ScriptEngines::scriptLoadError,
-        scriptEngines, [](const QString& filename, const QString& error){
+        scriptEngines, [](const QString& filename, const QString& error) {
         OffscreenUi::asyncWarning(nullptr, "Error Loading Script", filename + " failed to load.");
     }, Qt::QueuedConnection);
     }
     // add firstRun flag from settings to launch event
-    Setting::Handle<bool> firstRun { Settings::firstRun, true };
+    Setting::Handle<bool> firstRun{ Settings::firstRun, true };
     // once the settings have been loaded, check if we need to flip the default for UserActivityLogger
     auto& userActivityLogger = UserActivityLogger::getInstance();
             static int lastKey = Qt::Key_unknown;
             bool navAxis = false;
             switch (actionEnum) {
-                case Action::UI_NAV_VERTICAL:
+            case Action::UI_NAV_VERTICAL:
-                    navAxis = true;
+                navAxis = true;
-                    if (state > 0.0f) {
+                if (state > 0.0f) {
-                        key = Qt::Key_Up;
+                    key = Qt::Key_Up;
-                    } else if (state < 0.0f) {
+                } else if (state < 0.0f) {
-                        key = Qt::Key_Down;
+                    key = Qt::Key_Down;
-                    }
+                }
-                    break;
+                break;
-                case Action::UI_NAV_LATERAL:
+            case Action::UI_NAV_LATERAL:
-                    navAxis = true;
+                navAxis = true;
-                    if (state > 0.0f) {
+                if (state > 0.0f) {
-                        key = Qt::Key_Right;
+                    key = Qt::Key_Right;
-                    } else if (state < 0.0f) {
+                } else if (state < 0.0f) {
-                        key = Qt::Key_Left;
+                    key = Qt::Key_Left;
-                    }
+                }
-                    break;
+                break;
-                case Action::UI_NAV_GROUP:
+            case Action::UI_NAV_GROUP:
-                    navAxis = true;
+                navAxis = true;
-                    if (state > 0.0f) {
+                if (state > 0.0f) {
-                        key = Qt::Key_Tab;
+                    key = Qt::Key_Tab;
-                    } else if (state < 0.0f) {
+                } else if (state < 0.0f) {
-                        key = Qt::Key_Backtab;
+                    key = Qt::Key_Backtab;
-                    }
+                }
-                    break;
+                break;
-                case Action::UI_NAV_BACK:
+            case Action::UI_NAV_BACK:
-                    key = Qt::Key_Escape;
+                key = Qt::Key_Escape;
-                    break;
+                break;
-                case Action::UI_NAV_SELECT:
+            case Action::UI_NAV_SELECT:
-                    key = Qt::Key_Return;
+                key = Qt::Key_Return;
-                    break;
+                break;
-                default:
+            default:
-                    break;
+                break;
             }
             auto window = tabletScriptingInterface->getTabletWindow();
     QTimer* settingsTimer = new QTimer();
-    moveToNewNamedThread(settingsTimer, "Settings Thread", [this, settingsTimer]{
+    moveToNewNamedThread(settingsTimer, "Settings Thread", [this, settingsTimer] {
-        connect(qApp, &Application::beforeAboutToQuit, [this, settingsTimer]{
+        connect(qApp, &Application::beforeAboutToQuit, [this, settingsTimer] {
             // Disconnect the signal from the save settings
             QObject::disconnect(settingsTimer, &QTimer::timeout, this, &Application::saveSettings);
             // Stop the settings timer
     // Now that menu is initialized we can sync myAvatar with it's state.
     myAvatar->updateMotionBehaviorFromMenu();
-// FIXME spacemouse code still needs cleanup
+    // FIXME spacemouse code still needs cleanup
 #if 0
     // the 3Dconnexion device wants to be initialized after a window is displayed.
     SpacemouseManager::getInstance().init();
     // If the user clicks an an entity, we will check that it's an unlocked web entity, and if so, set the focus to it
     auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();
     connect(entityScriptingInterface.data(), &EntityScriptingInterface::clickDownOnEntity,
-            [this](const EntityItemID& entityItemID, const PointerEvent& event) {
+        [this](const EntityItemID& entityItemID, const PointerEvent& event) {
         if (getEntities()->wantsKeyboardFocus(entityItemID)) {
             setKeyboardFocusOverlay(UNKNOWN_OVERLAY_ID);
             setKeyboardFocusEntity(entityItemID);
             totalServerOctreeElements += i->second.getTotalElements();
         }
-        properties["local_octree_elements"] = (qint64) OctreeElement::getInternalNodeCount();
+        properties["local_octree_elements"] = (qint64)OctreeElement::getInternalNodeCount();
-        properties["server_octree_elements"] = (qint64) totalServerOctreeElements;
+        properties["server_octree_elements"] = (qint64)totalServerOctreeElements;
         properties["active_display_plugin"] = getActiveDisplayPlugin()->getName();
         properties["using_hmd"] = isHMDMode();
         if (_autoSwitchDisplayModeSupportedHMDPlugin) {
             if (getActiveDisplayPlugin() != _autoSwitchDisplayModeSupportedHMDPlugin &&
                 !_autoSwitchDisplayModeSupportedHMDPlugin->isSessionActive()) {
-                    startHMDStandBySession();
+                startHMDStandBySession();
             }
             // Poll periodically to check whether the user has worn HMD or not. Switch Display mode accordingly.
             // If the user wears HMD then switch to VR mode. If the user removes HMD then switch to Desktop mode.
     connect(checkNearbyAvatarsTimer, &QTimer::timeout, this, [this]() {
         auto avatarManager = DependencyManager::get<AvatarManager>();
         int nearbyAvatars = avatarManager->numberOfAvatarsInRange(avatarManager->getMyAvatar()->getPosition(),
-                                                                  NEARBY_AVATAR_RADIUS_METERS) - 1;
+            NEARBY_AVATAR_RADIUS_METERS) - 1;
         if (nearbyAvatars != lastCountOfNearbyAvatars) {
             lastCountOfNearbyAvatars = nearbyAvatars;
             UserActivityLogger::getInstance().logAction("nearby_avatars", { { "count", nearbyAvatars } });
     connect(&_myCamera, &Camera::modeUpdated, this, &Application::cameraModeChanged);
+    _pickManager.setShouldPickHUDOperator([&]() { return DependencyManager::get<HMDScriptingInterface>()->isHMDMode(); });
     // Setup the mouse ray pick and related operators
-    DependencyManager::get<EntityTreeRenderer>()->setMouseRayPickID(_rayPickManager.createRayPick(
+    DependencyManager::get<EntityTreeRenderer>()->setMouseRayPickID(_pickManager.addPick(RAY, std::make_shared<MouseRayPick>(
-        PickFilter(RayPickScriptingInterface::PICK_ENTITIES() | RayPickScriptingInterface::PICK_INCLUDE_NONCOLLIDABLE()),
+        PickFilter(RayPickScriptingInterface::PICK_ENTITIES() | RayPickScriptingInterface::PICK_INCLUDE_NONCOLLIDABLE()), 0.0f, true)));
-        0.0f, true));
     DependencyManager::get<EntityTreeRenderer>()->setMouseRayPickResultOperator([&](QUuid rayPickID) {
         RayToEntityIntersectionResult entityResult;
         entityResult.intersects = false;
-        QVariantMap result = _rayPickManager.getPrevPickResult(rayPickID);
+        QVariantMap result = _pickManager.getPrevPickResult(rayPickID);
         if (result["type"].isValid()) {
             entityResult.intersects = result["type"] != RayPickScriptingInterface::INTERSECTED_NONE();
             if (entityResult.intersects) {
         return entityResult;
     });
     DependencyManager::get<EntityTreeRenderer>()->setSetPrecisionPickingOperator([&](QUuid rayPickID, bool value) {
-        _rayPickManager.setPrecisionPicking(rayPickID, value);
+        _pickManager.setPrecisionPicking(rayPickID, value);
     });
     qCDebug(interfaceapp) << "Metaverse session ID is" << uuidStringWithoutCurlyBraces(accountManager->getSessionID());
     // TODO: break these out into distinct perfTimers when they prove interesting
     {
-        PROFILE_RANGE(app, "RayPickManager");
+        PROFILE_RANGE(app, "PickManager");
-        _rayPickManager.update();
+        _pickManager.update();
     }
     {