merge upstream/master into andrew/bispinor

Andrew Meadows committed 11 years ago

Commit 461d08c2 parents bf225e4 da8f995104 files · +2045 −2778Browse files

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

Unified · Split

 #include <glm/gtx/component_wise.hpp>
 #include <glm/gtx/quaternion.hpp>
 #include <glm/gtx/vector_angle.hpp>
+#include <glm/gtc/type_ptr.hpp>
 // include this before QGLWidget, which includes an earlier version of OpenGL
 #include "InterfaceConfig.h"
         _aboutToQuit(false),
         _notifiedPacketVersionMismatchThisDomain(false),
         _domainConnectionRefusals(QList<QString>()),
-        _maxOctreePPS(maxOctreePacketsPerSecond.get())
+        _maxOctreePPS(maxOctreePacketsPerSecond.get()),
+        _lastFaceTrackerUpdate(0)
 {
     setInstance(this);
 #ifdef Q_OS_WIN
 void Application::resetCamerasOnResizeGL(Camera& camera, const glm::uvec2& size) {
     if (OculusManager::isConnected()) {
-        OculusManager::configureCamera(camera, size.x, size.y);
+        OculusManager::configureCamera(camera);
     } else if (TV3DManager::isConnected()) {
         TV3DManager::configureCamera(camera, size.x, size.y);
     } else {
-        camera.setAspectRatio((float)size.x / size.y);
+        camera.setProjection(glm::perspective(glm::radians(_fieldOfView.get()), (float)size.x / size.y, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP));
-        camera.setFieldOfView(_fieldOfView.get());
     }
 }
         renderSize = _glWidget->getDeviceSize() * getRenderResolutionScale();
     }
     if (_renderResolution == toGlm(renderSize)) {
-    	return;
+        return;
     }
     _renderResolution = toGlm(renderSize);
 }
 void Application::updateProjectionMatrix(Camera& camera, bool updateViewFrustum) {
-    glMatrixMode(GL_PROJECTION);
+    _projectionMatrix = camera.getProjection();
-    glLoadIdentity();
-    float left, right, bottom, top, nearVal, farVal;
+    glMatrixMode(GL_PROJECTION);
-    glm::vec4 nearClipPlane, farClipPlane;
+    glLoadMatrixf(glm::value_ptr(_projectionMatrix));
     // Tell our viewFrustum about this change, using the application camera
     if (updateViewFrustum) {
         loadViewFrustum(camera, _viewFrustum);
-        _viewFrustum.computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
+    }
-    } else {
-        ViewFrustum tempViewFrustum;
-        loadViewFrustum(camera, tempViewFrustum);
-        tempViewFrustum.computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
-    }
-    glFrustum(left, right, bottom, top, nearVal, farVal);
-    // save matrix
-    glGetFloatv(GL_PROJECTION_MATRIX, (GLfloat*)&_projectionMatrix);
     glMatrixMode(GL_MODELVIEW);
 }
                 }
                 break;
