Removing access to the gl widget and display managers

Brad Davis committed 11 years ago

Commit 302aa9d1 parent 539063035 files · +401 −440Browse files

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

Unified · Split

 void Application::paintGL() {
     PROFILE_RANGE(__FUNCTION__);
+    _glWidget->makeCurrent();
     PerformanceTimer perfTimer("paintGL");
+    //Need accurate frame timing for the oculus rift
+    if (OculusManager::isConnected()) {
+        OculusManager::beginFrameTiming();
+    }
     PerformanceWarning::setSuppressShortTimings(Menu::getInstance()->isOptionChecked(MenuOption::SuppressShortTimings));
     bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
                                glm::vec3(0.0f, 0.0f, -1.0f) * MIRROR_FULLSCREEN_DISTANCE * _scaleMirror);
     }
-    // Update camera position
-    if (!OculusManager::isConnected()) {
-        _myCamera.update(1.0f / _fps);
-    }
     if (getShadowsEnabled()) {
         updateShadowMap();
     }
     if (OculusManager::isConnected()) {
         //When in mirror mode, use camera rotation. Otherwise, use body rotation
         if (_myCamera.getMode() == CAMERA_MODE_MIRROR) {
-            OculusManager::display(_myCamera.getRotation(), _myCamera.getPosition(), _myCamera);
+            OculusManager::display(_glWidget, _myCamera.getRotation(), _myCamera.getPosition(), _myCamera);
         } else {
-            OculusManager::display(_myAvatar->getWorldAlignedOrientation(), _myAvatar->getDefaultEyePosition(), _myCamera);
+            OculusManager::display(_glWidget, _myAvatar->getWorldAlignedOrientation(), _myAvatar->getDefaultEyePosition(), _myCamera);
         }
-        _myCamera.update(1.0f / _fps);
     } else if (TV3DManager::isConnected()) {
         TV3DManager::display(_myCamera);
         glPopMatrix();
         if (Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror)) {
-            _rearMirrorTools->render(true);
+            _rearMirrorTools->render(true, _glWidget->mapFromGlobal(QCursor::pos()));
         } else if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
             renderRearViewMirror(_mirrorViewRect);
         }
         }
     }
+    if (!OculusManager::isConnected() || OculusManager::allowSwap()) {
+        _glWidget->swapBuffers();
+    }
+    if (OculusManager::isConnected()) {
+        OculusManager::endFrameTiming();
+    }
     _frameCount++;
 }
 }
 void Application::resizeGL(int width, int height) {
+    DependencyManager::get<TextureCache>()->setFrameBufferSize(QSize(width, height));
     resetCamerasOnResizeGL(_myCamera, width, height);
     glViewport(0, 0, width, height); // shouldn't this account for the menu???
                 if (!event->isAutoRepeat()) {
                     // this starts an HFActionEvent
                     HFActionEvent startActionEvent(HFActionEvent::startType(),
-                                                   _myCamera.computePickRay(getTrueMouseX(),
+                                                   computePickRay(getTrueMouseX(), getTrueMouseY()));
-                                                                            getTrueMouseY()));
                     sendEvent(this, &startActionEvent);
                 }
             if (!event->isAutoRepeat()) {
                 // this ends the HFActionEvent
                 HFActionEvent endActionEvent(HFActionEvent::endType(),
-                                             _myCamera.computePickRay(getTrueMouseX(),
+                                             computePickRay(getTrueMouseX(), getTrueMouseY()));
-                                                                      getTrueMouseY()));
                 sendEvent(this, &endActionEvent);
             }
             break;
             // nobody handled this - make it an action event on the _window object
             HFActionEvent actionEvent(HFActionEvent::startType(),
-                                      _myCamera.computePickRay(event->x(), event->y()));
+                                      computePickRay(event->x(), event->y()));
             sendEvent(this, &actionEvent);
         } else if (event->button() == Qt::RightButton) {
             // fire an action end event
             HFActionEvent actionEvent(HFActionEvent::endType(),
-                                      _myCamera.computePickRay(event->x(), event->y()));
+                                      computePickRay(event->x(), event->y()));
             sendEvent(this, &actionEvent);
         }
     }
     _entityClipboardRenderer.setViewFrustum(getViewFrustum());
     _entityClipboardRenderer.setTree(&_entityClipboard);
-    _rearMirrorTools = new RearMirrorTools(_glWidget, _mirrorViewRect);
+    _rearMirrorTools = new RearMirrorTools(_mirrorViewRect);
     connect(_rearMirrorTools, SIGNAL(closeView()), SLOT(closeMirrorView()));
     connect(_rearMirrorTools, SIGNAL(restoreView()), SLOT(restoreMirrorView()));
     connect(_rearMirrorTools, SIGNAL(shrinkView()), SLOT(shrinkMirrorView()));
     connect(_rearMirrorTools, SIGNAL(resetView()), SLOT(resetSensors()));
