Merge branch 'master' of https://github.com/highfidelity/hifi into temp0

examples/headMove.js

@@ -41,11 +41,7 @@ var warpLine = Overlays.addOverlay("line3d", {
 
 var movingWithHead = false; 
 var headStartPosition, headStartDeltaPitch, headStartFinalPitch, headStartRoll, headStartYaw;
-var timeSinceLastTurn = 0.0;
-var timeSinceLastStep = 0.0;
-var isTurning = false; 
 var deltaYaw = 0.0;
-var turnAmount = 0.0;
 var keyDownTime = 0.0;
 var watchAvatar = false; 
 var oldMode; 
@@ -56,7 +52,6 @@ function saveCameraState() {
 }
 
 function restoreCameraState() {
-    //Camera.stopLooking();
     Camera.setMode(oldMode);
 }
 
@@ -67,8 +62,6 @@ function activateWarp() {
     updateWarp();
 }
 
-var WARP_PITCH_DEAD_ZONE = 4.0;
-var WARP_SENSITIVITY = 0.35;
 var TRIGGER_PULLBACK_DISTANCE = 0.04;
 var WATCH_AVATAR_DISTANCE = 1.5;
 var MAX_WARP_YAW = 40.0;
@@ -83,26 +76,32 @@ function playSound() {
     Audio.playSound(sound, options);
 }
 
+var WARP_SMOOTHING = 0.90;
+var WARP_START_TIME = 0.50;
+var WARP_START_DISTANCE = 1.0;
+var WARP_SENSITIVITY = 0.15;
+
 function updateWarp() {
     if (!warpActive) return;
 
     var look = Quat.getFront(Camera.getOrientation());
     var deltaPosition = Vec3.subtract(MyAvatar.getTrackedHeadPosition(), headStartPosition);
-    var deltaPitch = Math.abs(MyAvatar.getHeadFinalPitch() - headStartFinalPitch);
+    var deltaPitch = MyAvatar.getHeadFinalPitch() - headStartFinalPitch;
     deltaYaw = MyAvatar.getHeadFinalYaw() - headStartYaw;
 
-    willMove = (!watchAvatar && (Math.abs(deltaYaw) < MAX_WARP_YAW) && (deltaPitch > WARP_PITCH_DEAD_ZONE));
+    willMove = (!watchAvatar && (Math.abs(deltaYaw) < MAX_WARP_YAW) && (keyDownTime > WARP_START_TIME));
 
     if (willMove) {
-        var distance = Math.pow((deltaPitch - WARP_PITCH_DEAD_ZONE) * WARP_SENSITIVITY, 2.0);
+        //var distance = Math.pow((deltaPitch - WARP_PITCH_DEAD_ZONE) * WARP_SENSITIVITY, 2.0);
+        var distance = Math.exp(deltaPitch * WARP_SENSITIVITY) * WARP_START_DISTANCE;
         var warpDirection = Vec3.normalize({ x: look.x, y: 0, z: look.z });
-        warpPosition = Vec3.multiply(warpDirection, distance);
-        warpPosition = Vec3.sum(MyAvatar.position, warpPosition);
+        warpPosition = Vec3.mix(Vec3.sum(MyAvatar.position, Vec3.multiply(warpDirection, distance)), warpPosition, WARP_SMOOTHING);
     }
 
+    var height = MyAvatar.getEyePosition().y - MyAvatar.position.y;
+
     if (!watchAvatar && (Math.abs(deltaYaw) < MAX_PULLBACK_YAW) && (deltaPosition.z > TRIGGER_PULLBACK_DISTANCE)) {
         saveCameraState();
-        var height = MyAvatar.getEyePosition().y - MyAvatar.position.y;
         var cameraPosition = Vec3.subtract(MyAvatar.position, Vec3.multiplyQbyV(Camera.getOrientation(), { x: 0, y: -height, z: -height * WATCH_AVATAR_DISTANCE }));
         Camera.setPosition(cameraPosition);
         watchAvatar = true;
@@ -132,40 +131,15 @@ function finishWarp() {
     if (willMove) {
         MyAvatar.position = warpPosition;
         playSound();
-    } else if (!watchAvatar) {
-        isTurning = true;
-        turnAmount = deltaYaw;
-        timeSinceLastTurn = TURN_INTERVAL;
-        playSound();
     } 
 }
 
-var EPSILON_YAW = 180.0;
-var TURN_INTERVAL = 0.175; 
-
 function update(deltaTime) {
 
     if (movingWithHead) {
         keyDownTime += deltaTime;
         updateWarp();
     }
-
-    if (isTurning) {
-        timeSinceLastTurn += deltaTime; 
-        if (timeSinceLastTurn > TURN_INTERVAL) {
-            if (Math.abs(turnAmount) <= EPSILON_YAW) {
-                var thisTurn = turnAmount;
-                isTurning = false;
-            } else {
-                var thisTurn = turnAmount / 2.0;
-                turnAmount = turnAmount / 2.0;
-            }
-            var orientation = MyAvatar.orientation;
-            orientation = Quat.multiply(Quat.fromPitchYawRollDegrees(0, thisTurn, 0), orientation) ;
-            MyAvatar.orientation = orientation;
-            timeSinceLastTurn = 0.0;
-        }
-    }
 }
 
 Controller.keyPressEvent.connect(function(event) {
@@ -178,19 +152,25 @@ Controller.keyPressEvent.connect(function(event) {
         headStartRoll = MyAvatar.getHeadFinalRoll();
         headStartYaw = MyAvatar.getHeadFinalYaw();
         deltaYaw = 0.0;
+        warpPosition = MyAvatar.position;
         activateWarp();
     }
 });
 
-var TIME_FOR_TURNAROUND = 0.15;
+var TIME_FOR_TURN_AROUND = 0.50;
+var TIME_FOR_TURN = 0.25;
 var TURN_AROUND = 180.0;
 
 Controller.keyReleaseEvent.connect(function(event) {
     if (event.text == "SPACE") {
         movingWithHead = false;
-        isTurning = false;
-        if (keyDownTime < TIME_FOR_TURNAROUND) {
-            MyAvatar.orientation = Quat.multiply(Quat.fromPitchYawRollDegrees(0, TURN_AROUND, 0), MyAvatar.orientation);
+        if (keyDownTime < TIME_FOR_TURN_AROUND) {
+            if (keyDownTime < TIME_FOR_TURN) {
+                var currentYaw = MyAvatar.getHeadFinalYaw();
+                MyAvatar.orientation = Quat.multiply(Quat.fromPitchYawRollDegrees(0, currentYaw, 0), MyAvatar.orientation);
+            } else {
+                MyAvatar.orientation = Quat.multiply(Quat.fromPitchYawRollDegrees(0, TURN_AROUND, 0), MyAvatar.orientation);
+            }
             playSound();
         }
         finishWarp();

examples/libraries/entityCameraTool.js

@@ -97,11 +97,12 @@ EntityCameraTool = function() {
 
     that.focus = function(entityProperties) {
         var dim = entityProperties.dimensions;
+        dim = SelectionManager.worldDimensions;
         var size = Math.max(dim.x, Math.max(dim.y, dim.z));
 
         that.targetZoomDistance = Math.max(size * FOCUS_ZOOM_SCALE, FOCUS_MIN_ZOOM);
 
-        that.setFocalPoint(entityProperties.position);
+        that.setFocalPoint(SelectionManager.worldPosition);//entityProperties.position);
 
         that.updateCamera();
     }
@@ -184,7 +185,7 @@ EntityCameraTool = function() {
         // Scale based on current zoom level
         dZoom *= that.targetZoomDistance * ZOOM_SCALING;
 
-        that.targetZoomDistance = Math.max(Math.min(that.targetZoomDistance + dZoom, MAX_ZOOM_DISTANCE), MIN_ZOOM_DISTANCE);
+        that.targetZoomDistance = Math.max(that.targetZoomDistance + dZoom, MIN_ZOOM_DISTANCE);
 
         that.updateCamera();
     }

examples/newEditEntities.js

@@ -21,6 +21,7 @@ Script.include("libraries/progressDialog.js");
 
 Script.include("libraries/entitySelectionTool.js");
 var selectionDisplay = SelectionDisplay;
+var selectionManager = SelectionManager;
 
 Script.include("libraries/ModelImporter.js");
 var modelImporter = new ModelImporter();
@@ -34,6 +35,8 @@ var entityPropertyDialogBox = EntityPropertyDialogBox;
 Script.include("libraries/entityCameraTool.js");
 var entityCameraTool = new EntityCameraTool();
 
+selectionManager.setEventListener(selectionDisplay.updateHandles());
+
 var windowDimensions = Controller.getViewportDimensions();
 var toolIconUrl = HIFI_PUBLIC_BUCKET + "images/tools/";
 var toolHeight = 50;
@@ -440,6 +443,11 @@ function mousePressEvent(event) {
                 orientation = MyAvatar.orientation;
                 intersection = rayPlaneIntersection(pickRay, P, Quat.getFront(orientation));
 
+                if (!event.isShifted) {
+                    selectionManager.clearSelections();
+                }
+                selectionManager.addEntity(foundEntity);
+
                 print("Model selected selectedEntityID:" + selectedEntityID.id);
 
             }
@@ -641,14 +649,21 @@ Menu.menuItemEvent.connect(handeMenuEvent);
 
 Controller.keyReleaseEvent.connect(function (event) {
     // since sometimes our menu shortcut keys don't work, trap our menu items here also and fire the appropriate menu items
+    print(event.text);
     if (event.text == "`") {
         handeMenuEvent("Edit Properties...");
     }
     if (event.text == "BACKSPACE") {
         handeMenuEvent("Delete");
+    } else if (event.text == "TAB") {
+        selectionDisplay.toggleSpaceMode();
+    } else if (event.text == "ESC") {
+        selectionDisplay.cancelTool();
     } else if (event.text == "f") {
         if (entitySelected) {
-            entityCameraTool.focus(selectedEntityProperties);
+            // Get latest properties
+            var properties = Entities.getEntityProperties(selectedEntityID);
+            entityCameraTool.focus(properties);
         }
     }
 });

interface/src/ui/overlays/Base3DOverlay.h

@@ -26,6 +26,7 @@ public:
     ~Base3DOverlay();
 
     // getters
+    virtual bool is3D() const { return true; }
     const glm::vec3& getPosition() const { return _position; }
     const glm::vec3& getCenter() const { return _position; } // TODO: consider implementing registration points in this class
     float getLineWidth() const { return _lineWidth; }

interface/src/ui/overlays/Overlay.h

@@ -40,6 +40,7 @@ public:
     virtual void render() = 0;
 
     // getters
+    virtual bool is3D() const = 0;
     bool isLoaded() { return _isLoaded; }
     bool getVisible() const { return _visible; }
     xColor getColor();

interface/src/ui/overlays/Overlay2D.h

@@ -29,6 +29,8 @@ class Overlay2D : public Overlay {
 public:
     Overlay2D();
     ~Overlay2D();
+    
+    virtual bool is3D() const { return false; }
 
     // getters
     int getX() const { return _bounds.x(); }

interface/src/ui/overlays/Overlays.cpp

@@ -23,6 +23,7 @@
 #include "Rectangle3DOverlay.h"
 #include "Sphere3DOverlay.h"
 #include "TextOverlay.h"
+#include "Text3DOverlay.h"
 
 Overlays::Overlays() : _nextOverlayID(1) {
 }
@@ -131,6 +132,8 @@ unsigned int Overlays::addOverlay(const QString& type, const QScriptValue& prope
         thisOverlay = new ImageOverlay();
     } else if (type == "text") {
         thisOverlay = new TextOverlay();
+    } else if (type == "text3d") {
+        thisOverlay = new Text3DOverlay();
     } else if (type == "cube") {
         thisOverlay = new Cube3DOverlay();
     } else if (type == "sphere") {
@@ -167,8 +170,7 @@ unsigned int Overlays::addOverlay(Overlay* overlay) {
     QWriteLocker lock(&_lock);
     unsigned int thisID = _nextOverlayID;
     _nextOverlayID++;
-    bool is3D = typeid(*overlay) != typeid(ImageOverlay) && typeid(*overlay) != typeid(TextOverlay);
-    if (is3D) {
+    if (overlay->is3D()) {
         _overlays3D[thisID] = overlay;
     } else {
         _overlays2D[thisID] = overlay;

interface/src/ui/overlays/Text3DOverlay.cpp

@@ -0,0 +1,182 @@
+//
+//  Text3DOverlay.cpp
+//  interface/src/ui/overlays
+//
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include "Application.h"
+#include "Text3DOverlay.h"
+#include "ui/TextRenderer.h"
+
+const xColor DEFAULT_BACKGROUND_COLOR = { 0, 0, 0 };
+const float DEFAULT_MARGIN = 0.1f;
+
+Text3DOverlay::Text3DOverlay() :
+    _backgroundColor(DEFAULT_BACKGROUND_COLOR),
+    _lineHeight(0.1f),
+    _leftMargin(DEFAULT_MARGIN),
+    _topMargin(DEFAULT_MARGIN),
+    _rightMargin(DEFAULT_MARGIN),
+    _bottomMargin(DEFAULT_MARGIN),
+    _isFacingAvatar(false)
+{
+}
+
+Text3DOverlay::~Text3DOverlay() {
+}
+
+xColor Text3DOverlay::getBackgroundColor() {
+    if (_colorPulse == 0.0f) {
+        return _backgroundColor; 
+    }
+
+    float pulseLevel = updatePulse();
+    xColor result = _backgroundColor;
+    if (_colorPulse < 0.0f) {
+        result.red *= (1.0f - pulseLevel);
+        result.green *= (1.0f - pulseLevel);
+        result.blue *= (1.0f - pulseLevel);
+    } else {
+        result.red *= pulseLevel;
+        result.green *= pulseLevel;
+        result.blue *= pulseLevel;
+    }
+    return result;
+}
+
+
+void Text3DOverlay::render() {
+    if (!_visible) {
+        return; // do nothing if we're not visible
+    }
+
+    glPushMatrix(); {
+        glTranslatef(_position.x, _position.y, _position.z);
+        glm::quat rotation;
+        if (_isFacingAvatar) {
+            // rotate about vertical to face the camera
+            rotation = Application::getInstance()->getCamera()->getRotation();
+            rotation *= glm::angleAxis(glm::pi<float>(), glm::vec3(0.0f, 1.0f, 0.0f));
+        } else {
+            rotation = getRotation();
+        }
+        glm::vec3 axis = glm::axis(rotation);
+        glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
+
+        const float MAX_COLOR = 255.0f;
+        xColor backgroundColor = getBackgroundColor();
+        float alpha = getAlpha();
+        glColor4f(backgroundColor.red / MAX_COLOR, backgroundColor.green / MAX_COLOR, backgroundColor.blue / MAX_COLOR, alpha);
+
+        glm::vec2 dimensions = getDimensions();
+        glm::vec2 halfDimensions = dimensions * 0.5f;
+        
+        const float SLIGHTLY_BEHIND = -0.005f;
+
+        glBegin(GL_QUADS);
+            glVertex3f(-halfDimensions.x, -halfDimensions.y, SLIGHTLY_BEHIND);
+            glVertex3f(halfDimensions.x, -halfDimensions.y, SLIGHTLY_BEHIND);
+            glVertex3f(halfDimensions.x, halfDimensions.y, SLIGHTLY_BEHIND);
+            glVertex3f(-halfDimensions.x, halfDimensions.y, SLIGHTLY_BEHIND);
+        glEnd();
+        
+        const int FIXED_FONT_POINT_SIZE = 40;
+        const int FIXED_FONT_SCALING_RATIO = FIXED_FONT_POINT_SIZE * 40.0f; // this is a ratio determined through experimentation
+        
+        TextRenderer* textRenderer = TextRenderer::getInstance(SANS_FONT_FAMILY, FIXED_FONT_POINT_SIZE);
+        float LINE_SCALE_RATIO = 1.2f;
+        float maxHeight = (float)textRenderer->calculateHeight("Xy") * LINE_SCALE_RATIO;
+        
+        float scaleFactor =  (maxHeight / FIXED_FONT_SCALING_RATIO) * _lineHeight; 
+
+        glTranslatef(-(halfDimensions.x - _leftMargin), halfDimensions.y - _topMargin, 0.0f);
+
+        glm::vec2 clipMinimum(0.0f, 0.0f);
+        glm::vec2 clipDimensions((dimensions.x - (_leftMargin + _rightMargin)) / scaleFactor, 
+                                 (dimensions.y - (_topMargin + _bottomMargin)) / scaleFactor);
+
+        glScalef(scaleFactor, -scaleFactor, 1.0);
+        enableClipPlane(GL_CLIP_PLANE0, -1.0f, 0.0f, 0.0f, clipMinimum.x + clipDimensions.x);
+        enableClipPlane(GL_CLIP_PLANE1, 1.0f, 0.0f, 0.0f, -clipMinimum.x);
+        enableClipPlane(GL_CLIP_PLANE2, 0.0f, -1.0f, 0.0f, clipMinimum.y + clipDimensions.y);
+        enableClipPlane(GL_CLIP_PLANE3, 0.0f, 1.0f, 0.0f, -clipMinimum.y);
+    
+        glColor3f(_color.red / MAX_COLOR, _color.green / MAX_COLOR, _color.blue / MAX_COLOR);
+        QStringList lines = _text.split("\n");
+        int lineOffset = maxHeight;
+        foreach(QString thisLine, lines) {
+            textRenderer->draw(0, lineOffset, qPrintable(thisLine));
+            lineOffset += maxHeight;
+        }
+
+        glDisable(GL_CLIP_PLANE0);
+        glDisable(GL_CLIP_PLANE1);
+        glDisable(GL_CLIP_PLANE2);
+        glDisable(GL_CLIP_PLANE3);
+        
+    } glPopMatrix();
+    
+}
+
+void Text3DOverlay::enableClipPlane(GLenum plane, float x, float y, float z, float w) {
+    GLdouble coefficients[] = { x, y, z, w };
+    glClipPlane(plane, coefficients);
+    glEnable(plane);
+}
+
+void Text3DOverlay::setProperties(const QScriptValue& properties) {
+    Planar3DOverlay::setProperties(properties);
+    
+    QScriptValue text = properties.property("text");
+    if (text.isValid()) {
+        setText(text.toVariant().toString());
+    }
+
+    QScriptValue backgroundColor = properties.property("backgroundColor");
+    if (backgroundColor.isValid()) {
+        QScriptValue red = backgroundColor.property("red");
+        QScriptValue green = backgroundColor.property("green");
+        QScriptValue blue = backgroundColor.property("blue");
+        if (red.isValid() && green.isValid() && blue.isValid()) {
+            _backgroundColor.red = red.toVariant().toInt();
+            _backgroundColor.green = green.toVariant().toInt();
+            _backgroundColor.blue = blue.toVariant().toInt();
+        }
+    }
+
+    if (properties.property("lineHeight").isValid()) {
+        setLineHeight(properties.property("lineHeight").toVariant().toFloat());
+    }
+
+    if (properties.property("leftMargin").isValid()) {
+        setLeftMargin(properties.property("leftMargin").toVariant().toFloat());
+    }
+
+    if (properties.property("topMargin").isValid()) {
+        setTopMargin(properties.property("topMargin").toVariant().toFloat());
+    }
+
+    if (properties.property("rightMargin").isValid()) {
+        setRightMargin(properties.property("rightMargin").toVariant().toFloat());
+    }
+
+    if (properties.property("bottomMargin").isValid()) {
+        setBottomMargin(properties.property("bottomMargin").toVariant().toFloat());
+    }
+
+
+    QScriptValue isFacingAvatarValue = properties.property("isFacingAvatar");
+    if (isFacingAvatarValue.isValid()) {
+        _isFacingAvatar = isFacingAvatarValue.toVariant().toBool();
+    }
+
+}
+
+

interface/src/ui/overlays/Text3DOverlay.h

@@ -0,0 +1,61 @@
+//
+//  Text3DOverlay.h
+//  interface/src/ui/overlays
+//
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_Text3DOverlay_h
+#define hifi_Text3DOverlay_h
+
+// include this before QGLWidget, which includes an earlier version of OpenGL
+#include "InterfaceConfig.h"
+
+#include <QString>
+#include "Planar3DOverlay.h"
+
+class Text3DOverlay : public Planar3DOverlay {
+    Q_OBJECT
+    
+public:
+    Text3DOverlay();
+    ~Text3DOverlay();
+    virtual void render();
+
+    // getters
+    const QString& getText() const { return _text; }
+    float getLineHeight() const { return _lineHeight; }
+    float getLeftMargin() const { return _leftMargin; }
+    float getTopMargin() const { return _topMargin; }
+    float getRightMargin() const { return _rightMargin; }
+    float getBottomMargin() const { return _bottomMargin; }
+    xColor getBackgroundColor();
+
+    // setters
+    void setText(const QString& text) { _text = text; }
+    void setLineHeight(float value) { _lineHeight = value; }
+    void setLeftMargin(float margin) { _leftMargin = margin; }
+    void setTopMargin(float margin) { _topMargin = margin; }
+    void setRightMargin(float margin) { _rightMargin = margin; }
+    void setBottomMargin(float margin) { _bottomMargin = margin; }
+
+    virtual void setProperties(const QScriptValue& properties);
+
+private:
+    void enableClipPlane(GLenum plane, float x, float y, float z, float w);
+
+    QString _text;
+    xColor _backgroundColor;
+    float _lineHeight;
+    float _leftMargin;
+    float _topMargin;
+    float _rightMargin;
+    float _bottomMargin;
+    bool _isFacingAvatar;
+};
+
+ 
+#endif // hifi_Text3DOverlay_h

libraries/script-engine/src/Vec3.cpp

@@ -58,6 +58,10 @@ glm::vec3 Vec3::normalize(const glm::vec3& v) {
     return glm::normalize(v);
 }
 
+glm::vec3 Vec3::mix(const glm::vec3& v1, const glm::vec3& v2, float m) {
+    return glm::mix(v1, v2, m);
+}
+
 void Vec3::print(const QString& lable, const glm::vec3& v) {
     qDebug() << qPrintable(lable) << v.x << "," << v.y << "," << v.z;
 }

libraries/script-engine/src/Vec3.h

@@ -36,6 +36,7 @@ public slots:
     float distance(const glm::vec3& v1, const glm::vec3& v2);
     float orientedAngle(const glm::vec3& v1, const glm::vec3& v2, const glm::vec3& v3);
     glm::vec3 normalize(const glm::vec3& v);
+    glm::vec3 mix(const glm::vec3& v1, const glm::vec3& v2, float m);
     void print(const QString& lable, const glm::vec3& v);
     bool equal(const glm::vec3& v1, const glm::vec3& v2);
 };