+#if 0
             case Qt::Key_I:
                 if (isShifted) {
                     _myCamera.setEyeOffsetOrientation(glm::normalize(
                 }
                 updateProjectionMatrix();
                 break;
+#endif
             case Qt::Key_H:
                 if (isShifted) {
                     Menu::getInstance()->triggerOption(MenuOption::Mirror);
         FaceTracker* tracker = getActiveFaceTracker();
         if (tracker && !tracker->isMuted()) {
             tracker->update(deltaTime);
+            // Auto-mute microphone after losing face tracking?
+            if (tracker->isTracking()) {
+                _lastFaceTrackerUpdate = usecTimestampNow();
+            } else {
+                const quint64 MUTE_MICROPHONE_AFTER_USECS = 5000000;  //5 secs
+                Menu* menu = Menu::getInstance();
+                if (menu->isOptionChecked(MenuOption::AutoMuteAudio) && !menu->isOptionChecked(MenuOption::MuteAudio)) {
+                    if (_lastFaceTrackerUpdate > 0
+                        && ((usecTimestampNow() - _lastFaceTrackerUpdate) > MUTE_MICROPHONE_AFTER_USECS)) {
+                        menu->triggerOption(MenuOption::MuteAudio);
+                        _lastFaceTrackerUpdate = 0;
+                    }
+                } else {
+                    _lastFaceTrackerUpdate = 0;
+                }
+            }
+        } else {
+            _lastFaceTrackerUpdate = 0;
         }
         SixenseManager::getInstance().update(deltaTime);
         JoystickScriptingInterface::getInstance().update();
     }
         if (_physicsEngine.hasOutgoingChanges()) {
             _entitySimulation.lock();
             _entitySimulation.handleOutgoingChanges(_physicsEngine.getOutgoingChanges(), _physicsEngine.getSessionID());
-            _entitySimulation.handleCollisionEvents(_physicsEngine.getCollisionEvents());
             _entitySimulation.unlock();
             avatarManager->handleOutgoingChanges(_physicsEngine.getOutgoingChanges());
     if (!_aboutToQuit) {
         PerformanceTimer perfTimer("entities");
-        // NOTE: the _entities.update() call below will wait for lock
+        // Collision events (and their scripts) must not be handled when we're locked, above. (That would risk deadlock.)
+        _entitySimulation.handleCollisionEvents(_physicsEngine.getCollisionEvents());
+        // NOTE: the _entities.update() call below will wait for lock
         // and will simulate entity motion (the EntityTree has been given an EntitySimulation).
-        _entities.update(); // update the models...
+       _entities.update(); // update the models...
     }
     {
     _octreeQuery.setCameraAspectRatio(_viewFrustum.getAspectRatio());
     _octreeQuery.setCameraNearClip(_viewFrustum.getNearClip());
     _octreeQuery.setCameraFarClip(_viewFrustum.getFarClip());
-    _octreeQuery.setCameraEyeOffsetPosition(_viewFrustum.getEyeOffsetPosition());
+    _octreeQuery.setCameraEyeOffsetPosition(glm::vec3());
     auto lodManager = DependencyManager::get<LODManager>();
     _octreeQuery.setOctreeSizeScale(lodManager->getOctreeSizeScale());
     _octreeQuery.setBoundaryLevelAdjust(lodManager->getBoundaryLevelAdjust());
 //
 void Application::loadViewFrustum(Camera& camera, ViewFrustum& viewFrustum) {
     // We will use these below, from either the camera or head vectors calculated above
-    glm::vec3 position(camera.getPosition());
+    viewFrustum.setProjection(camera.getProjection());
-    float fov         = camera.getFieldOfView();    // degrees
-    float nearClip    = camera.getNearClip();
-    float farClip     = camera.getFarClip();
-    float aspectRatio = camera.getAspectRatio();
-    glm::quat rotation = camera.getRotation();
     // Set the viewFrustum up with the correct position and orientation of the camera
-    viewFrustum.setPosition(position);
+    viewFrustum.setPosition(camera.getPosition());
-    viewFrustum.setOrientation(rotation);
+    viewFrustum.setOrientation(camera.getRotation());
-    // Also make sure it's got the correct lens details from the camera
-    viewFrustum.setAspectRatio(aspectRatio);
-    viewFrustum.setFieldOfView(fov);    // degrees
-    viewFrustum.setNearClip(nearClip);
-    viewFrustum.setFarClip(farClip);
-    viewFrustum.setEyeOffsetPosition(camera.getEyeOffsetPosition());
-    viewFrustum.setEyeOffsetOrientation(camera.getEyeOffsetOrientation());
     // Ask the ViewFrustum class to calculate our corners
     viewFrustum.calculate();
         glm::vec3 shadowFrustumCenter = rotation * ((minima + maxima) * 0.5f);
         _shadowViewFrustum.setPosition(shadowFrustumCenter);
         _shadowViewFrustum.setOrientation(rotation);
-        _shadowViewFrustum.setOrthographic(true);
+        _shadowViewFrustum.setProjection(glm::ortho(minima.x, maxima.x, minima.y, maxima.y, minima.z, maxima.z));
-        _shadowViewFrustum.setWidth(maxima.x - minima.x);
-        _shadowViewFrustum.setHeight(maxima.y - minima.y);
-        _shadowViewFrustum.setNearClip(minima.z);
-        _shadowViewFrustum.setFarClip(maxima.z);
-        _shadowViewFrustum.setEyeOffsetPosition(glm::vec3());
-        _shadowViewFrustum.setEyeOffsetOrientation(glm::quat());
         _shadowViewFrustum.calculate();
         glMatrixMode(GL_PROJECTION);
         glFrontFace(GL_CCW);
     }
-    glm::vec3 eyeOffsetPos = theCamera.getEyeOffsetPosition();
-    glm::quat eyeOffsetOrient = theCamera.getEyeOffsetOrientation();
-    glm::vec3 eyeOffsetAxis = glm::axis(eyeOffsetOrient);
-    glRotatef(-glm::degrees(glm::angle(eyeOffsetOrient)), eyeOffsetAxis.x, eyeOffsetAxis.y, eyeOffsetAxis.z);
-    glTranslatef(-eyeOffsetPos.x, -eyeOffsetPos.y, -eyeOffsetPos.z);
     // transform view according to theCamera
     // could be myCamera (if in normal mode)
     // or could be viewFrustumOffsetCamera if in offset mode
     Transform viewTransform;
     viewTransform.setTranslation(theCamera.getPosition());
     viewTransform.setRotation(rotation);
-    viewTransform.postTranslate(eyeOffsetPos);
-    viewTransform.postRotate(eyeOffsetOrient);
     if (theCamera.getMode() == CAMERA_MODE_MIRROR) {
          viewTransform.setScale(Transform::Vec3(-1.0f, 1.0f, 1.0f));
     }
             // finally render the starfield
             if (hasStars) {
-                _stars.render(theCamera.getFieldOfView(), theCamera.getAspectRatio(), theCamera.getNearClip(), alpha);
+                _stars.render(_displayViewFrustum.getFieldOfView(), _displayViewFrustum.getAspectRatio(), _displayViewFrustum.getNearClip(), alpha);
             }
             // draw the sky dome
     // Grab current viewport to reset it at the end
     int viewport[4];
     glGetIntegerv(GL_VIEWPORT, viewport);
+    float aspect = (float)region.width() / region.height();
+    float fov = MIRROR_FIELD_OF_VIEW;
     // bool eyeRelativeCamera = false;
     if (billboard) {
-        _mirrorCamera.setFieldOfView(BILLBOARD_FIELD_OF_VIEW);  // degees
+        fov = BILLBOARD_FIELD_OF_VIEW;  // degees
         _mirrorCamera.setPosition(_myAvatar->getPosition() +
                                   _myAvatar->getOrientation() * glm::vec3(0.0f, 0.0f, -1.0f) * BILLBOARD_DISTANCE * _myAvatar->getScale());
     } else if (RearMirrorTools::rearViewZoomLevel.get() == BODY) {
-        _mirrorCamera.setFieldOfView(MIRROR_FIELD_OF_VIEW);     // degrees
         _mirrorCamera.setPosition(_myAvatar->getChestPosition() +
                                   _myAvatar->getOrientation() * glm::vec3(0.0f, 0.0f, -1.0f) * MIRROR_REARVIEW_BODY_DISTANCE * _myAvatar->getScale());
         // This was removed in commit 71e59cfa88c6563749594e25494102fe01db38e9 but could be further
         // investigated in order to adapt the technique while fixing the head rendering issue,
         // but the complexity of the hack suggests that a better approach
-        _mirrorCamera.setFieldOfView(MIRROR_FIELD_OF_VIEW);     // degrees
         _mirrorCamera.setPosition(_myAvatar->getHead()->getEyePosition() +
                                     _myAvatar->getOrientation() * glm::vec3(0.0f, 0.0f, -1.0f) * MIRROR_REARVIEW_DISTANCE * _myAvatar->getScale());
     }
-    _mirrorCamera.setAspectRatio((float)region.width() / region.height());
+    _mirrorCamera.setProjection(glm::perspective(glm::radians(fov), aspect, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP));
     _mirrorCamera.setRotation(_myAvatar->getWorldAlignedOrientation() * glm::quat(glm::vec3(0.0f, PI, 0.0f)));
     // set the bounds of rear mirror view