Merge pull request #909 from ey6es/master

Fixes for off-axis projection: handle offset frusta correctly in mirror mode, use an explicit focal length rather than near clip.

interface/resources/shaders/ambient_occlusion.frag

@@ -44,8 +44,7 @@ float texCoordToViewSpaceZ(vec2 texCoord) {
 // given a texture coordinate, returns the 3D view space coordinate
 vec3 texCoordToViewSpace(vec2 texCoord) {
     float z = texCoordToViewSpaceZ(texCoord);
-    return vec3(((texCoord * 2.0 - vec2(1.0 - gl_ProjectionMatrix[2][0], 1.0)) *
+    return vec3((leftBottom + texCoord * (rightTop - leftBottom)) * (-z / near), z);
-        (rightTop - leftBottom) + rightTop + leftBottom) * z / (-2.0 * near), z);
 }
 
 void main(void) {

interface/src/Application.cpp

@@ -423,9 +423,6 @@ void Application::resizeGL(int width, int height) {
     resetCamerasOnResizeGL(_viewFrustumOffsetCamera, width, height);
     resetCamerasOnResizeGL(_myCamera, width, height);
 
-    // Tell our viewFrustum about this change, using the application camera
-    loadViewFrustum(_myCamera, _viewFrustum);
-
     glViewport(0, 0, width, height); // shouldn't this account for the menu???
 
     updateProjectionMatrix();
@@ -436,9 +433,12 @@ void Application::updateProjectionMatrix() {
     glMatrixMode(GL_PROJECTION);
     glLoadIdentity();
     
+    // Tell our viewFrustum about this change, using the application camera
+    loadViewFrustum(_myCamera, _viewFrustum);
+    
     float left, right, bottom, top, nearVal, farVal;
     glm::vec4 nearClipPlane, farClipPlane;
-    _viewFrustum.computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
+    computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
     
     // If we're in Display Frustum mode, then we want to use the slightly adjust near/far clip values of the
     // _viewFrustumOffsetCamera, so that we can see more of the application content in the application's frustum
@@ -631,8 +631,8 @@ void Application::keyPressEvent(QKeyEvent* event) {
                 
             case Qt::Key_J:
                 if (isShifted) {
-                    _myCamera.setEyeOffsetOrientation(glm::normalize(
+                    _viewFrustum.setFocalLength(_viewFrustum.getFocalLength() - 0.1f);
-                                                                     glm::quat(glm::vec3(0, 0.002f, 0)) * _myCamera.getEyeOffsetOrientation()));
+                
                 } else {
                     _myCamera.setEyeOffsetPosition(_myCamera.getEyeOffsetPosition() + glm::vec3(-0.001, 0, 0));
                 }
@@ -641,8 +641,8 @@ void Application::keyPressEvent(QKeyEvent* event) {
                 
             case Qt::Key_M:
                 if (isShifted) {
-                    _myCamera.setEyeOffsetOrientation(glm::normalize(
+                    _viewFrustum.setFocalLength(_viewFrustum.getFocalLength() + 0.1f);
-                                                                     glm::quat(glm::vec3(0, -0.002f, 0)) * _myCamera.getEyeOffsetOrientation()));
+                
                 } else {
                     _myCamera.setEyeOffsetPosition(_myCamera.getEyeOffsetPosition() + glm::vec3(0.001, 0, 0));
                 }
@@ -1805,15 +1805,17 @@ void Application::update(float deltaTime) {
         }
         
         if (Menu::getInstance()->isOptionChecked(MenuOption::OffAxisProjection)) {
+            float xSign = Menu::getInstance()->isOptionChecked(MenuOption::Mirror) ? 1.0f : -1.0f;
             if (_faceshift.isActive()) {
-                const float EYE_OFFSET_SCALE = 0.005f;
+                const float EYE_OFFSET_SCALE = 0.025f;
                 glm::vec3 position = _faceshift.getHeadTranslation() * EYE_OFFSET_SCALE;
-                _myCamera.setEyeOffsetPosition(glm::vec3(-position.x, position.y, position.z));    
+                _myCamera.setEyeOffsetPosition(glm::vec3(position.x * xSign, position.y, position.z));    
                 updateProjectionMatrix();
                 
             } else if (_webcam.isActive()) {
-                const float EYE_OFFSET_SCALE = 5.0f;
+                const float EYE_OFFSET_SCALE = 0.5f;
-                _myCamera.setEyeOffsetPosition(_webcam.getEstimatedPosition() * EYE_OFFSET_SCALE);
+                glm::vec3 position = _webcam.getEstimatedPosition() * EYE_OFFSET_SCALE;
+                _myCamera.setEyeOffsetPosition(glm::vec3(position.x * xSign, -position.y, position.z));
                 updateProjectionMatrix();
             }
         }
@@ -2135,6 +2137,19 @@ void Application::setupWorldLight(Camera& whichCamera) {
     glMateriali(GL_FRONT, GL_SHININESS, 96);
 }
 
+void Application::computeOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& near,
+    float& far, glm::vec4& nearClipPlane, glm::vec4& farClipPlane) const {
+    
+    _viewFrustum.computeOffAxisFrustum(left, right, bottom, top, near, far, nearClipPlane, farClipPlane);
+    
+    // when mirrored, we must flip left and right
+    if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
+        float tmp = left;
+        left = -right;
+        right = -tmp;
+    }
+}
+
 void Application::displaySide(Camera& whichCamera) {
     // transform by eye offset
 
@@ -2918,6 +2933,30 @@ void Application::renderViewFrustum(ViewFrustum& viewFrustum) {
         // left plane - top edge - viewFrustum.getNear to distant
         glVertex3f(viewFrustum.getNearTopLeft().x, viewFrustum.getNearTopLeft().y, viewFrustum.getNearTopLeft().z);
         glVertex3f(viewFrustum.getFarTopLeft().x, viewFrustum.getFarTopLeft().y, viewFrustum.getFarTopLeft().z);
+    
+        // focal plane - bottom edge
+        glColor3f(1.0f, 0.0f, 1.0f);
+        float focalProportion = (viewFrustum.getFocalLength() - viewFrustum.getNearClip()) /
+            (viewFrustum.getFarClip() - viewFrustum.getNearClip());
+        glm::vec3 focalBottomLeft = glm::mix(viewFrustum.getNearBottomLeft(), viewFrustum.getFarBottomLeft(), focalProportion);
+        glm::vec3 focalBottomRight = glm::mix(viewFrustum.getNearBottomRight(),
+            viewFrustum.getFarBottomRight(), focalProportion);
+        glVertex3f(focalBottomLeft.x, focalBottomLeft.y, focalBottomLeft.z);
+        glVertex3f(focalBottomRight.x, focalBottomRight.y, focalBottomRight.z);
+
+        // focal plane - top edge
+        glm::vec3 focalTopLeft = glm::mix(viewFrustum.getNearTopLeft(), viewFrustum.getFarTopLeft(), focalProportion);
+        glm::vec3 focalTopRight = glm::mix(viewFrustum.getNearTopRight(), viewFrustum.getFarTopRight(), focalProportion);
+        glVertex3f(focalTopLeft.x, focalTopLeft.y, focalTopLeft.z);
+        glVertex3f(focalTopRight.x, focalTopRight.y, focalTopRight.z);
+
+        // focal plane - left edge
+        glVertex3f(focalBottomLeft.x, focalBottomLeft.y, focalBottomLeft.z);
+        glVertex3f(focalTopLeft.x, focalTopLeft.y, focalTopLeft.z);
+
+        // focal plane - right edge
+        glVertex3f(focalBottomRight.x, focalBottomRight.y, focalBottomRight.z);
+        glVertex3f(focalTopRight.x, focalTopRight.y, focalTopRight.z);
     }
     glEnd();
     glEnable(GL_LIGHTING);

interface/src/Application.h

@@ -135,6 +135,10 @@ public:
     
     void setupWorldLight(Camera& whichCamera);
 
+    /// Computes the off-axis frustum parameters for the view frustum, taking mirroring into account.
+    void computeOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& near,
+        float& far, glm::vec4& nearClipPlane, glm::vec4& farClipPlane) const;
+
     virtual void nodeAdded(Node* node);
     virtual void nodeKilled(Node* node);
     virtual void packetSentNotification(ssize_t length);

interface/src/renderer/AmbientOcclusionEffect.cpp

@@ -103,7 +103,7 @@ void AmbientOcclusionEffect::render() {
     
     float left, right, bottom, top, nearVal, farVal;
     glm::vec4 nearClipPlane, farClipPlane;
-    Application::getInstance()->getViewFrustum()->computeOffAxisFrustum(
+    Application::getInstance()->computeOffAxisFrustum(
         left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
     
     _occlusionProgram->bind();

libraries/voxels/src/ViewFrustum.cpp

@@ -32,6 +32,7 @@ ViewFrustum::ViewFrustum() :
     _aspectRatio(1.0),
     _nearClip(0.1),
     _farClip(500.0),
+    _focalLength(0.25f),
     _keyholeRadius(DEFAULT_KEYHOLE_RADIUS),
     _farTopLeft(0,0,0),
     _farTopRight(0,0,0),
@@ -310,15 +311,16 @@ bool testMatches(float lhs, float rhs) {
 
 bool ViewFrustum::matches(const ViewFrustum& compareTo, bool debug) const {
     bool result = 
-           testMatches(compareTo._position,             _position            ) &&
+           testMatches(compareTo._position, _position) &&
-           testMatches(compareTo._direction,            _direction           ) &&
+           testMatches(compareTo._direction, _direction) &&
-           testMatches(compareTo._up,                   _up                  ) &&
+           testMatches(compareTo._up, _up) &&
-           testMatches(compareTo._right,                _right               ) &&
+           testMatches(compareTo._right, _right) &&
-           testMatches(compareTo._fieldOfView,          _fieldOfView         ) &&
+           testMatches(compareTo._fieldOfView, _fieldOfView) &&
-           testMatches(compareTo._aspectRatio,          _aspectRatio         ) &&
+           testMatches(compareTo._aspectRatio, _aspectRatio) &&
-           testMatches(compareTo._nearClip,             _nearClip            ) &&
+           testMatches(compareTo._nearClip, _nearClip) &&
-           testMatches(compareTo._farClip,              _farClip             ) &&
+           testMatches(compareTo._farClip, _farClip) &&
-           testMatches(compareTo._eyeOffsetPosition,    _eyeOffsetPosition   ) &&
+           testMatches(compareTo._focalLength, _focalLength) &&
+           testMatches(compareTo._eyeOffsetPosition, _eyeOffsetPosition) &&
            testMatches(compareTo._eyeOffsetOrientation, _eyeOffsetOrientation);
 
     if (!result && debug) {
@@ -351,6 +353,9 @@ bool ViewFrustum::matches(const ViewFrustum& compareTo, bool debug) const {
         qDebug("%s -- compareTo._farClip=%f _farClip=%f\n", 
             (testMatches(compareTo._farClip, _farClip) ? "MATCHES " : "NO MATCH"),
             compareTo._farClip, _farClip);
+        qDebug("%s -- compareTo._focalLength=%f _focalLength=%f\n", 
+            (testMatches(compareTo._focalLength, _focalLength) ? "MATCHES " : "NO MATCH"),
+            compareTo._focalLength, _focalLength);
         qDebug("%s -- compareTo._eyeOffsetPosition=%f,%f,%f _eyeOffsetPosition=%f,%f,%f\n", 
             (testMatches(compareTo._eyeOffsetPosition, _eyeOffsetPosition) ? "MATCHES " : "NO MATCH"),
             compareTo._eyeOffsetPosition.x, compareTo._eyeOffsetPosition.y, compareTo._eyeOffsetPosition.z,
@@ -401,13 +406,17 @@ void ViewFrustum::computeOffAxisFrustum(float& left, float& right, float& bottom
     nearClipPlane = glm::vec4(-normal.x, -normal.y, -normal.z, glm::dot(normal, corners[0]));
     farClipPlane = glm::vec4(normal.x, normal.y, normal.z, -glm::dot(normal, corners[4]));
     
+    // compute the focal proportion (zero is near clip, one is far clip) 
+    float focalProportion = (_focalLength - _nearClip) / (_farClip - _nearClip);
+    
     // get the extents at Z = -near
     left = FLT_MAX;
     right = -FLT_MAX;
     bottom = FLT_MAX;
     top = -FLT_MAX;
     for (int i = 0; i < 4; i++) {
-        glm::vec4 intersection = corners[i] * (-near / corners[i].z);
+        glm::vec4 corner = glm::mix(corners[i], corners[i + 4], focalProportion);
+        glm::vec4 intersection = corner * (-near / corner.z);
         left = min(left, intersection.x);
         right = max(right, intersection.x);
         bottom = min(bottom, intersection.y);
@@ -426,6 +435,7 @@ void ViewFrustum::printDebugDetails() const {
     qDebug("_keyHoleRadius=%f\n", _keyholeRadius);
     qDebug("_nearClip=%f\n", _nearClip);
     qDebug("_farClip=%f\n", _farClip);
+    qDebug("_focalLength=%f\n", _focalLength);
     qDebug("_eyeOffsetPosition=%f,%f,%f\n",  _eyeOffsetPosition.x, _eyeOffsetPosition.y, _eyeOffsetPosition.z );
     qDebug("_eyeOffsetOrientation=%f,%f,%f,%f\n",  _eyeOffsetOrientation.x, _eyeOffsetOrientation.y, _eyeOffsetOrientation.z,
         _eyeOffsetOrientation.w );

libraries/voxels/src/ViewFrustum.h

@@ -39,6 +39,7 @@ public:
     void setAspectRatio(float a) { _aspectRatio = a; }
     void setNearClip(float n) { _nearClip = n; }
     void setFarClip(float f) { _farClip = f; }
+    void setFocalLength(float length) { _focalLength = length; }
     void setEyeOffsetPosition(const glm::vec3& p) { _eyeOffsetPosition    = p; }
     void setEyeOffsetOrientation(const glm::quat& o) { _eyeOffsetOrientation = o; }
 
@@ -47,6 +48,7 @@ public:
     float getAspectRatio() const { return _aspectRatio; }
     float getNearClip() const { return _nearClip; }
     float getFarClip() const { return _farClip; }
+    float getFocalLength() const { return _focalLength; }
     const glm::vec3& getEyeOffsetPosition() const { return _eyeOffsetPosition; }
     const glm::quat& getEyeOffsetOrientation() const { return _eyeOffsetOrientation; }
 
@@ -111,12 +113,13 @@ private:
     glm::vec3   _right;
     
     // Lens attributes
-    float       _fieldOfView;
+    float _fieldOfView;
-    float       _aspectRatio;
+    float _aspectRatio;
-    float       _nearClip;
+    float _nearClip;
-    float       _farClip;
+    float _farClip;
-    glm::vec3   _eyeOffsetPosition;
+    float _focalLength;
-    glm::quat   _eyeOffsetOrientation;
+    glm::vec3 _eyeOffsetPosition;
+    glm::quat _eyeOffsetOrientation;
     
     // keyhole attributes
     float       _keyholeRadius;