Merge branch 'master' into toybox

examples/controllers/handControllerGrab.js

@@ -101,9 +101,11 @@ function MyController(hand, triggerAction) {
         this.getHandRotation = MyAvatar.getLeftPalmRotation;
     }
 
+    var SPATIAL_CONTROLLERS_PER_PALM = 2;
+    var TIP_CONTROLLER_OFFSET = 1;
     this.triggerAction = triggerAction;
-    this.palm = 2 * hand;
-    // this.tip = 2 * hand + 1; // unused, but I'm leaving this here for fear it will be needed
+    this.palm = SPATIAL_CONTROLLERS_PER_PALM * hand;
+    this.tip = SPATIAL_CONTROLLERS_PER_PALM * hand + TIP_CONTROLLER_OFFSET; 
 
     this.actionID = null; // action this script created...
     this.grabbedEntity = null; // on this entity.
@@ -292,6 +294,9 @@ function MyController(hand, triggerAction) {
             Entities.callEntityMethod(this.grabbedEntity, "startDistantGrab");
         }
 
+        this.currentAvatarPosition = MyAvatar.position;
+        this.currentAvatarOrientation = MyAvatar.orientation;
+
     };
 
     this.continueDistanceHolding = function() {
@@ -310,11 +315,46 @@ function MyController(hand, triggerAction) {
         // the action was set up on a previous call.  update the targets.
         var radius = Math.max(Vec3.distance(this.currentObjectPosition, handControllerPosition) * DISTANCE_HOLDING_RADIUS_FACTOR, DISTANCE_HOLDING_RADIUS_FACTOR);
 
+        // how far did avatar move this timestep?
+        var currentPosition = MyAvatar.position;
+        var avatarDeltaPosition = Vec3.subtract(currentPosition, this.currentAvatarPosition); 
+        this.currentAvatarPosition = currentPosition;
+        
+        // How far did the avatar turn this timestep?
+        // Note:  The following code is too long because we need a Quat.quatBetween() function
+        // that returns the minimum quaternion between two quaternions. 
+        var currentOrientation = MyAvatar.orientation;
+        if (Quat.dot(currentOrientation, this.currentAvatarOrientation) < 0.0) {
+            var negativeCurrentOrientation = { 
+                x: -currentOrientation.x, 
+                y: -currentOrientation.y, 
+                z: -currentOrientation.z, 
+                w: -currentOrientation.w 
+            };
+            var avatarDeltaOrientation = Quat.multiply(negativeCurrentOrientation, Quat.inverse(this.currentAvatarOrientation));
+        } else {
+            var avatarDeltaOrientation = Quat.multiply(currentOrientation, Quat.inverse(this.currentAvatarOrientation));
+        }
+        var handToAvatar = Vec3.subtract(handControllerPosition, this.currentAvatarPosition);
+        var objectToAvatar = Vec3.subtract(this.currentObjectPosition, this.currentAvatarPosition);
+        var handMovementFromTurning = Vec3.subtract(Quat.multiply(avatarDeltaOrientation, handToAvatar), handToAvatar); 
+        var objectMovementFromTurning = Vec3.subtract(Quat.multiply(avatarDeltaOrientation, objectToAvatar), objectToAvatar); 
+        this.currentAvatarOrientation = currentOrientation;
+      
+        // how far did hand move this timestep?
         var handMoved = Vec3.subtract(handControllerPosition, this.handPreviousPosition);
         this.handPreviousPosition = handControllerPosition;
+        
+        //  magnify the hand movement but not the change from avatar movement & rotation
+        handMoved = Vec3.subtract(handMoved, avatarDeltaPosition);
+        handMoved = Vec3.subtract(handMoved, handMovementFromTurning);
         var superHandMoved = Vec3.multiply(handMoved, radius);
 
+        //  Move the object by the magnified amount and then by amount from avatar movement & rotation
         var newObjectPosition = Vec3.sum(this.currentObjectPosition, superHandMoved);
+        newObjectPosition = Vec3.sum(newObjectPosition, avatarDeltaPosition);
+        newObjectPosition = Vec3.sum(newObjectPosition, objectMovementFromTurning);
+
         var deltaPosition = Vec3.subtract(newObjectPosition, this.currentObjectPosition); // meters
         var now = Date.now();
         var deltaTime = (now - this.currentObjectTime) / MSEC_PER_SEC; // convert to seconds
@@ -379,7 +419,8 @@ function MyController(hand, triggerAction) {
 
         }
 
-        this.currentHandControllerPosition = Controller.getSpatialControlPosition(this.palm);
+        this.currentHandControllerTipPosition = Controller.getSpatialControlPosition(this.tip);
+
         this.currentObjectTime = Date.now();
     };
 
@@ -389,15 +430,21 @@ function MyController(hand, triggerAction) {
             return;
         }
 
-        // keep track of the measured velocity of the held object
-        var handControllerPosition = Controller.getSpatialControlPosition(this.palm);
+        // Keep track of the fingertip velocity to impart when we release the object
+        // Note that the idea of using a constant 'tip' velocity regardless of the 
+        // object's actual held offset is an idea intended to make it easier to throw things:
+        // Because we might catch something or transfer it between hands without a good idea 
+        // of it's actual offset, let's try imparting a velocity which is at a fixed radius
+        // from the palm.  
+
+        var handControllerPosition = Controller.getSpatialControlPosition(this.tip);
         var now = Date.now();
 
-        var deltaPosition = Vec3.subtract(handControllerPosition, this.currentHandControllerPosition); // meters
+        var deltaPosition = Vec3.subtract(handControllerPosition, this.currentHandControllerTipPosition); // meters
         var deltaTime = (now - this.currentObjectTime) / MSEC_PER_SEC; // convert to seconds
         this.computeReleaseVelocity(deltaPosition, deltaTime, true);
 
-        this.currentHandControllerPosition = handControllerPosition;
+        this.currentHandControllerTipPosition = handControllerPosition;
         this.currentObjectTime = now;
         Entities.callEntityMethod(this.grabbedEntity, "continueNearGrab");
     };
