Merge remote-tracking branch 'upstream/master'

interface/src/Application.cpp

@@ -18,6 +18,8 @@
 #include <ifaddrs.h>
 #endif
 
+#include <glm/gtx/quaternion.hpp>
+
 #include <QActionGroup>
 #include <QColorDialog>
 #include <QDesktopWidget>
@@ -355,6 +357,14 @@ void Application::paintGL() {
             whichCamera = _viewFrustumOffsetCamera;
         }        
 
+        // transform by eye offset
+
+        glm::vec3 eyeOffsetPos = whichCamera.getEyeOffsetPosition();
+        glm::quat eyeOffsetOrient = whichCamera.getEyeOffsetOrientation();
+        glm::vec3 eyeOffsetAxis = glm::axis(eyeOffsetOrient);
+        glRotatef(-glm::angle(eyeOffsetOrient), eyeOffsetAxis.x, eyeOffsetAxis.y, eyeOffsetAxis.z);
+        glTranslatef(-eyeOffsetPos.x, -eyeOffsetPos.y, -eyeOffsetPos.z);
+
         // transform view according to whichCamera
         // could be myCamera (if in normal mode)
         // or could be viewFrustumOffsetCamera if in offset mode
@@ -449,7 +459,11 @@ void Application::resizeGL(int width, int height) {
     }
     
     // On window reshape, we need to tell OpenGL about our new setting
