Merge branch 'master' of https://github.com/worklist/hifi

interface/src/Application.cpp

@@ -162,8 +162,7 @@ Application::Application(int& argc, char** argv, timeval &startup_time) :
         _packetCount(0),
         _packetsPerSecond(0),
         _bytesPerSecond(0),
-        _bytesCount(0),
+        _bytesCount(0)
-        _settings("HighFidelity", "Interface")
 {
     _applicationStartupTime = startup_time;
     _window->setWindowTitle("Interface");
@@ -975,7 +974,7 @@ void Application::terminate() {
     
     if (_autosave) {
         saveSettings();
-        _settings.sync();
+        _settings->sync();
     }
 
     if (_enableNetworkThread) {
@@ -1121,7 +1120,7 @@ static void sendVoxelEditMessage(PACKET_HEADER header, VoxelDetail& detail) {
 void Application::addVoxelInFrontOfAvatar() {
     VoxelDetail detail;
     
-    glm::vec3 position = (_myAvatar.getPosition() + _myAvatar.getCameraDirection()) * (1.0f / TREE_SCALE);
+    glm::vec3 position = (_myAvatar.getPosition() + _myAvatar.calculateCameraDirection()) * (1.0f / TREE_SCALE);
     detail.s = _mouseVoxelScale;
     
     detail.x = detail.s * floor(position.x / detail.s);
@@ -1166,8 +1165,6 @@ void Application::chooseVoxelPaintColor() {
     _window->activateWindow();
 }
 
-<<<<<<< HEAD
-=======
 const int MAXIMUM_EDIT_VOXEL_MESSAGE_SIZE = 1500;
 struct SendVoxelsOperationArgs {
     unsigned char* newBaseOctCode;
@@ -1331,7 +1328,6 @@ void Application::pasteVoxels() {
     }
 }
 
->>>>>>> 82c1ee2062577f614cfde096f08adfc9e83e4f0f
 void Application::initMenu() {
     QMenuBar* menuBar = new QMenuBar();
     _window->setMenuBar(menuBar);
@@ -1450,7 +1446,6 @@ void Application::initMenu() {
     debugMenu->addAction("Wants Res-In", this, SLOT(setWantsResIn(bool)))->setCheckable(true);
     debugMenu->addAction("Wants Monochrome", this, SLOT(setWantsMonochrome(bool)))->setCheckable(true);
     debugMenu->addAction("Wants View Delta Sending", this, SLOT(setWantsDelta(bool)))->setCheckable(true);
-<<<<<<< HEAD
 
     QMenu* settingsMenu = menuBar->addMenu("Settings");
     (_settingsAutosave = settingsMenu->addAction("Autosave", this, SLOT(setAutosave(bool))))->setCheckable(true);
@@ -1459,11 +1454,9 @@ void Application::initMenu() {
     settingsMenu->addAction("Save settings", this, SLOT(saveSettings()));
     settingsMenu->addAction("Import settings", this, SLOT(importSettings()));
     settingsMenu->addAction("Export settings", this, SLOT(exportSettings()));
-=======
     
     _networkAccessManager = new QNetworkAccessManager(this);
     _settings = new QSettings("High Fidelity", "Interface", this);
->>>>>>> 82c1ee2062577f614cfde096f08adfc9e83e4f0f
 }
 
 void Application::updateFrustumRenderModeAction() {
@@ -1573,9 +1566,7 @@ void Application::updateAvatar(float deltaTime) {
     // to the server.
     loadViewFrustum(_myCamera, _viewFrustum);
     _myAvatar.setCameraPosition(_viewFrustum.getPosition());
-    _myAvatar.setCameraDirection(_viewFrustum.getDirection());
+    _myAvatar.setCameraOrientation(_viewFrustum.getOrientation());
-    _myAvatar.setCameraUp(_viewFrustum.getUp());
-    _myAvatar.setCameraRight(_viewFrustum.getRight());
     _myAvatar.setCameraFov(_viewFrustum.getFieldOfView());
     _myAvatar.setCameraAspectRatio(_viewFrustum.getAspectRatio());
     _myAvatar.setCameraNearClip(_viewFrustum.getNearClip());
@@ -1639,13 +1630,10 @@ void Application::loadViewFrustum(Camera& camera, ViewFrustum& viewFrustum) {
     float farClip     = camera.getFarClip();
 
     glm::quat rotation = camera.getRotation();
-    glm::vec3 direction = rotation * AVATAR_FRONT;
-    glm::vec3 up = rotation * AVATAR_UP;
-    glm::vec3 right = rotation * AVATAR_RIGHT;
 
     // Set the viewFrustum up with the correct position and orientation of the camera    
     viewFrustum.setPosition(position);
-    viewFrustum.setOrientation(direction,up,right);
+    viewFrustum.setOrientation(rotation);
     
     // Also make sure it's got the correct lens details from the camera
     viewFrustum.setFieldOfView(fov);

interface/src/Application.h

@@ -71,66 +71,12 @@ public:
     Camera* getCamera() { return &_myCamera; }
     ViewFrustum* getViewFrustum() { return &_viewFrustum; }
     VoxelSystem* getVoxels() { return &_voxels; }
-    QSettings* getSettings() { return &_settings; }
+    QSettings* getSettings() { return _settings; }
     Environment* getEnvironment() { return &_environment; }
     bool shouldEchoAudio() { return _echoAudioMode->isChecked(); }
-<<<<<<< HEAD
-=======
     
     QNetworkAccessManager* getNetworkAccessManager() { return _networkAccessManager; }
     
-    /*!
-     @fn getSettingBool
-     @brief A function for getting boolean settings from the settings file.
-     @param settingName The desired setting to get the value for.
-     @param boolSetting The referenced variable where the setting will be stored.
-     @param defaultSetting The default setting to assign to boolSetting if this function fails to find the appropriate setting.  Defaults to false.
-    */
-    bool getSetting(const char* setting, bool &value, const bool defaultSetting = false) const;
-    
-    /*!
-     @fn getSettingFloat
-     @brief A function for getting float settings from the settings file.
-     @param settingName The desired setting to get the value for.
-     @param floatSetting The referenced variable where the setting will be stored.
-     @param defaultSetting The default setting to assign to boolSetting if this function fails to find the appropriate setting.  Defaults to 0.0f.
-     */
-    bool getSetting(const char* setting, float &value, const float defaultSetting = 0.0f) const;
-    
-    /*!
-     @fn getSettingVec3
-     @brief A function for getting boolean settings from the settings file.
-     @param settingName The desired setting to get the value for.
-     @param vecSetting The referenced variable where the setting will be stored.
-     @param defaultSetting The default setting to assign to boolSetting if this function fails to find the appropriate setting.  Defaults to <0.0f, 0.0f, 0.0f>
-     */
-    bool getSetting(const char* setting, glm::vec3 &value, const glm::vec3& defaultSetting = glm::vec3(0.0f, 0.0f, 0.0f)) const;
-    
-    /*!
-     @fn setSettingBool
-     @brief A function for setting boolean setting values when saving the settings file.
-     @param settingName The desired setting to populate a value for.
-     @param boolSetting The value to set.
-     */
-    void setSetting(const char* setting, const bool value);
-    
-    /*!
-     @fn setSettingFloat
-     @brief A function for setting boolean setting values when saving the settings file.
-     @param settingName The desired setting to populate a value for.
-     @param floatSetting The value to set.
-     */
-    void setSetting(const char* setting, const float value);
-    
-    /*!
-     @fn setSettingVec3
-     @brief A function for setting boolean setting values when saving the settings file.
-     @param settingName The desired setting to populate a value for.
-     @param vecSetting The value to set.
-     */
-    void setSetting(const char* setting, const glm::vec3& value);
->>>>>>> 82c1ee2062577f614cfde096f08adfc9e83e4f0f
-
 private slots:
     
     void timer();
@@ -167,22 +113,16 @@ private slots:
     void decreaseVoxelSize();
     void increaseVoxelSize();
     void chooseVoxelPaintColor();
-<<<<<<< HEAD
-
     void setAutosave(bool wantsAutosave);
     void loadSettings(QSettings* set = NULL);
     void saveSettings(QSettings* set = NULL);
     void importSettings();
     void exportSettings();
-    
-=======
     void exportVoxels();
     void importVoxels();
     void cutVoxels();
     void copyVoxels();
     void pasteVoxels();
-   
->>>>>>> 82c1ee2062577f614cfde096f08adfc9e83e4f0f
 private:
 
     static bool sendVoxelsOperation(VoxelNode* node, void* extraData);
@@ -260,7 +200,6 @@ private:
     QAction* _settingsAutosave;      // Whether settings are saved automatically
     
     QNetworkAccessManager* _networkAccessManager;
-    QSettings* _settings;
     
     SerialInterface _serialPort;
     bool _displayLevels;
@@ -353,7 +292,7 @@ private:
     int _bytesPerSecond;
     int _bytesCount;
     
-    QSettings _settings;   // Contain Menu settings and Avatar data
+    QSettings* _settings;   // Contain Menu settings and Avatar data
     bool _autosave;        // True if the autosave is on.
 };
 

interface/src/Avatar.cpp

@@ -429,9 +429,9 @@ void Avatar::simulate(float deltaTime, Transmitter* transmitter) {
     }
     
     glm::quat orientation = getOrientation();
-    glm::vec3 front = orientation * AVATAR_FRONT;
+    glm::vec3 front = orientation * IDENTITY_FRONT;
-    glm::vec3 right = orientation * AVATAR_RIGHT;
+    glm::vec3 right = orientation * IDENTITY_RIGHT;
-    glm::vec3 up = orientation * AVATAR_UP;
+    glm::vec3 up = orientation * IDENTITY_UP;
     
     // driving the avatar around should only apply if this is my avatar (as opposed to an avatar being driven remotely)
     const float THRUST_MAG = 600.0f;
@@ -651,9 +651,9 @@ void Avatar::updateHandMovementAndTouching(float deltaTime) {
     glm::quat orientation = getOrientation();
 
     // reset hand and arm positions according to hand movement
-    glm::vec3 right = orientation * AVATAR_RIGHT;
+    glm::vec3 right = orientation * IDENTITY_RIGHT;
-    glm::vec3 up    = orientation * AVATAR_UP;
+    glm::vec3 up    = orientation * IDENTITY_UP;
-    glm::vec3 front = orientation * AVATAR_FRONT;
+    glm::vec3 front = orientation * IDENTITY_FRONT;
 
     glm::vec3 transformedHandMovement
     = right *  _movedHandOffset.x * 2.0f
@@ -1125,14 +1125,14 @@ void Avatar::updateArmIKAndConstraints(float deltaTime) {
 
 glm::quat Avatar::computeRotationFromBodyToWorldUp(float proportion) const {
     glm::quat orientation = getOrientation();
-    glm::vec3 currentUp = orientation * AVATAR_UP;
+    glm::vec3 currentUp = orientation * IDENTITY_UP;
     float angle = glm::degrees(acosf(glm::clamp(glm::dot(currentUp, _worldUpDirection), -1.0f, 1.0f)));
     if (angle < EPSILON) {
         return glm::quat();
     }
     glm::vec3 axis;
     if (angle > 179.99f) { // 180 degree rotation; must use another axis
-        axis = orientation * AVATAR_RIGHT;
+        axis = orientation * IDENTITY_RIGHT;
     } else {
         axis = glm::normalize(glm::cross(currentUp, _worldUpDirection));
     }
@@ -1252,7 +1252,6 @@ void Avatar::setHeadFromGyros(glm::vec3* eulerAngles, glm::vec3* angularVelocity
     }
 }
 
-<<<<<<< HEAD
 void Avatar::loadData(QSettings* set) {
     set->beginGroup("Avatar");
 
@@ -1265,18 +1264,13 @@ void Avatar::loadData(QSettings* set) {
     _position.z = set->value("position_z", _position.z).toFloat();
 
     set->endGroup();
-=======
+}
+
 void Avatar::getBodyBallTransform(AvatarJointID jointID, glm::vec3& position, glm::quat& rotation) const {
     position = _bodyBall[jointID].position;
     rotation = _bodyBall[jointID].rotation;
 }
 
-void Avatar::writeAvatarDataToFile() {
-    Application::getInstance()->setSetting("avatarPos", _position);
-    Application::getInstance()->setSetting("avatarRotation", glm::vec3(_bodyYaw, _bodyPitch, _bodyRoll));
->>>>>>> 82c1ee2062577f614cfde096f08adfc9e83e4f0f
-}
-
 void Avatar::saveData(QSettings* set) {
     set->beginGroup("Avatar");
 

interface/src/Avatar.h

@@ -108,9 +108,9 @@ public:
     bool             getIsNearInteractingOther ()                const { return _avatarTouch.getAbleToReachOtherAvatar();}
     const glm::vec3& getHeadJointPosition      ()                const { return _skeleton.joint[ AVATAR_JOINT_HEAD_BASE ].position;}
     const glm::vec3& getBallPosition           (AvatarJointID j) const { return _bodyBall[j].position;} 
-    glm::vec3        getBodyRightDirection     ()                const { return getOrientation() * AVATAR_RIGHT; }
+    glm::vec3        getBodyRightDirection     ()                const { return getOrientation() * IDENTITY_RIGHT; }
-    glm::vec3        getBodyUpDirection        ()                const { return getOrientation() * AVATAR_UP; }
+    glm::vec3        getBodyUpDirection        ()                const { return getOrientation() * IDENTITY_UP; }
-    glm::vec3        getBodyFrontDirection     ()                const { return getOrientation() * AVATAR_FRONT; }
+    glm::vec3        getBodyFrontDirection     ()                const { return getOrientation() * IDENTITY_FRONT; }
     const glm::vec3& getVelocity               ()                const { return _velocity;}
     float            getSpeed                  ()                const { return _speed;}
     float            getHeight                 ()                const { return _height;}
@@ -131,18 +131,16 @@ public:
     void addThrust(glm::vec3 newThrust) { _thrust += newThrust; };
     glm::vec3 getThrust() { return _thrust; };
     
-<<<<<<< HEAD
     // get/set avatar data
     void saveData(QSettings* set);
     void loadData(QSettings* set);
-=======
+
     //  Get the position/rotation of a single body ball
     void getBodyBallTransform(AvatarJointID jointID, glm::vec3& position, glm::quat& rotation) const;
     
     //read/write avatar data
     void writeAvatarDataToFile();
     void readAvatarDataFromFile();
->>>>>>> 82c1ee2062577f614cfde096f08adfc9e83e4f0f
 
 private:
     // privatize copy constructor and assignment operator to avoid copying

interface/src/AvatarTouch.h

@@ -15,7 +15,7 @@
 
 enum AvatarHandState
 {
-    HAND_STATE_NULL = -1,
+    HAND_STATE_NULL = 0,
     HAND_STATE_OPEN,
     HAND_STATE_GRASPING,
     HAND_STATE_POINTING,

interface/src/Head.cpp

@@ -171,9 +171,9 @@ void Head::determineIfLookingAtSomething() {
 void Head::calculateGeometry() {
     //generate orientation directions 
     glm::quat orientation = getOrientation();
-    glm::vec3 right = orientation * AVATAR_RIGHT;
+    glm::vec3 right = orientation * IDENTITY_RIGHT;
-    glm::vec3 up = orientation * AVATAR_UP;
+    glm::vec3 up    = orientation * IDENTITY_UP;
-    glm::vec3 front = orientation * AVATAR_FRONT;
+    glm::vec3 front = orientation * IDENTITY_FRONT;
 
     //calculate the eye positions 
     _leftEyePosition  = _position 
@@ -346,9 +346,9 @@ void Head::renderMouth() {
     float s = sqrt(_averageLoudness);
 
     glm::quat orientation = getOrientation();
-    glm::vec3 right = orientation * AVATAR_RIGHT;
+    glm::vec3 right = orientation * IDENTITY_RIGHT;
-    glm::vec3 up = orientation * AVATAR_UP;
+    glm::vec3 up    = orientation * IDENTITY_UP;
-    glm::vec3 front = orientation * AVATAR_FRONT;
+    glm::vec3 front = orientation * IDENTITY_FRONT;
 
     glm::vec3 r = right * _scale * (0.30f + s * 0.0014f );
     glm::vec3 u = up * _scale * (0.05f + s * 0.0040f );
@@ -414,9 +414,9 @@ void Head::renderEyeBrows() {
     glm::vec3 rightBottom = _leftEyePosition;
    
     glm::quat orientation = getOrientation();
-    glm::vec3 right = orientation * AVATAR_RIGHT;
+    glm::vec3 right = orientation * IDENTITY_RIGHT;
-    glm::vec3 up = orientation * AVATAR_UP;
+    glm::vec3 up    = orientation * IDENTITY_UP;
-    glm::vec3 front = orientation * AVATAR_FRONT;
+    glm::vec3 front = orientation * IDENTITY_FRONT;
     
     glm::vec3 r = right * length; 
     glm::vec3 u = up * height; 
@@ -501,20 +501,20 @@ void Head::renderEyeBalls() {
 
                 //rotate the eyeball to aim towards the lookat position
                 glm::vec3 targetLookatAxis = glm::normalize(_lookAtPosition - _leftEyePosition); // the lookat direction
-                glm::vec3 rotationAxis = glm::cross(targetLookatAxis, AVATAR_UP);
+                glm::vec3 rotationAxis = glm::cross(targetLookatAxis, IDENTITY_UP);
-                float angle = 180.0f - angleBetween(targetLookatAxis, AVATAR_UP);            
+                float angle = 180.0f - angleBetween(targetLookatAxis, IDENTITY_UP);            
                 glRotatef(angle, rotationAxis.x, rotationAxis.y, rotationAxis.z);
                 glRotatef(180.0, 0.0f, 1.0f, 0.0f); //adjust roll to correct after previous rotations
             } else {
 
                 //rotate the eyeball to aim straight ahead
-                glm::vec3 rotationAxisToHeadFront = glm::cross(front, AVATAR_UP);            
+                glm::vec3 rotationAxisToHeadFront = glm::cross(front, IDENTITY_UP);            
-                float angleToHeadFront = 180.0f - angleBetween(front, AVATAR_UP);            
+                float angleToHeadFront = 180.0f - angleBetween(front, IDENTITY_UP);            
                 glRotatef(angleToHeadFront, rotationAxisToHeadFront.x, rotationAxisToHeadFront.y, rotationAxisToHeadFront.z);
 
                 //set the amount of roll (for correction after previous rotations)
-                float rollRotation = angleBetween(front, AVATAR_FRONT);            
+                float rollRotation = angleBetween(front, IDENTITY_FRONT);            
-                float dot = glm::dot(front, -AVATAR_RIGHT);
+                float dot = glm::dot(front, -IDENTITY_RIGHT);
                 if ( dot < 0.0f ) { rollRotation = -rollRotation; }
                 glRotatef(rollRotation, 0.0f, 1.0f, 0.0f); //roll the iris or correct roll about the lookat vector
             }
@@ -545,21 +545,21 @@ void Head::renderEyeBalls() {
             
                 //rotate the eyeball to aim towards the lookat position
                 glm::vec3 targetLookatAxis = glm::normalize(_lookAtPosition - _rightEyePosition);
-                glm::vec3 rotationAxis = glm::cross(targetLookatAxis, AVATAR_UP);
+                glm::vec3 rotationAxis = glm::cross(targetLookatAxis, IDENTITY_UP);
-                float angle = 180.0f - angleBetween(targetLookatAxis, AVATAR_UP);            
+                float angle = 180.0f - angleBetween(targetLookatAxis, IDENTITY_UP);            
                 glRotatef(angle, rotationAxis.x, rotationAxis.y, rotationAxis.z);
                 glRotatef(180.0f, 0.0f, 1.0f, 0.0f); //adjust roll to correct after previous rotations
 
             } else {
 
                 //rotate the eyeball to aim straight ahead
-                glm::vec3 rotationAxisToHeadFront = glm::cross(front, AVATAR_UP);            
+                glm::vec3 rotationAxisToHeadFront = glm::cross(front, IDENTITY_UP);            
-                float angleToHeadFront = 180.0f - angleBetween(front, AVATAR_UP);            
+                float angleToHeadFront = 180.0f - angleBetween(front, IDENTITY_UP);            
                 glRotatef(angleToHeadFront, rotationAxisToHeadFront.x, rotationAxisToHeadFront.y, rotationAxisToHeadFront.z);
 
                 //set the amount of roll (for correction after previous rotations)
-                float rollRotation = angleBetween(front, AVATAR_FRONT); 
+                float rollRotation = angleBetween(front, IDENTITY_FRONT); 
-                float dot = glm::dot(front, -AVATAR_RIGHT);
+                float dot = glm::dot(front, -IDENTITY_RIGHT);
                 if ( dot < 0.0f ) { rollRotation = -rollRotation; }
                 glRotatef(rollRotation, 0.0f, 1.0f, 0.0f); //roll the iris or correct roll about the lookat vector
             }
@@ -595,9 +595,8 @@ void Head::renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosi
 void Head::updateHairPhysics(float deltaTime) {
 
     glm::quat orientation = getOrientation();
-    glm::vec3 right = orientation * AVATAR_RIGHT;
+    glm::vec3 up    = orientation * IDENTITY_UP;
-    glm::vec3 up = orientation * AVATAR_UP;
+    glm::vec3 front = orientation * IDENTITY_FRONT;
-    glm::vec3 front = orientation * AVATAR_FRONT;
 
     for (int t = 0; t < NUM_HAIR_TUFTS; t ++) {
 

interface/src/Head.h

@@ -49,9 +49,9 @@ public:
     glm::quat getOrientation() const;
     glm::quat getWorldAlignedOrientation () const;
     
-    glm::vec3 getRightDirection() const { return getOrientation() * AVATAR_RIGHT; }
+    glm::vec3 getRightDirection() const { return getOrientation() * IDENTITY_RIGHT; }
-    glm::vec3 getUpDirection   () const { return getOrientation() * AVATAR_UP;    }
+    glm::vec3 getUpDirection   () const { return getOrientation() * IDENTITY_UP;    }
-    glm::vec3 getFrontDirection() const { return getOrientation() * AVATAR_FRONT; }
+    glm::vec3 getFrontDirection() const { return getOrientation() * IDENTITY_FRONT; }
     
     const bool getReturnToCenter() const { return _returnHeadToCenter; } // Do you want head to try to return to center (depends on interface detected)
     float getAverageLoudness() {return _averageLoudness;};

interface/src/Util.cpp

@@ -21,6 +21,8 @@
 #include "world.h"
 #include "Util.h"
 
+#include "VoxelConstants.h"
+
 using namespace std;
 
 // no clue which versions are affected...
@@ -415,9 +417,9 @@ void renderCircle(glm::vec3 position, float radius, glm::vec3 surfaceNormal, int
 
 
 void renderOrientationDirections(glm::vec3 position, const glm::quat& orientation, float size) {
-	glm::vec3 pRight	= position + orientation * AVATAR_RIGHT * size;
+	glm::vec3 pRight	= position + orientation * IDENTITY_RIGHT * size;
-	glm::vec3 pUp		= position + orientation * AVATAR_UP * size;
+	glm::vec3 pUp		= position + orientation * IDENTITY_UP    * size;
-	glm::vec3 pFront	= position + orientation * AVATAR_FRONT * size;
+	glm::vec3 pFront	= position + orientation * IDENTITY_FRONT * size;
 		
 	glColor3f(1.0f, 0.0f, 0.0f);
 	glBegin(GL_LINE_STRIP);

libraries/avatars/CMakeLists.txt

@@ -15,4 +15,7 @@ include(${MACRO_DIR}/IncludeGLM.cmake)
 include_glm(${TARGET_NAME} ${ROOT_DIR})
 
 include(${MACRO_DIR}/LinkHifiLibrary.cmake)
-link_hifi_library(shared ${TARGET_NAME} ${ROOT_DIR})
+link_hifi_library(shared ${TARGET_NAME} ${ROOT_DIR})
+
+# link in the hifi voxels library
+link_hifi_library(voxels ${TARGET_NAME} ${ROOT_DIR})

libraries/avatars/src/AvatarData.cpp

@@ -14,23 +14,10 @@
 #include <PacketHeaders.h>
 
 #include "AvatarData.h"
+#include <VoxelConstants.h>
 
 using namespace std;
 
-int packFloatAngleToTwoByte(unsigned char* buffer, float angle) {
-    const float ANGLE_CONVERSION_RATIO = (std::numeric_limits<uint16_t>::max() / 360.0);
-    
-    uint16_t angleHolder = floorf((angle + 180) * ANGLE_CONVERSION_RATIO);
-    memcpy(buffer, &angleHolder, sizeof(uint16_t));
-    
-    return sizeof(uint16_t);
-}
-
-int unpackFloatAngleFromTwoByte(uint16_t* byteAnglePointer, float* destinationPointer) {
-    *destinationPointer = (*byteAnglePointer / (float) std::numeric_limits<uint16_t>::max()) * 360.0 - 180;
-    return sizeof(uint16_t);
-}
-
 AvatarData::AvatarData(Agent* owningAgent) :
     AgentData(owningAgent),
     _handPosition(0,0,0),
@@ -39,9 +26,7 @@ AvatarData::AvatarData(Agent* owningAgent) :
     _bodyRoll(0.0),
     _handState(0),
     _cameraPosition(0,0,0),
-    _cameraDirection(0,0,0),
+    _cameraOrientation(),
-    _cameraUp(0,0,0),
-    _cameraRight(0,0,0),
     _cameraFov(0.0f),
     _cameraAspectRatio(0.0f),
     _cameraNearClip(0.0f),
@@ -91,55 +76,45 @@ int AvatarData::getBroadcastData(unsigned char* destinationBuffer) {
     memcpy(destinationBuffer, &_headData->_leanForward, sizeof(_headData->_leanForward));
     destinationBuffer += sizeof(_headData->_leanForward);
 
-    // Hand Position
+    // Hand Position - is relative to body position
-    memcpy(destinationBuffer, &_handPosition, sizeof(float) * 3);
+    glm::vec3 handPositionRelative = _handPosition - _position;
+    memcpy(destinationBuffer, &handPositionRelative, sizeof(float) * 3);
     destinationBuffer += sizeof(float) * 3;
 
     // Lookat Position
     memcpy(destinationBuffer, &_headData->_lookAtPosition, sizeof(_headData->_lookAtPosition));
     destinationBuffer += sizeof(_headData->_lookAtPosition);
      
-    // Hand State (0 = not grabbing, 1 = grabbing)
-    memcpy(destinationBuffer, &_handState, sizeof(char));
-    destinationBuffer += sizeof(char);
-    
     // Instantaneous audio loudness (used to drive facial animation)
+    //destinationBuffer += packFloatToByte(destinationBuffer, std::min(MAX_AUDIO_LOUDNESS, _audioLoudness), MAX_AUDIO_LOUDNESS);
     memcpy(destinationBuffer, &_headData->_audioLoudness, sizeof(float));
     destinationBuffer += sizeof(float); 
 
     // camera details
     memcpy(destinationBuffer, &_cameraPosition, sizeof(_cameraPosition));
     destinationBuffer += sizeof(_cameraPosition);
-    memcpy(destinationBuffer, &_cameraDirection, sizeof(_cameraDirection));
+    destinationBuffer += packOrientationQuatToBytes(destinationBuffer, _cameraOrientation);
-    destinationBuffer += sizeof(_cameraDirection);
+    destinationBuffer += packFloatAngleToTwoByte(destinationBuffer, _cameraFov);
-    memcpy(destinationBuffer, &_cameraRight, sizeof(_cameraRight));
+    destinationBuffer += packFloatRatioToTwoByte(destinationBuffer, _cameraAspectRatio);
-    destinationBuffer += sizeof(_cameraRight);
+    destinationBuffer += packClipValueToTwoByte(destinationBuffer, _cameraNearClip);
-    memcpy(destinationBuffer, &_cameraUp, sizeof(_cameraUp));
+    destinationBuffer += packClipValueToTwoByte(destinationBuffer, _cameraFarClip);
-    destinationBuffer += sizeof(_cameraUp);
-    memcpy(destinationBuffer, &_cameraFov, sizeof(_cameraFov));
-    destinationBuffer += sizeof(_cameraFov);
-    memcpy(destinationBuffer, &_cameraAspectRatio, sizeof(_cameraAspectRatio));
-    destinationBuffer += sizeof(_cameraAspectRatio);
-    memcpy(destinationBuffer, &_cameraNearClip, sizeof(_cameraNearClip));
-    destinationBuffer += sizeof(_cameraNearClip);
-    memcpy(destinationBuffer, &_cameraFarClip, sizeof(_cameraFarClip));
-    destinationBuffer += sizeof(_cameraFarClip);
-
-    // key state
-    *destinationBuffer++ = _keyState;
 
     // chat message
     *destinationBuffer++ = _chatMessage.size();
     memcpy(destinationBuffer, _chatMessage.data(), _chatMessage.size() * sizeof(char));
     destinationBuffer += _chatMessage.size() * sizeof(char);
     
-    // voxel sending features...
+    // bitMask of less than byte wide items
-    // voxel sending features...
+    unsigned char bitItems = 0;
-    unsigned char wantItems = 0;
+    if (_wantResIn) { setAtBit(bitItems,WANT_RESIN_AT_BIT); }
-    if (_wantResIn) { setAtBit(wantItems,WANT_RESIN_AT_BIT); }
+    if (_wantColor) { setAtBit(bitItems,WANT_COLOR_AT_BIT); }
-    if (_wantColor) { setAtBit(wantItems,WANT_COLOR_AT_BIT); }
+    if (_wantDelta) { setAtBit(bitItems,WANT_DELTA_AT_BIT); }
-    if (_wantDelta) { setAtBit(wantItems,WANT_DELTA_AT_BIT); }
+
-    *destinationBuffer++ = wantItems;
+    // key state
+    setSemiNibbleAt(bitItems,KEY_STATE_START_BIT,_keyState);
+    // hand state
+    setSemiNibbleAt(bitItems,HAND_STATE_START_BIT,_handState);
+    *destinationBuffer++ = bitItems;
     
     return destinationBuffer - bufferStart;
 }
@@ -185,54 +160,170 @@ int AvatarData::parseData(unsigned char* sourceBuffer, int numBytes) {
     memcpy(&_headData->_leanForward, sourceBuffer, sizeof(_headData->_leanForward));
     sourceBuffer += sizeof(_headData->_leanForward);
 
-    // Hand Position
+    // Hand Position - is relative to body position
-    memcpy(&_handPosition, sourceBuffer, sizeof(float) * 3);
+    glm::vec3 handPositionRelative;
+    memcpy(&handPositionRelative, sourceBuffer, sizeof(float) * 3);
+    _handPosition = _position + handPositionRelative;
     sourceBuffer += sizeof(float) * 3;
     
     // Lookat Position
     memcpy(&_headData->_lookAtPosition, sourceBuffer, sizeof(_headData->_lookAtPosition));
     sourceBuffer += sizeof(_headData->_lookAtPosition);
-        
+
-    // Hand State
-    memcpy(&_handState, sourceBuffer, sizeof(char));
-    sourceBuffer += sizeof(char);
-    
     // Instantaneous audio loudness (used to drive facial animation)
+    //sourceBuffer += unpackFloatFromByte(sourceBuffer, _audioLoudness, MAX_AUDIO_LOUDNESS);
     memcpy(&_headData->_audioLoudness, sourceBuffer, sizeof(float));
     sourceBuffer += sizeof(float);
     
     // camera details
     memcpy(&_cameraPosition, sourceBuffer, sizeof(_cameraPosition));
     sourceBuffer += sizeof(_cameraPosition);
-    memcpy(&_cameraDirection, sourceBuffer, sizeof(_cameraDirection));
+    sourceBuffer += unpackOrientationQuatFromBytes(sourceBuffer, _cameraOrientation);
-    sourceBuffer += sizeof(_cameraDirection);
+    sourceBuffer += unpackFloatAngleFromTwoByte((uint16_t*) sourceBuffer, &_cameraFov);
-    memcpy(&_cameraRight, sourceBuffer, sizeof(_cameraRight));
+    sourceBuffer += unpackFloatRatioFromTwoByte(sourceBuffer,_cameraAspectRatio);
-    sourceBuffer += sizeof(_cameraRight);
+    sourceBuffer += unpackClipValueFromTwoByte(sourceBuffer,_cameraNearClip);
-    memcpy(&_cameraUp, sourceBuffer, sizeof(_cameraUp));
+    sourceBuffer += unpackClipValueFromTwoByte(sourceBuffer,_cameraFarClip);
-    sourceBuffer += sizeof(_cameraUp);
+
-    memcpy(&_cameraFov, sourceBuffer, sizeof(_cameraFov));
-    sourceBuffer += sizeof(_cameraFov);
-    memcpy(&_cameraAspectRatio, sourceBuffer, sizeof(_cameraAspectRatio));
-    sourceBuffer += sizeof(_cameraAspectRatio);
-    memcpy(&_cameraNearClip, sourceBuffer, sizeof(_cameraNearClip));
-    sourceBuffer += sizeof(_cameraNearClip);
-    memcpy(&_cameraFarClip, sourceBuffer, sizeof(_cameraFarClip));
-    sourceBuffer += sizeof(_cameraFarClip);
-    
-    // key state
-    _keyState = (KeyState)*sourceBuffer++;
-    
     // the rest is a chat message
     int chatMessageSize = *sourceBuffer++;
     _chatMessage = string((char*)sourceBuffer, chatMessageSize);
     sourceBuffer += chatMessageSize * sizeof(char);
 
     // voxel sending features...
-    unsigned char wantItems = 0;
+    unsigned char bitItems = 0;
-    wantItems = (unsigned char)*sourceBuffer++;
+    bitItems = (unsigned char)*sourceBuffer++;
-    _wantResIn = oneAtBit(wantItems,WANT_RESIN_AT_BIT);
+    _wantResIn = oneAtBit(bitItems,WANT_RESIN_AT_BIT);
-    _wantColor = oneAtBit(wantItems,WANT_COLOR_AT_BIT);
+    _wantColor = oneAtBit(bitItems,WANT_COLOR_AT_BIT);
-    _wantDelta = oneAtBit(wantItems,WANT_DELTA_AT_BIT);
+    _wantDelta = oneAtBit(bitItems,WANT_DELTA_AT_BIT);
+
+    // key state, stored as a semi-nibble in the bitItems
+    _keyState = (KeyState)getSemiNibbleAt(bitItems,KEY_STATE_START_BIT);
+
+    // hand state, stored as a semi-nibble in the bitItems
+    _handState = getSemiNibbleAt(bitItems,HAND_STATE_START_BIT);
 
     return sourceBuffer - startPosition;
 }
+
+glm::vec3 AvatarData::calculateCameraDirection() const {
+    glm::vec3 direction = glm::vec3(_cameraOrientation * glm::vec4(IDENTITY_FRONT, 0.0f));
+    return direction;
+}
+
+
+int packFloatAngleToTwoByte(unsigned char* buffer, float angle) {
+    const float ANGLE_CONVERSION_RATIO = (std::numeric_limits<uint16_t>::max() / 360.0);
+    
+    uint16_t angleHolder = floorf((angle + 180) * ANGLE_CONVERSION_RATIO);
+    memcpy(buffer, &angleHolder, sizeof(uint16_t));
+    
+    return sizeof(uint16_t);
+}
+
+int unpackFloatAngleFromTwoByte(uint16_t* byteAnglePointer, float* destinationPointer) {
+    *destinationPointer = (*byteAnglePointer / (float) std::numeric_limits<uint16_t>::max()) * 360.0 - 180;
+    return sizeof(uint16_t);
+}
+
+int packOrientationQuatToBytes(unsigned char* buffer, const glm::quat& quatInput) {
+    const float QUAT_PART_CONVERSION_RATIO = (std::numeric_limits<uint16_t>::max() / 2.0);
+    uint16_t quatParts[4];
+    quatParts[0] = floorf((quatInput.x + 1.0) * QUAT_PART_CONVERSION_RATIO);
+    quatParts[1] = floorf((quatInput.y + 1.0) * QUAT_PART_CONVERSION_RATIO);
+    quatParts[2] = floorf((quatInput.z + 1.0) * QUAT_PART_CONVERSION_RATIO);
+    quatParts[3] = floorf((quatInput.w + 1.0) * QUAT_PART_CONVERSION_RATIO);
+
+    memcpy(buffer, &quatParts, sizeof(quatParts));
+    return sizeof(quatParts);
+}
+
+int unpackOrientationQuatFromBytes(unsigned char* buffer, glm::quat& quatOutput) {
+    uint16_t quatParts[4];
+    memcpy(&quatParts, buffer, sizeof(quatParts));
+
+    quatOutput.x = ((quatParts[0] / (float) std::numeric_limits<uint16_t>::max()) * 2.0) - 1.0;
+    quatOutput.y = ((quatParts[1] / (float) std::numeric_limits<uint16_t>::max()) * 2.0) - 1.0;
+    quatOutput.z = ((quatParts[2] / (float) std::numeric_limits<uint16_t>::max()) * 2.0) - 1.0;
+    quatOutput.w = ((quatParts[3] / (float) std::numeric_limits<uint16_t>::max()) * 2.0) - 1.0;
+
+    return sizeof(quatParts);
+}
+
+float SMALL_LIMIT = 10.0;
+float LARGE_LIMIT = 1000.0;
+
+int packFloatRatioToTwoByte(unsigned char* buffer, float ratio) {
+    // if the ratio is less than 10, then encode it as a positive number scaled from 0 to int16::max()
+    int16_t ratioHolder;
+    
+    if (ratio < SMALL_LIMIT) {
+        const float SMALL_RATIO_CONVERSION_RATIO = (std::numeric_limits<int16_t>::max() / SMALL_LIMIT);
+        ratioHolder = floorf(ratio * SMALL_RATIO_CONVERSION_RATIO);
+    } else {
+        const float LARGE_RATIO_CONVERSION_RATIO = std::numeric_limits<int16_t>::min() / LARGE_LIMIT;
+        ratioHolder = floorf((std::min(ratio,LARGE_LIMIT) - SMALL_LIMIT) * LARGE_RATIO_CONVERSION_RATIO);
+    }
+    memcpy(buffer, &ratioHolder, sizeof(ratioHolder));
+    return sizeof(ratioHolder);
+}
+
+int unpackFloatRatioFromTwoByte(unsigned char* buffer, float& ratio) {
+    int16_t ratioHolder;
+    memcpy(&ratioHolder, buffer, sizeof(ratioHolder));
+
+    // If it's positive, than the original ratio was less than SMALL_LIMIT
+    if (ratioHolder > 0) {
+        ratio = (ratioHolder / (float) std::numeric_limits<int16_t>::max()) * SMALL_LIMIT;
+    } else {
+        // If it's negative, than the original ratio was between SMALL_LIMIT and LARGE_LIMIT
+        ratio = ((ratioHolder / (float) std::numeric_limits<int16_t>::min()) * LARGE_LIMIT) + SMALL_LIMIT;
+    }
+    return sizeof(ratioHolder);
+}
+
+int packClipValueToTwoByte(unsigned char* buffer, float clipValue) {
+    // Clip values must be less than max signed 16bit integers
+    assert(clipValue < std::numeric_limits<int16_t>::max());
+    int16_t holder;
+    
+    // if the clip is less than 10, then encode it as a positive number scaled from 0 to int16::max()
+    if (clipValue < SMALL_LIMIT) {
+        const float SMALL_RATIO_CONVERSION_RATIO = (std::numeric_limits<int16_t>::max() / SMALL_LIMIT);
+        holder = floorf(clipValue * SMALL_RATIO_CONVERSION_RATIO);
+    } else {
+        // otherwise we store it as a negative integer
+        holder = -1 * floorf(clipValue);
+    }
+    memcpy(buffer, &holder, sizeof(holder));
+    return sizeof(holder);
+}
+
+int unpackClipValueFromTwoByte(unsigned char* buffer, float& clipValue) {
+    int16_t holder;
+    memcpy(&holder, buffer, sizeof(holder));
+
+    // If it's positive, than the original clipValue was less than SMALL_LIMIT
+    if (holder > 0) {
+        clipValue = (holder / (float) std::numeric_limits<int16_t>::max()) * SMALL_LIMIT;
+    } else {
+        // If it's negative, than the original holder can be found as the opposite sign of holder
+        clipValue = -1.0f * holder;
+    }
+    return sizeof(holder);
+}
+
+int packFloatToByte(unsigned char* buffer, float value, float scaleBy) {
+    unsigned char holder;
+    const float CONVERSION_RATIO = (255 / scaleBy);
+    holder = floorf(value * CONVERSION_RATIO);
+    memcpy(buffer, &holder, sizeof(holder));
+    return sizeof(holder);
+}
+
+int unpackFloatFromByte(unsigned char* buffer, float& value, float scaleBy) {
+    unsigned char holder;
+    memcpy(&holder, buffer, sizeof(holder));
+    value = ((float)holder / (float) 255) * scaleBy;
+    return sizeof(holder);
+}
+

libraries/avatars/src/AvatarData.h

@@ -10,8 +10,10 @@
 #define __hifi__AvatarData__
 
 #include <string>
+#include <inttypes.h>
 
 #include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
 
 #include <AgentData.h>
 #include "HeadData.h"
@@ -19,15 +21,15 @@
 const int WANT_RESIN_AT_BIT = 0;
 const int WANT_COLOR_AT_BIT = 1;
 const int WANT_DELTA_AT_BIT = 2;
+const int KEY_STATE_START_BIT = 3;  // 4th and 5th bits
+const int HAND_STATE_START_BIT = 5; // 6th and 7th bits
+
+const float MAX_AUDIO_LOUDNESS = 1000.0; // close enough for mouth animation
 
-// this is where the coordinate system is represented
-const glm::vec3 AVATAR_RIGHT = glm::vec3(1.0f, 0.0f, 0.0f);
-const glm::vec3 AVATAR_UP    = glm::vec3(0.0f, 1.0f, 0.0f);
-const glm::vec3 AVATAR_FRONT = glm::vec3(0.0f, 0.0f, -1.0f);
 
 enum KeyState
 {
-    NO_KEY_DOWN,
+    NO_KEY_DOWN = 0,
     INSERT_KEY_DOWN,
     DELETE_KEY_DOWN
 };
@@ -59,23 +61,21 @@ public:
     
     // getters for camera details
     const glm::vec3& getCameraPosition()    const { return _cameraPosition; };
-    const glm::vec3& getCameraDirection()   const { return _cameraDirection; }
+    const glm::quat& getCameraOrientation() const { return _cameraOrientation; }
-    const glm::vec3& getCameraUp()          const { return _cameraUp; }
-    const glm::vec3& getCameraRight()       const { return _cameraRight; }
     float getCameraFov()                    const { return _cameraFov; }
     float getCameraAspectRatio()            const { return _cameraAspectRatio; }
     float getCameraNearClip()               const { return _cameraNearClip; }
     float getCameraFarClip()                const { return _cameraFarClip; }
 
+    glm::vec3 calculateCameraDirection() const;
+
     // setters for camera details    
-    void setCameraPosition(const glm::vec3& position)   { _cameraPosition    = position; };
+    void setCameraPosition(const glm::vec3& position)       { _cameraPosition    = position;    }
-    void setCameraDirection(const glm::vec3& direction) { _cameraDirection   = direction; }
+    void setCameraOrientation(const glm::quat& orientation) { _cameraOrientation = orientation; }
-    void setCameraUp(const glm::vec3& up)               { _cameraUp          = up; }
+    void setCameraFov(float fov)                            { _cameraFov         = fov;         }
-    void setCameraRight(const glm::vec3& right)         { _cameraRight       = right; }
+    void setCameraAspectRatio(float aspectRatio)            { _cameraAspectRatio = aspectRatio; }
-    void setCameraFov(float fov)                        { _cameraFov         = fov; }
+    void setCameraNearClip(float nearClip)                  { _cameraNearClip    = nearClip;    }
-    void setCameraAspectRatio(float aspectRatio)        { _cameraAspectRatio = aspectRatio; }
+    void setCameraFarClip(float farClip)                    { _cameraFarClip     = farClip;     }
-    void setCameraNearClip(float nearClip)              { _cameraNearClip    = nearClip; }
-    void setCameraFarClip(float farClip)                { _cameraFarClip     = farClip; }
     
     // key state
     void setKeyState(KeyState s) { _keyState = s; }
@@ -109,11 +109,7 @@ protected:
     
     // camera details for the avatar
     glm::vec3 _cameraPosition;
-
+    glm::quat _cameraOrientation;
-    // can we describe this in less space? For example, a Quaternion? or Euler angles?
-    glm::vec3 _cameraDirection;
-    glm::vec3 _cameraUp;
-    glm::vec3 _cameraRight;
     float _cameraFov;
     float _cameraAspectRatio;
     float _cameraNearClip;
@@ -137,4 +133,31 @@ private:
     AvatarData& operator= (const AvatarData&);
 };
 
+
+// These pack/unpack functions are designed to start specific known types in as efficient a manner
+// as possible. Taking advantage of the known characteristics of the semantic types.
+
+// Angles are known to be between 0 and 360deg, this allows us to encode in 16bits with great accuracy
+int packFloatAngleToTwoByte(unsigned char* buffer, float angle);
+int unpackFloatAngleFromTwoByte(uint16_t* byteAnglePointer, float* destinationPointer);
+
+// Orientation Quats are known to have 4 normalized components be between -1.0 and 1.0 
+// this allows us to encode each component in 16bits with great accuracy
+int packOrientationQuatToBytes(unsigned char* buffer, const glm::quat& quatInput);
+int unpackOrientationQuatFromBytes(unsigned char* buffer, glm::quat& quatOutput);
+
+// Ratios need the be highly accurate when less than 10, but not very accurate above 10, and they
+// are never greater than 1000 to 1, this allows us to encode each component in 16bits
+int packFloatRatioToTwoByte(unsigned char* buffer, float ratio);
+int unpackFloatRatioFromTwoByte(unsigned char* buffer, float& ratio);
+
+// Near/Far Clip values need the be highly accurate when less than 10, but only integer accuracy above 10 and
+// they are never greater than 16,000, this allows us to encode each component in 16bits
+int packClipValueToTwoByte(unsigned char* buffer, float clipValue);
+int unpackClipValueFromTwoByte(unsigned char* buffer, float& clipValue);
+
+// Positive floats that don't need to be very precise
+int packFloatToByte(unsigned char* buffer, float value, float scaleBy);
+int unpackFloatFromByte(unsigned char* buffer, float& value, float scaleBy);
+
 #endif /* defined(__hifi__AvatarData__) */

libraries/shared/src/SharedUtil.cpp

@@ -101,6 +101,15 @@ void setAtBit(unsigned char& byte, int bitIndex) {
     byte += (1 << (7 - bitIndex));
 }
 
+int  getSemiNibbleAt(unsigned char& byte, int bitIndex) {
+    return (byte >> (7 - bitIndex) & 3); // semi-nibbles store 00, 01, 10, or 11
+}
+
+void setSemiNibbleAt(unsigned char& byte, int bitIndex, int value) {
+    //assert(value <= 3 && value >= 0);
+    byte += ((value & 3) << (7 - bitIndex)); // semi-nibbles store 00, 01, 10, or 11
+}
+
 
 void switchToResourcesParentIfRequired() {
 #ifdef __APPLE__
@@ -421,3 +430,4 @@ int insertIntoSortedArrays(void* value, float key, int originalIndex,
     }
     return -1; // error case
 }
+

libraries/shared/src/SharedUtil.h

@@ -54,6 +54,10 @@ int numberOfOnes(unsigned char byte);
 bool oneAtBit(unsigned char byte, int bitIndex);
 void setAtBit(unsigned char& byte, int bitIndex);
 
+int  getSemiNibbleAt(unsigned char& byte, int bitIndex);
+void setSemiNibbleAt(unsigned char& byte, int bitIndex, int value);
+
+
 void switchToResourcesParentIfRequired();
 
 void loadRandomIdentifier(unsigned char* identifierBuffer, int numBytes);
@@ -88,4 +92,5 @@ class debug {
 public:                           
     static const char* valueOf(bool checkValue) { return checkValue ? "yes" : "no"; };
 };
+
 #endif /* defined(__hifi__SharedUtil__) */

libraries/voxels/src/ViewFrustum.cpp

@@ -13,28 +13,37 @@
 #include <glm/gtx/transform.hpp>
 
 #include "ViewFrustum.h"
+#include "VoxelConstants.h"
 #include "SharedUtil.h"
 #include "Log.h"
 
 using namespace std;
 
 ViewFrustum::ViewFrustum() :
-    _position(glm::vec3(0,0,0)),
+    _position(0,0,0),
-    _direction(glm::vec3(0,0,0)),
+    _orientation(),
-    _up(glm::vec3(0,0,0)),
+    _direction(0,0,0),
-    _right(glm::vec3(0,0,0)),
+    _up(0,0,0),
+    _right(0,0,0),
     _fieldOfView(0.0),
     _aspectRatio(1.0),
     _nearClip(0.1),
     _farClip(500.0),
-    _farTopLeft(glm::vec3(0,0,0)),
+    _farTopLeft(0,0,0),
-    _farTopRight(glm::vec3(0,0,0)),
+    _farTopRight(0,0,0),
-    _farBottomLeft(glm::vec3(0,0,0)),
+    _farBottomLeft(0,0,0),
-    _farBottomRight(glm::vec3(0,0,0)),
+    _farBottomRight(0,0,0),
-    _nearTopLeft(glm::vec3(0,0,0)),
+    _nearTopLeft(0,0,0),
-    _nearTopRight(glm::vec3(0,0,0)),
+    _nearTopRight(0,0,0),
-    _nearBottomLeft(glm::vec3(0,0,0)),
+    _nearBottomLeft(0,0,0),
-    _nearBottomRight(glm::vec3(0,0,0)) { }
+    _nearBottomRight(0,0,0) { }
+    
+void ViewFrustum::setOrientation(const glm::quat& orientationAsQuaternion) {
+    _orientation = orientationAsQuaternion;
+    _right       = glm::vec3(orientationAsQuaternion * glm::vec4(IDENTITY_RIGHT, 0.0f));
+    _up          = glm::vec3(orientationAsQuaternion * glm::vec4(IDENTITY_UP,    0.0f));
+    _direction   = glm::vec3(orientationAsQuaternion * glm::vec4(IDENTITY_FRONT, 0.0f));
+}
 
 /////////////////////////////////////////////////////////////////////////////////////
 // ViewFrustum::calculateViewFrustum()

libraries/voxels/src/ViewFrustum.h

@@ -21,6 +21,9 @@ private:
 
     // camera location/orientation attributes
     glm::vec3   _position;
+    glm::quat   _orientation;
+    
+    // calculated for orientation
     glm::vec3   _direction;
     glm::vec3   _up;
     glm::vec3   _right;
@@ -53,23 +56,23 @@ private:
     
 public:
     // setters for camera attributes
-    void setPosition        (const glm::vec3& p) { _position = p; }
+    void setPosition        (const glm::vec3& p) { _position = p; };
-    void setOrientation     (const glm::vec3& d, const glm::vec3& u, const glm::vec3& r ) 
+    void setOrientation     (const glm::quat& orientationAsQuaternion);
-        { _direction = d; _up = u; _right = r; }
 
     // getters for camera attributes
-    const glm::vec3& getPosition()  const { return _position;  };
+    const glm::vec3& getPosition()    const { return _position;    };
-    const glm::vec3& getDirection() const { return _direction; };
+    const glm::quat& getOrientation() const { return _orientation; };
-    const glm::vec3& getUp()        const { return _up;        };
+    const glm::vec3& getDirection()   const { return _direction;   };
-    const glm::vec3& getRight()     const { return _right;     };
+    const glm::vec3& getUp()          const { return _up;          };
+    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 setEyeOffsetPosition    (const glm::vec3& p) { _eyeOffsetPosition    = p; };
-    void setEyeOffsetOrientation (const glm::quat& o) { _eyeOffsetOrientation = o; }
+    void setEyeOffsetOrientation (const glm::quat& o) { _eyeOffsetOrientation = o; };
 
 
     // getters for lens attributes

libraries/voxels/src/VoxelConstants.h

@@ -15,6 +15,11 @@
 #include <limits.h>
 #include <OctalCode.h>
 
+// this is where the coordinate system is represented
+const glm::vec3 IDENTITY_RIGHT = glm::vec3( 1.0f, 0.0f, 0.0f);
+const glm::vec3 IDENTITY_UP    = glm::vec3( 0.0f, 1.0f, 0.0f);
+const glm::vec3 IDENTITY_FRONT = glm::vec3( 0.0f, 0.0f,-1.0f);
+
 const int TREE_SCALE = 128;
 
 const int NUMBER_OF_CHILDREN = 8;

voxel-server/src/VoxelAgentData.cpp

@@ -48,7 +48,7 @@ bool VoxelAgentData::updateCurrentViewFrustum() {
     ViewFrustum newestViewFrustum;
     // get position and orientation details from the camera
     newestViewFrustum.setPosition(getCameraPosition());
-    newestViewFrustum.setOrientation(getCameraDirection(), getCameraUp(), getCameraRight());
+    newestViewFrustum.setOrientation(getCameraOrientation());
 
     // Also make sure it's got the correct lens details from the camera
     newestViewFrustum.setFieldOfView(getCameraFov());