-    // make sure our texture cache knows about window size changes
-    DependencyManager::get<TextureCache>()->associateWithWidget(_glWidget);
     // initialize the GlowEffect with our widget
-    DependencyManager::get<GlowEffect>()->init(_glWidget,
+    bool glow = Menu::getInstance()->isOptionChecked(MenuOption::EnableGlowEffect);
-                                               Menu::getInstance()->isOptionChecked(MenuOption::EnableGlowEffect));
+    DependencyManager::get<GlowEffect>()->init(glow);
 }
 void Application::closeMirrorView() {
     // make sure the frustum is up-to-date
     loadViewFrustum(_myCamera, _viewFrustum);
-    PickRay pickRay = _myCamera.computePickRay(getTrueMouseX(), getTrueMouseY());
+    PickRay pickRay = computePickRay(getTrueMouseX(), getTrueMouseY());
     _mouseRayOrigin = pickRay.origin;
     _mouseRayDirection = pickRay.direction;
     return DependencyManager::get<LODManager>()->getBoundaryLevelAdjust();
 }
-PickRay Application::computePickRay(float x, float y) {
+PickRay Application::computePickRay(float x, float y) const {
-    return getCamera()->computePickRay(x, y);
+    glm::vec2 size = getCanvasSize();
+    x /= size.x;
+    y /= size.y;
+    PickRay result;
+    if (isHMDMode()) {
+        ApplicationOverlay::computeHmdPickRay(glm::vec2(x, y), result.origin, result.direction);
+    } else {
+        getViewFrustum()->computePickRay(x, y, result.origin, result.direction);
+    }
+    return result;
 }
 QImage Application::renderAvatarBillboard() {
     return &_viewFrustum;
 }
+const ViewFrustum* Application::getViewFrustum() const {
+#ifdef DEBUG
+    if (QThread::currentThread() == activeRenderingThread) {
+        // FIXME, should this be an assert?
+        qWarning() << "Calling Application::getViewFrustum() from the active rendering thread, did you mean Application::getDisplayViewFrustum()?";
+    }
+#endif
+    return &_viewFrustum;
+}
 ViewFrustum* Application::getDisplayViewFrustum() {
 #ifdef DEBUG
     if (QThread::currentThread() != activeRenderingThread) {
     _mirrorCamera.setAspectRatio((float)region.width() / region.height());
     _mirrorCamera.setRotation(_myAvatar->getWorldAlignedOrientation() * glm::quat(glm::vec3(0.0f, PI, 0.0f)));
-    _mirrorCamera.update(1.0f/_fps);
     // set the bounds of rear mirror view
     if (billboard) {
     glPopMatrix();
     if (!billboard) {
-        _rearMirrorTools->render(false);
+        _rearMirrorTools->render(false, _glWidget->mapFromGlobal(QCursor::pos()));
     }
     // reset Viewport and projection matrix
     player->setMedia(QUrl::fromLocalFile(inf.absoluteFilePath()));
     player->play();
-    QString fileName = Snapshot::saveSnapshot();
+    QString fileName = Snapshot::saveSnapshot(_glWidget->grabFrameBuffer());
     AccountManager& accountManager = AccountManager::getInstance();
     if (!accountManager.isLoggedIn()) {
 void Application::postLambdaEvent(std::function<void()> f) {
     QCoreApplication::postEvent(this, new LambdaEvent(f));
 }
+void Application::initPlugins() {
+    OculusManager::init();
+}
+void Application::shutdownPlugins() {
+    OculusManager::deinit();
+}
+glm::vec3 Application::getHeadPosition() const {
+    return OculusManager::getRelativePosition();
+}
+glm::quat Application::getHeadOrientation() const {
+    return OculusManager::getOrientation();
+}
+glm::uvec2 Application::getCanvasSize() const {
+    return glm::uvec2(_glWidget->width(), _glWidget->height());
+}
+QSize Application::getDeviceSize() const {
+    return _glWidget->getDeviceSize();
+}
+int Application::getTrueMouseX() const {
+    return _glWidget->mapFromGlobal(QCursor::pos()).x();
+}
+int Application::getTrueMouseY() const {
+    return _glWidget->mapFromGlobal(QCursor::pos()).y();
+}
+bool Application::isThrottleRendering() const {
+    return _glWidget->isThrottleRendering();
+}
+PickRay Application::computePickRay() const {
+    return computePickRay(getTrueMouseX(), getTrueMouseY());
+}
+bool Application::hasFocus() const {
+    return _glWidget->hasFocus();
+}
+void Application::resizeGL() {
+    this->resizeGL(_glWidget->getDeviceWidth(), _glWidget->getDeviceHeight());
+}