@@ -480,17 +527,14 @@ function MyController(hand, triggerAction) {
     };
 
     this.startTouch = function(entityID) {
-        // print('START TOUCH' + entityID);
         Entities.callEntityMethod(entityID, "startTouch");
     };
 
     this.continueTouch = function(entityID) {
-        // print('CONTINUE TOUCH' + entityID);
         Entities.callEntityMethod(entityID, "continueTouch");
     };
 
     this.stopTouch = function(entityID) {
-        // print('STOP TOUCH' + entityID);
         Entities.callEntityMethod(entityID, "stopTouch");
     };
 
@@ -514,8 +558,10 @@ function MyController(hand, triggerAction) {
     this.release = function() {
         this.lineOff();
 
-        if (this.grabbedEntity !== null && this.actionID !== null) {
-            Entities.deleteAction(this.grabbedEntity, this.actionID);
+        if (this.grabbedEntity !== null) {
+            if(this.actionID !== null) {
+              Entities.deleteAction(this.grabbedEntity, this.actionID);  
+            }
             Entities.callEntityMethod(this.grabbedEntity, "releaseGrab");
         }
 

examples/example/hmd/colorCube.fs

@@ -0,0 +1,10 @@
+
+float getProceduralColors(inout vec3 diffuse, inout vec3 specular, inout float shininess) {
+    
+    specular = _modelNormal.rgb;
+    if (any(lessThan(specular, vec3(0.0)))) {
+        specular = vec3(1.0) + specular;
+    }
+    diffuse = vec3(1.0, 1.0, 1.0);
+    return 1.0;
+}

examples/example/hmd/colorCube.js

@@ -0,0 +1,42 @@
+function avatarRelativePosition(position) {
+    return Vec3.sum(MyAvatar.position, Vec3.multiplyQbyV(MyAvatar.orientation, position));
+}
+
+ColorCube = function() {};
+ColorCube.prototype.NAME = "ColorCube";
+ColorCube.prototype.POSITION = { x: 0, y: 0.5, z: -0.5 }; 
+ColorCube.prototype.USER_DATA = { ProceduralEntity: {
+        version: 2, shaderUrl: Script.resolvePath("colorCube.fs"),
+} };
+
+// Clear any previous entities within 50 meters
+ColorCube.prototype.clear = function() {
+    var ids = Entities.findEntities(MyAvatar.position, 50);
+    var that = this;
+    ids.forEach(function(id) {
+        var properties = Entities.getEntityProperties(id);
+        if (properties.name == that.NAME) {
+            Entities.deleteEntity(id);
+        }
+    }, this);
+}
+
+ColorCube.prototype.create = function() {
+    var that = this;
+    var size = HMD.ipd;
+    var id = Entities.addEntity({
+        type: "Box",
+        position: avatarRelativePosition(that.POSITION),
+        name: that.NAME,
+        color: that.COLOR,
+        ignoreCollisions: true,
+        collisionsWillMove: false,
+        dimensions: { x: size, y: size, z: size },
+        lifetime: 3600,
+        userData: JSON.stringify(that.USER_DATA)
+    });
+}
+
+var colorCube = new ColorCube();
+colorCube.clear();
+colorCube.create();

interface/src/scripting/HMDScriptingInterface.cpp

@@ -10,7 +10,7 @@
 //
 
 #include "HMDScriptingInterface.h"
-
+#include "display-plugins/DisplayPlugin.h"
 #include <avatar/AvatarManager.h>
 
 HMDScriptingInterface& HMDScriptingInterface::getInstance() {
@@ -53,3 +53,7 @@ QScriptValue HMDScriptingInterface::getHUDLookAtPosition3D(QScriptContext* conte
     }
     return QScriptValue::NullValue;
 }
+
+float HMDScriptingInterface::getIPD() const {
+    return Application::getInstance()->getActiveDisplayPlugin()->getIPD();
+}

interface/src/scripting/HMDScriptingInterface.h

@@ -20,6 +20,7 @@ class HMDScriptingInterface : public QObject {
     Q_OBJECT
     Q_PROPERTY(bool magnifier READ getMagnifier)
     Q_PROPERTY(bool active READ isHMDMode)
+    Q_PROPERTY(float ipd READ getIPD)
 public:
     static HMDScriptingInterface& getInstance();
 
@@ -33,6 +34,7 @@ private:
     HMDScriptingInterface() {};
     bool getMagnifier() const { return Application::getInstance()->getApplicationCompositor().hasMagnifier(); };
     bool isHMDMode() const { return Application::getInstance()->isHMDMode(); }
+    float getIPD() const;
 
     bool getHUDLookAtPosition3D(glm::vec3& result) const;
 

libraries/avatars/src/AvatarData.cpp

@@ -989,8 +989,11 @@ void AvatarData::setFaceModelURL(const QUrl& faceModelURL) {
 }
 
 void AvatarData::setSkeletonModelURL(const QUrl& skeletonModelURL) {
-    _skeletonModelURL = skeletonModelURL.isEmpty() ? AvatarData::defaultFullAvatarModelUrl() : skeletonModelURL;
-
+    const QUrl& expanded = skeletonModelURL.isEmpty() ? AvatarData::defaultFullAvatarModelUrl() : skeletonModelURL;
+    if (expanded == _skeletonModelURL) {
+        return;
+    }
+    _skeletonModelURL = expanded;
     qCDebug(avatars) << "Changing skeleton model for avatar to" << _skeletonModelURL.toString();
 
     updateJointMappings();

libraries/display-plugins/src/display-plugins/DisplayPlugin.h

@@ -121,6 +121,8 @@ public:
         static const glm::mat4 pose; return pose;
     }
 
+    virtual float getIPD() const { return 0.0f; }
+
     virtual void abandonCalibration() {}
     virtual void resetSensors() {}
     virtual float devicePixelRatio() { return 1.0;  }

libraries/display-plugins/src/display-plugins/oculus/OculusBaseDisplayPlugin.cpp

@@ -149,3 +149,11 @@ void OculusBaseDisplayPlugin::deactivate() {
 void OculusBaseDisplayPlugin::display(GLuint finalTexture, const glm::uvec2& sceneSize) {
     ++_frameIndex;
 }
+
+float OculusBaseDisplayPlugin::getIPD() const {
+    float result = 0.0f;
+#if (OVR_MAJOR_VERSION >= 6)
+    result = ovr_GetFloat(_hmd, OVR_KEY_IPD, OVR_DEFAULT_IPD);
+#endif
+    return result;
+}

libraries/display-plugins/src/display-plugins/oculus/OculusBaseDisplayPlugin.h

@@ -31,6 +31,7 @@ public:
     virtual void resetSensors() override final;
     virtual glm::mat4 getEyePose(Eye eye) const override final;
     virtual glm::mat4 getHeadPose() const override final;
+    virtual float getIPD() const override final;
 
 protected:
     virtual void preRender() override final;

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -442,7 +442,7 @@ void DeferredLightingEffect::render(RenderArgs* args) {
 
                 deferredTransforms[i].projection = projMats[i];
 
-                auto sideViewMat =  eyeViews[i] * monoViewMat;
+                auto sideViewMat = monoViewMat * glm::inverse(eyeViews[i]);
                 viewTransforms[i].evalFromRawMatrix(sideViewMat);
                 deferredTransforms[i].viewInverse = sideViewMat;
 
@@ -574,10 +574,8 @@ void DeferredLightingEffect::render(RenderArgs* args) {
 
                 for (auto lightID : _pointLights) {
                     auto& light = _allocatedLights[lightID];
-                    // IN DEBUG:  light->setShowContour(true);
-                    if (_pointLightLocations->lightBufferUnit >= 0) {
-                        batch.setUniformBuffer(_pointLightLocations->lightBufferUnit, light->getSchemaBuffer());
-                    }
+                    // IN DEBUG: light->setShowContour(true);
+                    batch.setUniformBuffer(_pointLightLocations->lightBufferUnit, light->getSchemaBuffer());
 
                     float expandedRadius = light->getMaximumRadius() * (1.0f + SCALE_EXPANSION);
                     // TODO: We shouldn;t have to do that test and use a different volume geometry for when inside the vlight volume,
@@ -612,8 +610,7 @@ void DeferredLightingEffect::render(RenderArgs* args) {
 
                 for (auto lightID : _spotLights) {
                     auto light = _allocatedLights[lightID];
-                    // IN DEBUG:  light->setShowContour(true);
-
+                    // IN DEBUG: light->setShowContour(true);
                     batch.setUniformBuffer(_spotLightLocations->lightBufferUnit, light->getSchemaBuffer());
 
                     auto eyeLightPos = eyePoint - light->getPosition();

libraries/render-utils/src/simple.slf

@@ -17,6 +17,7 @@
 
 // the interpolated normal
 in vec3 _normal;
+in vec3 _modelNormal;
 in vec3 _color;
 in vec2 _texCoord0;
 in vec4 _position;

libraries/render-utils/src/simple.slv

@@ -22,6 +22,7 @@ uniform bool Instanced = false;
 // the interpolated normal
 
 out vec3 _normal;
+out vec3 _modelNormal;
 out vec3 _color;
 out vec2 _texCoord0;
 out vec4 _position;
@@ -30,6 +31,7 @@ void main(void) {
     _color = inColor.rgb;
     _texCoord0 = inTexCoord0.st;
     _position = inPosition;
+    _modelNormal = inNormal.xyz;
 
     // standard transform
     TransformCamera cam = getTransformCamera();