-    gluPerspective(fov,aspectRatio,nearClip,farClip);
+    float left, right, bottom, top, nearVal, farVal;
+    glm::vec4 nearClipPlane, farClipPlane;
+    loadViewFrustum(camera, _viewFrustum);
+    _viewFrustum.computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
+    glFrustum(left, right, bottom, top, nearVal, farVal);
     
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();
@@ -593,6 +607,66 @@ void Application::keyPressEvent(QKeyEvent* event) {
             _myAvatar.setDriveKeys(shifted ? RIGHT : ROT_RIGHT, 1);
             break;
         
+        case Qt::Key_I:
+            if (shifted) {
+                _myCamera.setEyeOffsetOrientation(glm::normalize(
+                    glm::quat(glm::vec3(0.002f, 0, 0)) * _myCamera.getEyeOffsetOrientation()));
+            } else {
+                _myCamera.setEyeOffsetPosition(_myCamera.getEyeOffsetPosition() + glm::vec3(0, 0.001, 0));
+            }
+            resizeGL(_glWidget->width(), _glWidget->height());
+            break;
+        
+        case Qt::Key_K:
+            if (shifted) {
+                _myCamera.setEyeOffsetOrientation(glm::normalize(
+                    glm::quat(glm::vec3(-0.002f, 0, 0)) * _myCamera.getEyeOffsetOrientation()));
+            } else {
+                _myCamera.setEyeOffsetPosition(_myCamera.getEyeOffsetPosition() + glm::vec3(0, -0.001, 0));
+            }
+            resizeGL(_glWidget->width(), _glWidget->height());
+            break;
+        
+        case Qt::Key_J:
+            if (shifted) {
+                _myCamera.setEyeOffsetOrientation(glm::normalize(
+                    glm::quat(glm::vec3(0, 0.002f, 0)) * _myCamera.getEyeOffsetOrientation()));
+            } else {
+                _myCamera.setEyeOffsetPosition(_myCamera.getEyeOffsetPosition() + glm::vec3(-0.001, 0, 0));
+            }
+            resizeGL(_glWidget->width(), _glWidget->height());
+            break;
+        
+        case Qt::Key_M:
+            if (shifted) {
+                _myCamera.setEyeOffsetOrientation(glm::normalize(
+                    glm::quat(glm::vec3(0, -0.002f, 0)) * _myCamera.getEyeOffsetOrientation()));
+            } else {
+                _myCamera.setEyeOffsetPosition(_myCamera.getEyeOffsetPosition() + glm::vec3(0.001, 0, 0));
+            }
+            resizeGL(_glWidget->width(), _glWidget->height());
+            break;
+            
+        case Qt::Key_U:
+            if (shifted) {
+                _myCamera.setEyeOffsetOrientation(glm::normalize(
+                    glm::quat(glm::vec3(0, 0, -0.002f)) * _myCamera.getEyeOffsetOrientation()));
+            } else {
+                _myCamera.setEyeOffsetPosition(_myCamera.getEyeOffsetPosition() + glm::vec3(0, 0, -0.001));
+            }
+            resizeGL(_glWidget->width(), _glWidget->height());
+            break;
+            
+        case Qt::Key_Y:
+            if (shifted) {
+                _myCamera.setEyeOffsetOrientation(glm::normalize(
+                    glm::quat(glm::vec3(0, 0, 0.002f)) * _myCamera.getEyeOffsetOrientation()));
+            } else {
+                _myCamera.setEyeOffsetPosition(_myCamera.getEyeOffsetPosition() + glm::vec3(0, 0, 0.001));
+            }
+            resizeGL(_glWidget->width(), _glWidget->height());
+            break;
+            
         default:
             event->ignore();
             break;
@@ -1005,12 +1079,12 @@ void Application::doFalseRandomizeEveryOtherVoxelColors() {
 }
 
 void Application::doFalseColorizeByDistance() {
-    loadViewFrustum(_viewFrustum);
+    loadViewFrustum(_myCamera, _viewFrustum);
     _voxels.falseColorizeDistanceFromView(&_viewFrustum);
 }
 
 void Application::doFalseColorizeInView() {
-    loadViewFrustum(_viewFrustum);
+    loadViewFrustum(_myCamera, _viewFrustum);
     // we probably want to make sure the viewFrustum is initialized first
     _voxels.falseColorizeInView(&_viewFrustum);
 }
@@ -1311,7 +1385,7 @@ void Application::updateAvatar(float deltaTime) {
     // We could optimize this to not actually load the viewFrustum, since we don't
     // actually need to calculate the view frustum planes to send these details 
     // to the server.
-    loadViewFrustum(_viewFrustum);
+    loadViewFrustum(_myCamera, _viewFrustum);
     _myAvatar.setCameraPosition(_viewFrustum.getPosition());
     _myAvatar.setCameraDirection(_viewFrustum.getDirection());
     _myAvatar.setCameraUp(_viewFrustum.getUp());
@@ -1363,7 +1437,7 @@ void Application::updateAvatar(float deltaTime) {
 // Description: this will load the view frustum bounds for EITHER the head
 //                 or the "myCamera". 
 //
-void Application::loadViewFrustum(ViewFrustum& viewFrustum) {
+void Application::loadViewFrustum(Camera& camera, ViewFrustum& viewFrustum) {
     // We will use these below, from either the camera or head vectors calculated above    
     glm::vec3 position;
     glm::vec3 direction;
@@ -1373,16 +1447,16 @@ void Application::loadViewFrustum(ViewFrustum& viewFrustum) {
     
     // Camera or Head?
     if (_cameraFrustum->isChecked()) {
-        position = _myCamera.getPosition();
+        position = camera.getPosition();
     } else {
         position = _myAvatar.getHeadPosition();
     }
     
-    fov         = _myCamera.getFieldOfView();
+    fov         = camera.getFieldOfView();
-    nearClip    = _myCamera.getNearClip();
+    nearClip    = camera.getNearClip();
-    farClip     = _myCamera.getFarClip();
+    farClip     = camera.getFarClip();
 
-    Orientation o = _myCamera.getOrientation();
+    Orientation o = camera.getOrientation();
 
     direction   = o.getFront();
     up          = o.getUp();
@@ -1407,6 +1481,8 @@ void Application::loadViewFrustum(ViewFrustum& viewFrustum) {
     viewFrustum.setFieldOfView(fov);
     viewFrustum.setNearClip(nearClip);
     viewFrustum.setFarClip(farClip);
+    viewFrustum.setEyeOffsetPosition(camera.getEyeOffsetPosition());
+    viewFrustum.setEyeOffsetOrientation(camera.getEyeOffsetOrientation());
 
     // Ask the ViewFrustum class to calculate our corners
     viewFrustum.calculate();
@@ -1818,12 +1894,12 @@ void Application::displayStats() {
 //    * Far Plane - draws only the far plane
 void Application::renderViewFrustum(ViewFrustum& viewFrustum) {
     // Load it with the latest details!
-    loadViewFrustum(viewFrustum);
+    loadViewFrustum(_myCamera, viewFrustum);
     
-    glm::vec3 position  = viewFrustum.getPosition();
+    glm::vec3 position  = viewFrustum.getOffsetPosition();
-    glm::vec3 direction = viewFrustum.getDirection();
+    glm::vec3 direction = viewFrustum.getOffsetDirection();
-    glm::vec3 up        = viewFrustum.getUp();
+    glm::vec3 up        = viewFrustum.getOffsetUp();
-    glm::vec3 right     = viewFrustum.getRight();
+    glm::vec3 right     = viewFrustum.getOffsetRight();
     
     //  Get ready to draw some lines
     glDisable(GL_LIGHTING);

interface/src/Application.h

@@ -105,7 +105,7 @@ private:
     void init();
     
     void updateAvatar(float deltaTime);
-    void loadViewFrustum(ViewFrustum& viewFrustum);
+    void loadViewFrustum(Camera& camera, ViewFrustum& viewFrustum);
     
     void displayOculus(Camera& whichCamera);
     void displaySide(Camera& whichCamera);

interface/src/Camera.cpp

@@ -169,6 +169,16 @@ void Camera::setFarClip    (float f) {
     _frustumNeedsReshape = true; 
 }
 
+void Camera::setEyeOffsetPosition  (const glm::vec3& p) {
+    _eyeOffsetPosition = p;
+    _frustumNeedsReshape = true;
+}
+
+void Camera::setEyeOffsetOrientation  (const glm::quat& o) {
+    _eyeOffsetOrientation = o;
+    _frustumNeedsReshape = true;
+}
+
 void Camera::initialize() {
     _needsToInitialize = true;
     _modeShift = 0.0;

interface/src/Camera.h

@@ -10,6 +10,7 @@
 
 #include "Orientation.h"
 #include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
 
 enum CameraMode
 {
@@ -34,8 +35,8 @@ public:
 
     void initialize(); // instantly put the camera at the ideal position and rotation. 
 
-	void update( float deltaTime );
+    void update( float deltaTime );
-	
+    
     void setYaw           ( float       y ) { _yaw            = y; }
     void setPitch         ( float       p ) { _pitch          = p; }
     void setRoll          ( float       r ) { _roll           = r; }
@@ -53,6 +54,8 @@ public:
     void setAspectRatio   ( float       a );
     void setNearClip      ( float       n );
     void setFarClip       ( float       f );
+    void setEyeOffsetPosition     ( const glm::vec3& p);
+    void setEyeOffsetOrientation  ( const glm::quat& o);
 
     float       getYaw        () { return _yaw;         }
     float       getPitch      () { return _pitch;       }
@@ -64,31 +67,35 @@ public:
     float       getAspectRatio() { return _aspectRatio; }
     float       getNearClip   () { return _nearClip;    }
     float       getFarClip    () { return _farClip;     }
+    glm::vec3   getEyeOffsetPosition  () { return _eyeOffsetPosition;   }
+    glm::quat   getEyeOffsetOrientation () { return _eyeOffsetOrientation; }
     bool        getFrustumNeedsReshape(); // call to find out if the view frustum needs to be reshaped
     void        setFrustumWasReshaped();  // call this after reshaping the view frustum.
 
 private:
 
     bool        _needsToInitialize;
-	CameraMode  _mode;
+    CameraMode  _mode;
     bool        _frustumNeedsReshape;
-	glm::vec3	_position;
+    glm::vec3   _position;
-	glm::vec3	_idealPosition;
+    glm::vec3   _idealPosition;
-	glm::vec3	_targetPosition;
+    glm::vec3   _targetPosition;
-	float		_fieldOfView;
+    float       _fieldOfView;
-    float		_aspectRatio;
+    float       _aspectRatio;
-    float		_nearClip;
+    float       _nearClip;
-    float		_farClip;
+    float       _farClip;
-	float		_yaw;
+    glm::vec3   _eyeOffsetPosition;
-	float		_pitch;
+    glm::quat   _eyeOffsetOrientation;
-	float		_roll;
+    float       _yaw;
-	float		_upShift;
+    float       _pitch;
-	float		_idealYaw;
+    float       _roll;
-	float		_idealPitch;
+    float       _upShift;
-	float		_idealRoll;
+    float       _idealYaw;
-	float		_distance;
+    float       _idealPitch;
-	float		_tightness;
+    float       _idealRoll;
-	Orientation	_orientation;
+    float       _distance;
+    float       _tightness;
+    Orientation _orientation;
     float       _modeShift;
 
     CameraFollowingAttributes _attributes[NUM_CAMERA_MODES];

interface/src/Environment.cpp

@@ -25,18 +25,8 @@ void Environment::renderAtmosphere(Camera& camera) {
     glPushMatrix();
     glTranslatef(getAtmosphereCenter().x, getAtmosphereCenter().y, getAtmosphereCenter().z);
 
-    // use the camera distance to reset the near and far distances to keep the atmosphere in the frustum
-    glMatrixMode(GL_PROJECTION);
-    glPushMatrix();
-    
-    float projection[16];
-    glGetFloatv(GL_PROJECTION_MATRIX, projection);
     glm::vec3 relativeCameraPos = camera.getPosition() - getAtmosphereCenter();
     float height = glm::length(relativeCameraPos);
-    float near = camera.getNearClip(), far = height + getAtmosphereOuterRadius();
-    projection[10] = (far + near) / (near - far);
-    projection[14] = (2.0f * far * near) / (near - far);
-    glLoadMatrixf(projection);
     
     // use the appropriate shader depending on whether we're inside or outside
     ProgramObject* program;

interface/src/VoxelSystem.cpp

@@ -638,11 +638,18 @@ void VoxelSystem::render() {
     _perlinModulateProgram->bind();
     glBindTexture(GL_TEXTURE_2D, _permutationNormalTextureID);
 
+    // for performance, disable blending and enable backface culling
+    glDisable(GL_BLEND);
+    glEnable(GL_CULL_FACE);
+
     // draw the number of voxels we have
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vboIndicesID);
     glScalef(TREE_SCALE, TREE_SCALE, TREE_SCALE);
     glDrawElements(GL_TRIANGLES, 36 * _voxelsInReadArrays, GL_UNSIGNED_INT, 0);
 
+    glEnable(GL_BLEND);
+    glDisable(GL_CULL_FACE);
+
     _perlinModulateProgram->release();
     glBindTexture(GL_TEXTURE_2D, 0);
 

interface/src/ui/TextRenderer.cpp

@@ -139,7 +139,7 @@ const Glyph& TextRenderer::getGlyph(char c) {
         painter.setFont(_font);
         if (_effectType == SHADOW_EFFECT) {
             for (int i = 0; i < _effectThickness; i++) {
-                painter.drawText(-bounds.x() - i, -bounds.y() + i, ch);
+                painter.drawText(-bounds.x() - 1 - i, -bounds.y() + 1 + i, ch);
             }
         } else if (_effectType == OUTLINE_EFFECT) {
             QPainterPath path;

interface/src/ui/TextRenderer.h

@@ -26,7 +26,7 @@ public:
     enum EffectType { NO_EFFECT, SHADOW_EFFECT, OUTLINE_EFFECT };
 
     TextRenderer(const char* family, int pointSize = -1, int weight = -1, bool italic = false,
-                 EffectType effect = NO_EFFECT, int effectThickness = 2);
+                 EffectType effect = NO_EFFECT, int effectThickness = 1);
     ~TextRenderer();
 
     const QFontMetrics& metrics() const { return _metrics; }

libraries/voxels/src/Plane.cpp

@@ -28,7 +28,7 @@ void Plane::set3Points(const glm::vec3 &v1, const glm::vec3 &v2, const glm::vec3
 
     // this will be perpendicular to both lines
     _normal = glm::cross(linev1v2,linev1v3);
-    glm::normalize(_normal);
+    _normal = glm::normalize(_normal);
 
     // this is a point on the plane
     _point = v2;

libraries/voxels/src/ViewFrustum.cpp

@@ -8,10 +8,16 @@
 //
 //
 
+#include <algorithm>
+
+#include <glm/gtx/transform.hpp>
+
 #include "ViewFrustum.h"
+#include "SharedUtil.h"
 #include "voxels_Log.h"
 
 using voxels_lib::printLog;
+using namespace std;
 
 ViewFrustum::ViewFrustum() :
     _position(glm::vec3(0,0,0)),
@@ -22,10 +28,6 @@ ViewFrustum::ViewFrustum() :
     _aspectRatio(1.0),
     _nearClip(0.1),
     _farClip(500.0),
-    _nearHeight(0.0),
-    _nearWidth(0.0),
-    _farHeight(0.0),
-    _farWidth(0.0),
     _farCenter(glm::vec3(0,0,0)),
     _farTopLeft(glm::vec3(0,0,0)),
     _farTopRight(glm::vec3(0,0,0)),
@@ -41,67 +43,68 @@ ViewFrustum::ViewFrustum() :
 // ViewFrustum::calculateViewFrustum()
 //
 // Description: this will calculate the view frustum bounds for a given position
-// 				and direction
+//                 and direction
 //
 // Notes on how/why this works: 
 //     http://www.lighthouse3d.com/tutorials/view-frustum-culling/view-frustums-shape/
 //
 void ViewFrustum::calculate() {
+    // compute the off-axis frustum parameters as we would for glFrustum
+    float left, right, bottom, top, nearVal, farVal;
+    glm::vec4 nearClipPlane, farClipPlane;
+    computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
+    
+    // start with the corners of the near frustum window
+    glm::vec3 topLeft(left, top, -nearVal);
+    glm::vec3 topRight(right, top, -nearVal);
+    glm::vec3 bottomLeft(left, bottom, -nearVal);
+    glm::vec3 bottomRight(right, bottom, -nearVal);
+    
+    // find the intersections of the rays through the corners with the clip planes in view space,
+    // then transform them to world space
+    glm::mat4 worldMatrix = glm::translate(_position) * glm::mat4(glm::mat3(_right, _up, -_direction)) *
+        glm::translate(_eyeOffsetPosition) * glm::mat4_cast(_eyeOffsetOrientation);
+    _farTopLeft = glm::vec3(worldMatrix * glm::vec4(topLeft *
+        (-farClipPlane.w / glm::dot(topLeft, glm::vec3(farClipPlane))), 1.0f));
+    _farTopRight = glm::vec3(worldMatrix * glm::vec4(topRight *
+        (-farClipPlane.w / glm::dot(topRight, glm::vec3(farClipPlane))), 1.0f));
+    _farBottomLeft = glm::vec3(worldMatrix * glm::vec4(bottomLeft *
+        (-farClipPlane.w / glm::dot(bottomLeft, glm::vec3(farClipPlane))), 1.0f));
+    _farBottomRight = glm::vec3(worldMatrix * glm::vec4(bottomRight *
+        (-farClipPlane.w / glm::dot(bottomRight, glm::vec3(farClipPlane))), 1.0f));
+    _nearTopLeft = glm::vec3(worldMatrix * glm::vec4(topLeft *
+        (-nearClipPlane.w / glm::dot(topLeft, glm::vec3(nearClipPlane))), 1.0f));
+    _nearTopRight = glm::vec3(worldMatrix * glm::vec4(topRight *
+        (-nearClipPlane.w / glm::dot(topRight, glm::vec3(nearClipPlane))), 1.0f));
+    _nearBottomLeft = glm::vec3(worldMatrix * glm::vec4(bottomLeft *
+        (-nearClipPlane.w / glm::dot(bottomLeft, glm::vec3(nearClipPlane))), 1.0f));
+    _nearBottomRight = glm::vec3(worldMatrix * glm::vec4(bottomRight *
+        (-nearClipPlane.w / glm::dot(bottomRight, glm::vec3(nearClipPlane))), 1.0f));
+    
+    // compute the offset position and axes in world space
+    _offsetPosition = glm::vec3(worldMatrix * glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
+    _offsetDirection = glm::vec3(worldMatrix * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f));
+    _offsetUp = glm::vec3(worldMatrix * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
+    _offsetRight = glm::vec3(worldMatrix * glm::vec4(1.0f, 0.0f, 0.0f, 0.0f));
+    
+    // compute the six planes
+    // The planes are defined such that the normal points towards the inside of the view frustum. 
+    // Testing if an object is inside the view frustum is performed by computing on which side of 
+    // the plane the object resides. This can be done computing the signed distance from the point
+    // to the plane. If it is on the side that the normal is pointing, i.e. the signed distance 
+    // is positive, then it is on the right side of the respective plane. If an object is on the 
+    // right side of all six planes then the object is inside the frustum.
 
-    static const double PI_OVER_180			= 3.14159265359 / 180.0; // would be better if this was in a shared location
+    // the function set3Points assumes that the points are given in counter clockwise order, assume you
-	
+    // are inside the frustum, facing the plane. Start with any point, and go counter clockwise for
-	glm::vec3 front    = _direction;
+    // three consecutive points
-	
+    
-	// Calculating field of view.
+    _planes[TOP_PLANE   ].set3Points(_nearTopRight,_nearTopLeft,_farTopLeft);
-	float fovInRadians = _fieldOfView * PI_OVER_180;
+    _planes[BOTTOM_PLANE].set3Points(_nearBottomLeft,_nearBottomRight,_farBottomRight);
-	
+    _planes[LEFT_PLANE  ].set3Points(_nearBottomLeft,_farBottomLeft,_farTopLeft);
-	float twoTimesTanHalfFOV = 2.0f * tan(fovInRadians/2.0f);
+    _planes[RIGHT_PLANE ].set3Points(_farBottomRight,_nearBottomRight,_nearTopRight);
-
+    _planes[NEAR_PLANE  ].set3Points(_nearBottomRight,_nearBottomLeft,_nearTopLeft);
-    // Do we need this?
+    _planes[FAR_PLANE   ].set3Points(_farBottomLeft,_farBottomRight,_farTopRight);
-	//tang = (float)tan(ANG2RAD * angle * 0.5) ;
-
-    float nearClip = _nearClip;
-    float farClip  = _farClip;
-	
-	_nearHeight = (twoTimesTanHalfFOV * nearClip);
-	_nearWidth  = _nearHeight * _aspectRatio;
-	_farHeight  = (twoTimesTanHalfFOV * farClip);
-	_farWidth   = _farHeight * _aspectRatio;
-
-	float farHalfHeight    = (_farHeight * 0.5f);
-	float farHalfWidth     = (_farWidth  * 0.5f);
-	_farCenter       = _position+front * farClip;
-	_farTopLeft      = _farCenter  + (_up * farHalfHeight)  - (_right * farHalfWidth); 
-	_farTopRight     = _farCenter  + (_up * farHalfHeight)  + (_right * farHalfWidth); 
-	_farBottomLeft   = _farCenter  - (_up * farHalfHeight)  - (_right * farHalfWidth); 
-	_farBottomRight  = _farCenter  - (_up * farHalfHeight)  + (_right * farHalfWidth); 
-
-	float nearHalfHeight   = (_nearHeight * 0.5f);
-	float nearHalfWidth    = (_nearWidth  * 0.5f);
-	_nearCenter      = _position+front * nearClip;
-	_nearTopLeft     = _nearCenter + (_up * nearHalfHeight) - (_right * nearHalfWidth); 
-	_nearTopRight    = _nearCenter + (_up * nearHalfHeight) + (_right * nearHalfWidth); 
-	_nearBottomLeft  = _nearCenter - (_up * nearHalfHeight) - (_right * nearHalfWidth); 
-	_nearBottomRight = _nearCenter - (_up * nearHalfHeight) + (_right * nearHalfWidth); 
-
-	// compute the six planes
-	// The planes are defined such that the normal points towards the inside of the view frustum. 
-	// Testing if an object is inside the view frustum is performed by computing on which side of 
-	// the plane the object resides. This can be done computing the signed distance from the point
-	// to the plane. If it is on the side that the normal is pointing, i.e. the signed distance 
-	// is positive, then it is on the right side of the respective plane. If an object is on the 
-	// right side of all six planes then the object is inside the frustum.
-
-	// the function set3Points assumes that the points are given in counter clockwise order, assume you
-	// are inside the frustum, facing the plane. Start with any point, and go counter clockwise for
-	// three consecutive points
-	
-	_planes[TOP_PLANE   ].set3Points(_nearTopRight,_nearTopLeft,_farTopLeft);
-	_planes[BOTTOM_PLANE].set3Points(_nearBottomLeft,_nearBottomRight,_farBottomRight);
-	_planes[LEFT_PLANE  ].set3Points(_nearBottomLeft,_farBottomLeft,_farTopLeft);
-	_planes[RIGHT_PLANE ].set3Points(_farBottomRight,_nearBottomRight,_nearTopRight);
-	_planes[NEAR_PLANE  ].set3Points(_nearBottomRight,_nearBottomLeft,_nearTopLeft);
-	_planes[FAR_PLANE   ].set3Points(_farBottomLeft,_farBottomRight,_farTopRight);
 
 }
 
@@ -113,34 +116,35 @@ void ViewFrustum::dump() const {
     printLog("right.x=%f, right.y=%f, right.z=%f\n", _right.x, _right.y, _right.z);
 
     printLog("farDist=%f\n", _farClip);
-    printLog("farHeight=%f\n", _farHeight);
-    printLog("farWidth=%f\n", _farWidth);
 
     printLog("nearDist=%f\n", _nearClip);
-    printLog("nearHeight=%f\n", _nearHeight);
+
-    printLog("nearWidth=%f\n", _nearWidth);
+    printLog("eyeOffsetPosition=%f,%f,%f\n", _eyeOffsetPosition.x, _eyeOffsetPosition.y, _eyeOffsetPosition.z);
+    
+    printLog("eyeOffsetOrientation=%f,%f,%f,%f\n", _eyeOffsetOrientation.x, _eyeOffsetOrientation.y,
+        _eyeOffsetOrientation.z, _eyeOffsetOrientation.w);
 
     printLog("farCenter.x=%f,      farCenter.y=%f,      farCenter.z=%f\n",
-    	_farCenter.x, _farCenter.y, _farCenter.z);
+        _farCenter.x, _farCenter.y, _farCenter.z);
     printLog("farTopLeft.x=%f,     farTopLeft.y=%f,     farTopLeft.z=%f\n",
-    	_farTopLeft.x, _farTopLeft.y, _farTopLeft.z);
+        _farTopLeft.x, _farTopLeft.y, _farTopLeft.z);
     printLog("farTopRight.x=%f,    farTopRight.y=%f,    farTopRight.z=%f\n",
-    	_farTopRight.x, _farTopRight.y, _farTopRight.z);
+        _farTopRight.x, _farTopRight.y, _farTopRight.z);
     printLog("farBottomLeft.x=%f,  farBottomLeft.y=%f,  farBottomLeft.z=%f\n",
-    	_farBottomLeft.x, _farBottomLeft.y, _farBottomLeft.z);
+        _farBottomLeft.x, _farBottomLeft.y, _farBottomLeft.z);
     printLog("farBottomRight.x=%f, farBottomRight.y=%f, farBottomRight.z=%f\n",
-    	_farBottomRight.x, _farBottomRight.y, _farBottomRight.z);
+        _farBottomRight.x, _farBottomRight.y, _farBottomRight.z);
 
     printLog("nearCenter.x=%f,      nearCenter.y=%f,      nearCenter.z=%f\n",
-    	_nearCenter.x, _nearCenter.y, _nearCenter.z);
+        _nearCenter.x, _nearCenter.y, _nearCenter.z);
     printLog("nearTopLeft.x=%f,     nearTopLeft.y=%f,     nearTopLeft.z=%f\n",
-    	_nearTopLeft.x, _nearTopLeft.y, _nearTopLeft.z);
+        _nearTopLeft.x, _nearTopLeft.y, _nearTopLeft.z);
     printLog("nearTopRight.x=%f,    nearTopRight.y=%f,    nearTopRight.z=%f\n",
-    	_nearTopRight.x, _nearTopRight.y, _nearTopRight.z);
+        _nearTopRight.x, _nearTopRight.y, _nearTopRight.z);
     printLog("nearBottomLeft.x=%f,  nearBottomLeft.y=%f,  nearBottomLeft.z=%f\n",
-    	_nearBottomLeft.x, _nearBottomLeft.y, _nearBottomLeft.z);
+        _nearBottomLeft.x, _nearBottomLeft.y, _nearBottomLeft.z);
     printLog("nearBottomRight.x=%f, nearBottomRight.y=%f, nearBottomRight.z=%f\n",
-    	_nearBottomRight.x, _nearBottomRight.y, _nearBottomRight.z);
+        _nearBottomRight.x, _nearBottomRight.y, _nearBottomRight.z);
 }
 
 
@@ -163,30 +167,30 @@ ViewFrustum::location ViewFrustum::pointInFrustum(const glm::vec3& point) const
     //printf("ViewFrustum::pointInFrustum() point=%f,%f,%f\n",point.x,point.y,point.z);
     //dump();
 
-	ViewFrustum::location result = INSIDE;
+    ViewFrustum::location result = INSIDE;
-	for(int i=0; i < 6; i++) {
+    for(int i=0; i < 6; i++) {
-	    float distance = _planes[i].distance(point);
+        float distance = _planes[i].distance(point);
 
         //printf("plane[%d] %s -- distance=%f \n",i,debugPlaneName(i),distance);
-	
+    
-		if (distance < 0) {
+        if (distance < 0) {
-			return OUTSIDE;
+            return OUTSIDE;
-		}
+        }
-	}
+    }
-	return(result);
+    return(result);
 }
 
 ViewFrustum::location ViewFrustum::sphereInFrustum(const glm::vec3& center, float radius) const {
-	ViewFrustum::location result = INSIDE;
+    ViewFrustum::location result = INSIDE;
-	float distance;
+    float distance;
-	for(int i=0; i < 6; i++) {
+    for(int i=0; i < 6; i++) {
-		distance = _planes[i].distance(center);
+        distance = _planes[i].distance(center);
-		if (distance < -radius)
+        if (distance < -radius)
-			return OUTSIDE;
+            return OUTSIDE;
-		else if (distance < radius)
+        else if (distance < radius)
-			result =  INTERSECT;
+            result =  INTERSECT;
-	}
+    }
-	return(result);
+    return(result);
 }
 
 
@@ -194,8 +198,8 @@ ViewFrustum::location ViewFrustum::boxInFrustum(const AABox& box) const {
 
     //printf("ViewFrustum::boxInFrustum() box.corner=%f,%f,%f x=%f\n",
     //    box.getCorner().x,box.getCorner().y,box.getCorner().z,box.getSize().x);
-	ViewFrustum::location result = INSIDE;
+    ViewFrustum::location result = INSIDE;
-	for(int i=0; i < 6; i++) {
+    for(int i=0; i < 6; i++) {
 
         //printf("plane[%d] -- point(%f,%f,%f) normal(%f,%f,%f) d=%f \n",i,
         //    _planes[i].getPoint().x, _planes[i].getPoint().y, _planes[i].getPoint().z,
@@ -203,26 +207,26 @@ ViewFrustum::location ViewFrustum::boxInFrustum(const AABox& box) const {
         //    _planes[i].getDCoefficient()
         //);
 
-	    glm::vec3 normal = _planes[i].getNormal();
+        glm::vec3 normal = _planes[i].getNormal();
-	    glm::vec3 boxVertexP = box.getVertexP(normal);
+        glm::vec3 boxVertexP = box.getVertexP(normal);
-	    float planeToBoxVertexPDistance = _planes[i].distance(boxVertexP);
+        float planeToBoxVertexPDistance = _planes[i].distance(boxVertexP);
 
-	    glm::vec3 boxVertexN = box.getVertexN(normal);
+        glm::vec3 boxVertexN = box.getVertexN(normal);
-	    float planeToBoxVertexNDistance = _planes[i].distance(boxVertexN);
+        float planeToBoxVertexNDistance = _planes[i].distance(boxVertexN);
-	    
+        
         //printf("plane[%d] normal=(%f,%f,%f) bVertexP=(%f,%f,%f) planeToBoxVertexPDistance=%f  boxVertexN=(%f,%f,%f) planeToBoxVertexNDistance=%f\n",i, 
         //    normal.x,normal.y,normal.z,
         //    boxVertexP.x,boxVertexP.y,boxVertexP.z,planeToBoxVertexPDistance,
         //    boxVertexN.x,boxVertexN.y,boxVertexN.z,planeToBoxVertexNDistance
         //    );
 
-		if (planeToBoxVertexPDistance < 0) {
+        if (planeToBoxVertexPDistance < 0) {
-			return OUTSIDE;
+            return OUTSIDE;
-		} else if (planeToBoxVertexNDistance < 0) {
+        } else if (planeToBoxVertexNDistance < 0) {
-			result =  INTERSECT;
+            result =  INTERSECT;
-		}
+        }
-	}
+    }
-	return(result);
+    return(result);
  }
  
 bool ViewFrustum::matches(const ViewFrustum& compareTo) const {
@@ -234,7 +238,9 @@ bool ViewFrustum::matches(const ViewFrustum& compareTo) const {
            compareTo._fieldOfView == _fieldOfView &&
            compareTo._aspectRatio == _aspectRatio &&
            compareTo._nearClip    == _nearClip &&
-           compareTo._farClip     == _farClip;
+           compareTo._farClip     == _farClip &&
+           compareTo._eyeOffsetPosition == _eyeOffsetPosition &&
+           compareTo._eyeOffsetOrientation == _eyeOffsetOrientation;
 
     if (!result && debug) {
         printLog("ViewFrustum::matches()... result=%s\n", (result ? "yes" : "no"));
@@ -266,6 +272,15 @@ bool ViewFrustum::matches(const ViewFrustum& compareTo) const {
         printLog("%s -- compareTo._farClip=%f _farClip=%f\n", 
             (compareTo._farClip == _farClip ? "MATCHES " : "NO MATCH"),
             compareTo._farClip, _farClip);
+        printLog("%s -- compareTo._eyeOffsetPosition=%f,%f,%f _eyeOffsetPosition=%f,%f,%f\n", 
+            (compareTo._eyeOffsetPosition == _eyeOffsetPosition ? "MATCHES " : "NO MATCH"),
+            compareTo._eyeOffsetPosition.x, compareTo._eyeOffsetPosition.y, compareTo._eyeOffsetPosition.z,
+            _eyeOffsetPosition.x, _eyeOffsetPosition.y, _eyeOffsetPosition.z);
+        printLog("%s -- compareTo._eyeOffsetOrientation=%f,%f,%f,%f _eyeOffsetOrientation=%f,%f,%f,%f\n", 
+            (compareTo._eyeOffsetOrientation == _eyeOffsetOrientation ? "MATCHES " : "NO MATCH"),
+            compareTo._eyeOffsetOrientation.x, compareTo._eyeOffsetOrientation.y,
+                compareTo._eyeOffsetOrientation.z, compareTo._eyeOffsetOrientation.w,
+            _eyeOffsetOrientation.x, _eyeOffsetOrientation.y, _eyeOffsetOrientation.z, _eyeOffsetOrientation.w);
     }
     return result;
 }
@@ -277,6 +292,51 @@ void ViewFrustum::computePickRay(float x, float y, glm::vec3& origin, glm::vec3&
     direction = glm::normalize(origin - _position);
 }
 
+void ViewFrustum::computeOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& near, float& far,
+                                        glm::vec4& nearClipPlane, glm::vec4& farClipPlane) const {
+    // compute our dimensions the usual way
+    float hheight = _nearClip * tanf(_fieldOfView * 0.5f * PI_OVER_180);
+    float hwidth = _aspectRatio * hheight;
+    
+    // get our frustum corners in view space
+    glm::mat4 eyeMatrix = glm::mat4_cast(glm::inverse(_eyeOffsetOrientation)) * glm::translate(-_eyeOffsetPosition);
+    glm::vec4 corners[8];
+    float farScale = _farClip / _nearClip;
+    corners[0] = eyeMatrix * glm::vec4(-hwidth, -hheight, -_nearClip, 1.0f);
+    corners[1] = eyeMatrix * glm::vec4(hwidth, -hheight, -_nearClip, 1.0f);
+    corners[2] = eyeMatrix * glm::vec4(hwidth, hheight, -_nearClip, 1.0f);
+    corners[3] = eyeMatrix * glm::vec4(-hwidth, hheight, -_nearClip, 1.0f);
+    corners[4] = eyeMatrix * glm::vec4(-hwidth * farScale, -hheight * farScale, -_farClip, 1.0f);
+    corners[5] = eyeMatrix * glm::vec4(hwidth * farScale, -hheight * farScale, -_farClip, 1.0f);
+    corners[6] = eyeMatrix * glm::vec4(hwidth * farScale, hheight * farScale, -_farClip, 1.0f);
+    corners[7] = eyeMatrix * glm::vec4(-hwidth * farScale, hheight * farScale, -_farClip, 1.0f);
+    
+    // find the minimum and maximum z values, which will be our near and far clip distances
+    near = FLT_MAX;
+    far = -FLT_MAX;
+    for (int i = 0; i < 8; i++) {
+        near = min(near, -corners[i].z);
+        far = max(far, -corners[i].z);
+    }
+    
+    // get the near/far normal and use it to find the clip planes
+    glm::vec4 normal = eyeMatrix * glm::vec4(0.0f, 0.0f, 1.0f, 0.0f);
+    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]));
+    
+    // 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);
+        left = min(left, intersection.x);
+        right = max(right, intersection.x);
+        bottom = min(bottom, intersection.y);
+        top = max(top, intersection.y);
+    }
+}
 
 void ViewFrustum::printDebugDetails() const {
     printLog("ViewFrustum::printDebugDetails()... \n");
@@ -288,5 +348,8 @@ void ViewFrustum::printDebugDetails() const {
     printLog("_aspectRatio=%f\n", _aspectRatio);
     printLog("_nearClip=%f\n", _nearClip);
     printLog("_farClip=%f\n", _farClip);
+    printLog("_eyeOffsetPosition=%f,%f,%f\n",  _eyeOffsetPosition.x, _eyeOffsetPosition.y, _eyeOffsetPosition.z );
+    printLog("_eyeOffsetOrientation=%f,%f,%f,%f\n",  _eyeOffsetOrientation.x, _eyeOffsetOrientation.y, _eyeOffsetOrientation.z,
+        _eyeOffsetOrientation.w );
 }
 

libraries/voxels/src/ViewFrustum.h

@@ -12,6 +12,7 @@
 #define __hifi__ViewFrustum__
 
 #include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
 #include "Plane.h"
 #include "AABox.h"
 
@@ -29,12 +30,14 @@ private:
     float       _aspectRatio;
     float       _nearClip; 
     float       _farClip;
+    glm::vec3   _eyeOffsetPosition;
+    glm::quat   _eyeOffsetOrientation;
 
     // Calculated values
-    float       _nearHeight;
+    glm::vec3   _offsetPosition;
-    float       _nearWidth;
+    glm::vec3   _offsetDirection;
-    float       _farHeight;
+    glm::vec3   _offsetUp;
-    float       _farWidth;
+    glm::vec3   _offsetRight;
     glm::vec3   _farCenter;
     glm::vec3   _farTopLeft;      
     glm::vec3   _farTopRight;     
@@ -63,16 +66,26 @@ public:
     const glm::vec3& getRight()     const { return _right;     };
 
     // setters for lens attributes
-    void setFieldOfView     ( float f ) { _fieldOfView      = f; }
+    void setFieldOfView          ( float f )          { _fieldOfView          = f; }
-    void setAspectRatio     ( float a ) { _aspectRatio      = a; }
+    void setAspectRatio          ( float a )          { _aspectRatio          = a; }
-    void setNearClip        ( float n ) { _nearClip         = n; }
+    void setNearClip             ( float n )          { _nearClip             = n; }
-    void setFarClip         ( float f ) { _farClip          = f; }
+    void setFarClip              ( float f )          { _farClip              = f; }
+    void setEyeOffsetPosition    (const glm::vec3& p) { _eyeOffsetPosition    = p; }
+    void setEyeOffsetOrientation (const glm::quat& o) { _eyeOffsetOrientation = o; }
+
 
     // getters for lens attributes
-    float getFieldOfView()                  const { return _fieldOfView;    };
+    float getFieldOfView()                     const { return _fieldOfView;         };
-    float getAspectRatio()                  const { return _aspectRatio;    };
+    float getAspectRatio()                     const { return _aspectRatio;         };
-    float getNearClip()                     const { return _nearClip;       };
+    float getNearClip()                        const { return _nearClip;            };
-    float getFarClip()                      const { return _farClip;        };
+    float getFarClip()                         const { return _farClip;             };
+    const glm::vec3& getEyeOffsetPosition()    const { return _eyeOffsetPosition;   };
+    const glm::quat& getEyeOffsetOrientation() const { return _eyeOffsetOrientation;};
+
+    const glm::vec3& getOffsetPosition()    const { return _offsetPosition; };
+    const glm::vec3& getOffsetDirection()   const { return _offsetDirection;};
+    const glm::vec3& getOffsetUp()          const { return _offsetUp;       };
+    const glm::vec3& getOffsetRight()       const { return _offsetRight;    };
 
     const glm::vec3& getFarCenter()         const { return _farCenter;      };
     const glm::vec3& getFarTopLeft()        const { return _farTopLeft;     };  
@@ -101,8 +114,12 @@ public:
     // some frustum comparisons
     bool matches(const ViewFrustum& compareTo) const;
     bool matches(const ViewFrustum* compareTo) const { return matches(*compareTo); };
+
     void computePickRay(float x, float y, glm::vec3& origin, glm::vec3& direction) const;
 
+    void computeOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& near, float& far,
+                               glm::vec4& nearClipPlane, glm::vec4& farClipPlane) const;
+
     void printDebugDetails() const;
 };