Merge branch 'master' of github.com:highfidelity/hifi into fix-grabbing-problem

assignment-client/src/Agent.cpp

@@ -344,8 +344,6 @@ void Agent::scriptRequestFinished() {
 void Agent::executeScript() {
     _scriptEngine = scriptEngineFactory(ScriptEngine::AGENT_SCRIPT, _scriptContents, _payload);
 
-    DependencyManager::get<RecordingScriptingInterface>()->setScriptEngine(_scriptEngine);
-
     // setup an Avatar for the script to use
     auto scriptedAvatar = DependencyManager::get<ScriptableAvatar>();
 

interface/src/Application.cpp

@@ -4844,12 +4844,6 @@ void Application::loadSettings() {
 
         isFirstPerson = (qApp->isHMDMode());
 
-        // Flying should be disabled by default in HMD mode on first run, and it
-        // should be enabled by default in desktop mode.
-
-        auto myAvatar = getMyAvatar();
-        myAvatar->setFlyingEnabled(!isFirstPerson);
-
     } else {
         // if this is not the first run, the camera will be initialized differently depending on user settings
 
@@ -6201,6 +6195,9 @@ PickRay Application::computePickRay(float x, float y) const {
         getApplicationCompositor().computeHmdPickRay(pickPoint, result.origin, result.direction);
     } else {
         pickPoint /= getCanvasSize();
+        if (_myCamera.getMode() == CameraMode::CAMERA_MODE_MIRROR) {
+            pickPoint.x = 1.0f - pickPoint.x;
+        }
         QMutexLocker viewLocker(&_viewMutex);
         _viewFrustum.computePickRay(pickPoint.x, pickPoint.y, result.origin, result.direction);
     }
@@ -6536,9 +6533,6 @@ void Application::registerScriptEngineWithApplicationServices(ScriptEnginePointe
     entityScriptingInterface->setPacketSender(&_entityEditSender);
     entityScriptingInterface->setEntityTree(getEntities()->getTree());
 
-    // give the script engine to the RecordingScriptingInterface for its callbacks
-    DependencyManager::get<RecordingScriptingInterface>()->setScriptEngine(scriptEngine);
-
     if (property(hifi::properties::TEST).isValid()) {
         scriptEngine->registerGlobalObject("Test", TestScriptingInterface::getInstance());
     }

interface/src/avatar/MyAvatar.cpp

@@ -577,9 +577,11 @@ void MyAvatar::updateChildCauterization(SpatiallyNestablePointer object, bool ca
 
 void MyAvatar::simulate(float deltaTime) {
     PerformanceTimer perfTimer("simulate");
-
+    
     animateScaleChanges(deltaTime);
 
+    setFlyingEnabled(getFlyingEnabled());
+
     if (_cauterizationNeedsUpdate) {
         _cauterizationNeedsUpdate = false;
 
@@ -724,16 +726,18 @@ void MyAvatar::simulate(float deltaTime) {
                         properties.setQueryAACubeDirty();
                         properties.setLastEdited(now);
 
-                        packetSender->queueEditEntityMessage(PacketType::EntityEdit, entityTree, entity->getID(), properties);
+                        packetSender->queueEditEntityMessage(PacketType::EntityEdit, entityTree,
+                                                             entity->getID(), properties);
                         entity->setLastBroadcast(usecTimestampNow());
 
                         entity->forEachDescendant([&](SpatiallyNestablePointer descendant) {
-                            EntityItemPointer entityDescendant = std::static_pointer_cast<EntityItem>(descendant);
+                            EntityItemPointer entityDescendant = std::dynamic_pointer_cast<EntityItem>(descendant);
-                            if (!entityDescendant->getClientOnly() && descendant->updateQueryAACube()) {
+                            if (entityDescendant && !entityDescendant->getClientOnly() && descendant->updateQueryAACube()) {
                                 EntityItemProperties descendantProperties;
                                 descendantProperties.setQueryAACube(descendant->getQueryAACube());
                                 descendantProperties.setLastEdited(now);
-                                packetSender->queueEditEntityMessage(PacketType::EntityEdit, entityTree, entityDescendant->getID(), descendantProperties);
+                                packetSender->queueEditEntityMessage(PacketType::EntityEdit, entityTree,
+                                                                     entityDescendant->getID(), descendantProperties);
                                 entityDescendant->setLastBroadcast(now); // for debug/physics status icons
                             }
                         });
@@ -1131,6 +1135,8 @@ void MyAvatar::saveData() {
     settings.setValue("collisionSoundURL", _collisionSoundURL);
     settings.setValue("useSnapTurn", _useSnapTurn);
     settings.setValue("userHeight", getUserHeight());
+    settings.setValue("flyingDesktop", getFlyingDesktopPref());
+    settings.setValue("flyingHMD", getFlyingHMDPref());
     settings.setValue("enabledFlying", getFlyingEnabled());
 
     settings.endGroup();
@@ -1281,8 +1287,13 @@ void MyAvatar::loadData() {
         settings.remove("avatarEntityData");
     }
     setAvatarEntityDataChanged(true);
+
+    // Flying preferences must be loaded before calling setFlyingEnabled()
     Setting::Handle<bool> firstRunVal { Settings::firstRun, true };
-    setFlyingEnabled(firstRunVal.get() ? getFlyingEnabled() : settings.value("enabledFlying").toBool());
+    setFlyingDesktopPref(firstRunVal.get() ? true : settings.value("flyingDesktop").toBool());
+    setFlyingHMDPref(firstRunVal.get() ? false : settings.value("flyingHMD").toBool());
+    setFlyingEnabled(getFlyingEnabled());
+
     setDisplayName(settings.value("displayName").toString());
     setCollisionSoundURL(settings.value("collisionSoundURL", DEFAULT_AVATAR_COLLISION_SOUND_URL).toString());
     setSnapTurn(settings.value("useSnapTurn", _useSnapTurn).toBool());
@@ -2825,6 +2836,12 @@ void MyAvatar::setFlyingEnabled(bool enabled) {
         return;
     }
 
+    if (qApp->isHMDMode()) {
+        setFlyingHMDPref(enabled);
+    } else {
+        setFlyingDesktopPref(enabled);
+    }
+
     _enableFlying = enabled;
 }
 
@@ -2840,7 +2857,33 @@ bool MyAvatar::isInAir() {
 
 bool MyAvatar::getFlyingEnabled() {
     // May return true even if client is not allowed to fly in the zone.
-    return _enableFlying;
+    return (qApp->isHMDMode() ? getFlyingHMDPref() : getFlyingDesktopPref());
+}
+
+void MyAvatar::setFlyingDesktopPref(bool enabled) {
+    if (QThread::currentThread() != thread()) {
+        QMetaObject::invokeMethod(this, "setFlyingDesktopPref", Q_ARG(bool, enabled));
+        return;
+    }
+
+    _flyingPrefDesktop = enabled;
+}
+
+bool MyAvatar::getFlyingDesktopPref() {
+    return _flyingPrefDesktop;
+}
+
+void MyAvatar::setFlyingHMDPref(bool enabled) {
+    if (QThread::currentThread() != thread()) {
+        QMetaObject::invokeMethod(this, "setFlyingHMDPref", Q_ARG(bool, enabled));
+        return;
+    }
+
+    _flyingPrefHMD = enabled;
+}
+
+bool MyAvatar::getFlyingHMDPref() {
+    return _flyingPrefHMD;
 }
 
 // Public interface for targetscale
@@ -3042,7 +3085,7 @@ static glm::vec3 dampenCgMovement(glm::vec3 cgUnderHeadHandsAvatarSpace, float b
 }
 
 // computeCounterBalance returns the center of gravity in Avatar space
-glm::vec3 MyAvatar::computeCounterBalance() const {
+glm::vec3 MyAvatar::computeCounterBalance() {
     struct JointMass {
         QString name;
         float weight;
@@ -3060,7 +3103,8 @@ glm::vec3 MyAvatar::computeCounterBalance() const {
     JointMass cgLeftHandMass(QString("LeftHand"), DEFAULT_AVATAR_LEFTHAND_MASS, glm::vec3(0.0f, 0.0f, 0.0f));
     JointMass cgRightHandMass(QString("RightHand"), DEFAULT_AVATAR_RIGHTHAND_MASS, glm::vec3(0.0f, 0.0f, 0.0f));
     glm::vec3 tposeHead = DEFAULT_AVATAR_HEAD_POS;
-    glm::vec3 tposeHips = glm::vec3(0.0f, 0.0f, 0.0f);
+    glm::vec3 tposeHips = DEFAULT_AVATAR_HIPS_POS;
+    glm::vec3 tposeRightFoot = DEFAULT_AVATAR_RIGHTFOOT_POS;
 
     if (_skeletonModel->getRig().indexOfJoint(cgHeadMass.name) != -1) {
         cgHeadMass.position = getAbsoluteJointTranslationInObjectFrame(_skeletonModel->getRig().indexOfJoint(cgHeadMass.name));
@@ -3079,6 +3123,9 @@ glm::vec3 MyAvatar::computeCounterBalance() const {
     if (_skeletonModel->getRig().indexOfJoint("Hips") != -1) {
         tposeHips = getAbsoluteDefaultJointTranslationInObjectFrame(_skeletonModel->getRig().indexOfJoint("Hips"));
     }
+    if (_skeletonModel->getRig().indexOfJoint("RightFoot") != -1) {
+        tposeRightFoot = getAbsoluteDefaultJointTranslationInObjectFrame(_skeletonModel->getRig().indexOfJoint("RightFoot"));
+    }
 
     // find the current center of gravity position based on head and hand moments
     glm::vec3 sumOfMoments = (cgHeadMass.weight * cgHeadMass.position) + (cgLeftHandMass.weight * cgLeftHandMass.position) + (cgRightHandMass.weight * cgRightHandMass.position);
@@ -3099,9 +3146,12 @@ glm::vec3 MyAvatar::computeCounterBalance() const {
     glm::vec3 counterBalancedCg = (1.0f / DEFAULT_AVATAR_HIPS_MASS) * counterBalancedForHead;
 
     // find the height of the hips
+    const float UPPER_LEG_FRACTION = 0.3333f;
     glm::vec3 xzDiff((cgHeadMass.position.x - counterBalancedCg.x), 0.0f, (cgHeadMass.position.z - counterBalancedCg.z));
     float headMinusHipXz = glm::length(xzDiff);
     float headHipDefault = glm::length(tposeHead - tposeHips);
+    float hipFootDefault = tposeHips.y - tposeRightFoot.y;
+    float sitSquatThreshold = tposeHips.y - (UPPER_LEG_FRACTION * hipFootDefault);
     float hipHeight = 0.0f;
     if (headHipDefault > headMinusHipXz) {
         hipHeight = sqrtf((headHipDefault * headHipDefault) - (headMinusHipXz * headMinusHipXz));
@@ -3113,6 +3163,10 @@ glm::vec3 MyAvatar::computeCounterBalance() const {
     if (counterBalancedCg.y > (tposeHips.y + 0.05f)) {
         // if the height is higher than default hips, clamp to default hips
         counterBalancedCg.y = tposeHips.y + 0.05f;
+    } else if (counterBalancedCg.y < sitSquatThreshold) {
+        //do a height reset
+        setResetMode(true);
+        _follow.activate(FollowHelper::Vertical);
     }
     return counterBalancedCg;
 }
@@ -3162,7 +3216,7 @@ static void drawBaseOfSupport(float baseOfSupportScale, float footLocal, glm::ma
 // this function finds the hips position using a center of gravity model that
 // balances the head and hands with the hips over the base of support
 // returns the rotation (-z forward) and position of the Avatar in Sensor space
-glm::mat4 MyAvatar::deriveBodyUsingCgModel() const {
+glm::mat4 MyAvatar::deriveBodyUsingCgModel() {
     glm::mat4 sensorToWorldMat = getSensorToWorldMatrix();
     glm::mat4 worldToSensorMat = glm::inverse(sensorToWorldMat);
     auto headPose = getControllerPoseInSensorFrame(controller::Action::HEAD);
@@ -3180,7 +3234,7 @@ glm::mat4 MyAvatar::deriveBodyUsingCgModel() const {
     }
 
     // get the new center of gravity
-    const glm::vec3 cgHipsPosition = computeCounterBalance();
+    glm::vec3 cgHipsPosition = computeCounterBalance();
 
     // find the new hips rotation using the new head-hips axis as the up axis
     glm::mat4 avatarHipsMat = computeNewHipsMatrix(glmExtractRotation(avatarHeadMat), extractTranslation(avatarHeadMat), cgHipsPosition);

interface/src/avatar/MyAvatar.h

@@ -955,6 +955,30 @@ public:
      */
     Q_INVOKABLE bool getFlyingEnabled();
 
+    /**jsdoc
+     * @function MyAvatar.setFlyingDesktopPref
+     * @param {boolean} enabled
+     */
+    Q_INVOKABLE void setFlyingDesktopPref(bool enabled);
+
+    /**jsdoc
+     * @function MyAvatar.getFlyingDesktopPref
+     * @returns {boolean}
+     */
+    Q_INVOKABLE bool getFlyingDesktopPref();
+
+    /**jsdoc
+     * @function MyAvatar.setFlyingDesktopPref
+     * @param {boolean} enabled
+     */
+    Q_INVOKABLE void setFlyingHMDPref(bool enabled);
+
+    /**jsdoc
+     * @function MyAvatar.getFlyingDesktopPref
+     * @returns {boolean}
+     */
+    Q_INVOKABLE bool getFlyingHMDPref();
+
 
     /**jsdoc
      * @function MyAvatar.getAvatarScale
@@ -1019,12 +1043,12 @@ public:
     // results are in sensor frame (-z forward)
     glm::mat4 deriveBodyFromHMDSensor() const;
 
-    glm::vec3 computeCounterBalance() const;
+    glm::vec3 computeCounterBalance();
 
     // derive avatar body position and orientation from using the current HMD Sensor location in relation to the previous
     // location of the base of support of the avatar.
     // results are in sensor frame (-z foward)
-    glm::mat4 deriveBodyUsingCgModel() const;
+    glm::mat4 deriveBodyUsingCgModel();
 
     /**jsdoc
      * @function MyAvatar.isUp
@@ -1505,6 +1529,8 @@ private:
     std::bitset<MAX_DRIVE_KEYS> _disabledDriveKeys;
 
     bool _enableFlying { false };
+    bool _flyingPrefDesktop { true };
+    bool _flyingPrefHMD { false };
     bool _wasPushing { false };
     bool _isPushing { false };
     bool _isBeingPushed { false };

interface/src/ui/PreferencesDialog.cpp

@@ -313,8 +313,8 @@ void setupPreferences() {
                                                        getter, setter));
     }
     {
-        auto getter = [=]()->bool { return myAvatar->getFlyingEnabled(); };
+        auto getter = [=]()->bool { return myAvatar->getFlyingHMDPref(); };
-        auto setter = [=](bool value) { myAvatar->setFlyingEnabled(value); };
+        auto setter = [=](bool value) { myAvatar->setFlyingHMDPref(value); };
         preferences->addPreference(new CheckPreference(VR_MOVEMENT, "Flying & jumping", getter, setter));
     }
     {

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -699,14 +699,6 @@ void RenderableModelEntityItem::computeShapeInfo(ShapeInfo& shapeInfo) {
     adjustShapeInfoByRegistration(shapeInfo);
 }
 
-void RenderableModelEntityItem::setCollisionShape(const btCollisionShape* shape) {
-    const void* key = static_cast<const void*>(shape);
-    if (_collisionMeshKey != key) {
-        _collisionMeshKey = key;
-        emit requestCollisionGeometryUpdate();
-    }
-}
-
 void RenderableModelEntityItem::setJointMap(std::vector<int> jointMap) {
     if (jointMap.size() > 0) {
         _jointMap = jointMap;
@@ -1278,10 +1270,6 @@ bool ModelEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPoin
     return false;
 }
 
-void ModelEntityRenderer::setCollisionMeshKey(const void*key) {
-    _collisionMeshKey = key;
-}
-
 void ModelEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) {
     DETAILED_PROFILE_RANGE(simulation_physics, __FUNCTION__);
     if (_hasModel != entity->hasModel()) {

libraries/entities-renderer/src/RenderableModelEntityItem.h

@@ -78,8 +78,6 @@ public:
     virtual bool isReadyToComputeShape() const override;
     virtual void computeShapeInfo(ShapeInfo& shapeInfo) override;
 
-    void setCollisionShape(const btCollisionShape* shape) override;
-
     virtual bool contains(const glm::vec3& point) const override;
     void stopModelOverrideIfNoParent();
 
@@ -112,10 +110,6 @@ public:
     virtual QStringList getJointNames() const override;
 
     bool getMeshes(MeshProxyList& result) override; // deprecated
-    const void* getCollisionMeshKey() const { return _collisionMeshKey; }
-
-signals:
-    void requestCollisionGeometryUpdate();
 
 private:
     bool needsUpdateModelBounds() const;
@@ -130,7 +124,6 @@ private:
     QVariantMap _originalTextures;
     bool _dimensionsInitialized { true };
     bool _needsJointSimulation { false };
-    const void* _collisionMeshKey { nullptr };
 };
 
 namespace render { namespace entities { 
@@ -161,7 +154,6 @@ protected:
     virtual bool needsRenderUpdate() const override;
     virtual void doRender(RenderArgs* args) override;
     virtual void doRenderUpdateSynchronousTyped(const ScenePointer& scene, Transaction& transaction, const TypedEntityPointer& entity) override;
-    void setCollisionMeshKey(const void* key);
 
     render::hifi::Tag getTagMask() const override;
 

libraries/entities/src/EntityItem.h

@@ -378,8 +378,6 @@ public:
     /// return preferred shape type (actual physical shape may differ)
     virtual ShapeType getShapeType() const { return SHAPE_TYPE_NONE; }
 
-    virtual void setCollisionShape(const btCollisionShape* shape) {}
-
     void setPosition(const glm::vec3& value);
     virtual void setParentID(const QUuid& parentID) override;
     virtual void setShapeType(ShapeType type) { /* do nothing */ }

libraries/physics/src/CollisionRenderMeshCache.cpp

@@ -1,217 +0,0 @@
-//
-//  CollisionRenderMeshCache.cpp
-//  libraries/physics/src
-//
-//  Created by Andrew Meadows 2016.07.13
-//  Copyright 2016 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 "CollisionRenderMeshCache.h"
-
-#include <cassert>
-
-#include <btBulletDynamicsCommon.h>
-#include <BulletCollision/CollisionShapes/btShapeHull.h>
-
-#include <ShapeInfo.h> // for MAX_HULL_POINTS
-
-const int32_t MAX_HULL_INDICES = 6 * MAX_HULL_POINTS;
-const int32_t MAX_HULL_NORMALS = MAX_HULL_INDICES;
-float tempVertices[MAX_HULL_NORMALS];
-graphics::Index tempIndexBuffer[MAX_HULL_INDICES];
-
-bool copyShapeToMesh(const btTransform& transform, const btConvexShape* shape,
-        gpu::BufferView& vertices, gpu::BufferView& indices, gpu::BufferView& parts,
-        gpu::BufferView& normals) {
-    assert(shape);
-
-    btShapeHull hull(shape);
-    if (!hull.buildHull(shape->getMargin())) {
-        return false;
-    }
-
-    int32_t numHullIndices = hull.numIndices();
-    assert(numHullIndices <= MAX_HULL_INDICES);
-
-    int32_t numHullVertices = hull.numVertices();
-    assert(numHullVertices <= MAX_HULL_POINTS);
-
-    { // new part
-        graphics::Mesh::Part part;
-        part._startIndex = (graphics::Index)indices.getNumElements();
-        part._numIndices = (graphics::Index)numHullIndices;
-        // FIXME: the render code cannot handle the case where part._baseVertex != 0
-        //part._baseVertex = vertices.getNumElements(); // DOES NOT WORK
-        part._baseVertex = 0;
-
-        gpu::BufferView::Size numBytes = sizeof(graphics::Mesh::Part);
-        const gpu::Byte* data = reinterpret_cast<const gpu::Byte*>(&part);
-        parts._buffer->append(numBytes, data);
-        parts._size = parts._buffer->getSize();
-    }
-
-    const int32_t SIZE_OF_VEC3 = 3 * sizeof(float);
-    graphics::Index indexOffset = (graphics::Index)vertices.getNumElements();
-
-    { // new indices
-        const uint32_t* hullIndices = hull.getIndexPointer();
-        // FIXME: the render code cannot handle the case where part._baseVertex != 0
-        // so we must add an offset to each index
-        for (int32_t i = 0; i < numHullIndices; ++i) {
-            tempIndexBuffer[i] = hullIndices[i] + indexOffset;
-        }
-        const gpu::Byte* data = reinterpret_cast<const gpu::Byte*>(tempIndexBuffer);
-        gpu::BufferView::Size numBytes = (gpu::BufferView::Size)(sizeof(graphics::Index) * numHullIndices);
-        indices._buffer->append(numBytes, data);
-        indices._size = indices._buffer->getSize();
-    }
-    { // new vertices
-        const btVector3* hullVertices = hull.getVertexPointer();
-        assert(numHullVertices <= MAX_HULL_POINTS);
-        for (int32_t i = 0; i < numHullVertices; ++i) {
-            btVector3 transformedPoint = transform * hullVertices[i];
-            memcpy(tempVertices + 3 * i, transformedPoint.m_floats, SIZE_OF_VEC3);
-        }
-        gpu::BufferView::Size numBytes = sizeof(float) * (3 * numHullVertices);
-        const gpu::Byte* data = reinterpret_cast<const gpu::Byte*>(tempVertices);
-        vertices._buffer->append(numBytes, data);
-        vertices._size = vertices._buffer->getSize();
-    }
-    { // new normals
-        // compute average point
-        btVector3 avgVertex(0.0f, 0.0f, 0.0f);
-        const btVector3* hullVertices = hull.getVertexPointer();
-        for (int i = 0; i < numHullVertices; ++i) {
-            avgVertex += hullVertices[i];
-        }
-        avgVertex = transform * (avgVertex * (1.0f / (float)numHullVertices));
-
-        for (int i = 0; i < numHullVertices; ++i) {
-            btVector3 norm = transform * hullVertices[i] - avgVertex;
-            btScalar normLength = norm.length();
-            if (normLength > FLT_EPSILON) {
-                norm /= normLength;
-            }
-            memcpy(tempVertices + 3 * i, norm.m_floats, SIZE_OF_VEC3);
-        }
-        gpu::BufferView::Size numBytes = sizeof(float) * (3 * numHullVertices);
-        const gpu::Byte* data = reinterpret_cast<const gpu::Byte*>(tempVertices);
-        normals._buffer->append(numBytes, data);
-        normals._size = vertices._buffer->getSize();
-    }
-    return true;
-}
-
-graphics::MeshPointer createMeshFromShape(const void* pointer) {
-    graphics::MeshPointer mesh;
-    if (!pointer) {
-        return mesh;
-    }
-
-    // pointer must be a const btCollisionShape* (cast to void*), but it only
-    // needs to be valid here when its render mesh is created, after this call
-    // the cache doesn't care what happens to the shape behind the pointer
-    const btCollisionShape* shape = static_cast<const btCollisionShape*>(pointer);
-
-    int32_t shapeType = shape->getShapeType();
-    if (shapeType == (int32_t)COMPOUND_SHAPE_PROXYTYPE || shape->isConvex()) {
-        // allocate buffers for it
-        gpu::BufferView vertices(new gpu::Buffer(), gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
-        gpu::BufferView indices(new gpu::Buffer(), gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::INDEX));
-        gpu::BufferView parts(new gpu::Buffer(), gpu::Element(gpu::VEC4, gpu::UINT32, gpu::PART));
-        gpu::BufferView normals(new gpu::Buffer(), gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
-
-        int32_t numSuccesses = 0;
-        if (shapeType == (int32_t)COMPOUND_SHAPE_PROXYTYPE) {
-            const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(shape);
-            int32_t numSubShapes = compoundShape->getNumChildShapes();
-            for (int32_t i = 0; i < numSubShapes; ++i) {
-                const btCollisionShape* childShape = compoundShape->getChildShape(i);
-                if (childShape->isConvex()) {
-                    const btConvexShape* convexShape = static_cast<const btConvexShape*>(childShape);
-                    if (copyShapeToMesh(compoundShape->getChildTransform(i), convexShape, vertices, indices, parts, normals)) {
-                        numSuccesses++;
-                    }
-                }
-            }
-        } else {
-            // shape is convex
-            const btConvexShape* convexShape = static_cast<const btConvexShape*>(shape);
-            btTransform transform;
-            transform.setIdentity();
-            if (copyShapeToMesh(transform, convexShape, vertices, indices, parts, normals)) {
-                numSuccesses++;
-            }
-        }
-        if (numSuccesses > 0) {
-            mesh = std::make_shared<graphics::Mesh>();
-            mesh->setVertexBuffer(vertices);
-            mesh->setIndexBuffer(indices);
-            mesh->setPartBuffer(parts);
-            mesh->addAttribute(gpu::Stream::NORMAL, normals);
-        } else {
-            // TODO: log failure message here
-        }
-    }
-    return mesh;
-}
-
-CollisionRenderMeshCache::CollisionRenderMeshCache() {
-}
-
-CollisionRenderMeshCache::~CollisionRenderMeshCache() {
-    _meshMap.clear();
-    _pendingGarbage.clear();
-}
-
-graphics::MeshPointer CollisionRenderMeshCache::getMesh(CollisionRenderMeshCache::Key key) {
-    graphics::MeshPointer mesh;
-    if (key) {
-        CollisionMeshMap::const_iterator itr = _meshMap.find(key);
-        if (itr == _meshMap.end()) {
-            // make mesh and add it to map
-            mesh = createMeshFromShape(key);
-            if (mesh) {
-                _meshMap.insert(std::make_pair(key, mesh));
-            }
-        } else {
-            mesh = itr->second;
-        }
-    }
-    const uint32_t MAX_NUM_PENDING_GARBAGE = 20;
-    if (_pendingGarbage.size() > MAX_NUM_PENDING_GARBAGE) {
-        collectGarbage();
-    }
-    return mesh;
-}
-
-bool CollisionRenderMeshCache::releaseMesh(CollisionRenderMeshCache::Key key) {
-    if (!key) {
-        return false;
-    }
-    CollisionMeshMap::const_iterator itr = _meshMap.find(key);
-    if (itr != _meshMap.end()) {
-        _pendingGarbage.push_back(key);
-        return true;
-    }
-    return false;
-}
-
-void CollisionRenderMeshCache::collectGarbage() {
-    uint32_t numShapes = (uint32_t)_pendingGarbage.size();
-    for (uint32_t i = 0; i < numShapes; ++i) {
-        CollisionRenderMeshCache::Key key = _pendingGarbage[i];
-        CollisionMeshMap::const_iterator itr = _meshMap.find(key);
-        if (itr != _meshMap.end()) {
-            if ((*itr).second.use_count() == 1) {
-                // we hold the only reference
-                _meshMap.erase(itr);
-            }
-        }
-    }
-    _pendingGarbage.clear();
-}
-

libraries/physics/src/CollisionRenderMeshCache.h

@@ -1,48 +0,0 @@
-//
-//  CollisionRenderMeshCache.h
-//  libraries/physics/src
-//
-//  Created by Andrew Meadows 2016.07.13
-//  Copyright 2016 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_CollisionRenderMeshCache_h
-#define hifi_CollisionRenderMeshCache_h
-
-#include <memory>
-#include <vector>
-#include <unordered_map>
-
-#include <graphics/Geometry.h>
-
-
-class CollisionRenderMeshCache {
-public:
-    using Key = const void*; // must actually be a const btCollisionShape*
-
-    CollisionRenderMeshCache();
-    ~CollisionRenderMeshCache();
-
-    /// \return pointer to geometry
-    graphics::MeshPointer getMesh(Key key);
-
-    /// \return true if geometry was found and released
-    bool releaseMesh(Key key);
-
-    /// delete geometries that have zero references
-    void collectGarbage();
-
-    // validation methods
-    uint32_t getNumMeshes() const { return (uint32_t)_meshMap.size(); }
-    bool hasMesh(Key key) const { return _meshMap.find(key) == _meshMap.end(); }
-
-private:
-    using CollisionMeshMap = std::unordered_map<Key, graphics::MeshPointer>;
-    CollisionMeshMap _meshMap;
-    std::vector<Key> _pendingGarbage;
-};
-
-#endif // hifi_CollisionRenderMeshCache_h

libraries/physics/src/EntityMotionState.cpp

@@ -307,13 +307,6 @@ const btCollisionShape* EntityMotionState::computeNewShape() {
     return getShapeManager()->getShape(shapeInfo);
 }
 
-void EntityMotionState::setShape(const btCollisionShape* shape) {
-    if (_shape != shape) {
-        ObjectMotionState::setShape(shape);
-        _entity->setCollisionShape(_shape);
-    }
-}
-
 bool EntityMotionState::remoteSimulationOutOfSync(uint32_t simulationStep) {
     // NOTE: this method is only ever called when the entity simulation is locally owned
     DETAILED_PROFILE_RANGE(simulation_physics, "CheckOutOfSync");

libraries/physics/src/EntityMotionState.h

@@ -118,7 +118,6 @@ protected:
 
     bool isReadyToComputeShape() const override;
     const btCollisionShape* computeNewShape() override;
-    void setShape(const btCollisionShape* shape) override;
     void setMotionType(PhysicsMotionType motionType) override;
 
     // EntityMotionState keeps a SharedPointer to its EntityItem which is only set in the CTOR

libraries/script-engine/src/RecordingScriptingInterface.cpp

@@ -59,7 +59,7 @@ void RecordingScriptingInterface::playClip(NetworkClipLoaderPointer clipLoader,
 
     if (callback.isFunction()) {
         QScriptValueList args { true, url };
-        callback.call(_scriptEngine->globalObject(), args);
+        callback.call(QScriptValue(), args);
     }
 }
 
@@ -78,7 +78,7 @@ void RecordingScriptingInterface::loadRecording(const QString& url, QScriptValue
     auto weakClipLoader = clipLoader.toWeakRef();
 
     // when clip loaded, call the callback with the URL and success boolean
-    connect(clipLoader.data(), &recording::NetworkClipLoader::clipLoaded, this,
+    connect(clipLoader.data(), &recording::NetworkClipLoader::clipLoaded, callback.engine(),
             [this, weakClipLoader, url, callback]() mutable {
 
         if (auto clipLoader = weakClipLoader.toStrongRef()) {
@@ -92,12 +92,12 @@ void RecordingScriptingInterface::loadRecording(const QString& url, QScriptValue
     });
 
     // when clip load fails, call the callback with the URL and failure boolean
-    connect(clipLoader.data(), &recording::NetworkClipLoader::failed, this, [this, weakClipLoader, url, callback](QNetworkReply::NetworkError error) mutable {
+    connect(clipLoader.data(), &recording::NetworkClipLoader::failed, callback.engine(), [this, weakClipLoader, url, callback](QNetworkReply::NetworkError error) mutable {
         qCDebug(scriptengine) << "Failed to load recording from" << url;
 
         if (callback.isFunction()) {
             QScriptValueList args { false, url };
-            callback.call(_scriptEngine->currentContext()->thisObject(), args);
+            callback.call(QScriptValue(), args);
         }
 
         if (auto clipLoader = weakClipLoader.toStrongRef()) {

libraries/script-engine/src/RecordingScriptingInterface.h

@@ -36,8 +36,6 @@ class RecordingScriptingInterface : public QObject, public Dependency {
 public:
     RecordingScriptingInterface();
 
-    void setScriptEngine(QSharedPointer<BaseScriptEngine> scriptEngine) { _scriptEngine = scriptEngine; }
-
 public slots:
 
     /**jsdoc
@@ -246,7 +244,6 @@ protected:
     Flag _useSkeletonModel { false };
     recording::ClipPointer _lastClip;
 
-    QSharedPointer<BaseScriptEngine> _scriptEngine;
     QSet<recording::NetworkClipLoaderPointer> _clipLoaders;
 
 private:

libraries/shared/src/AvatarConstants.h

@@ -23,10 +23,10 @@ const float DEFAULT_AVATAR_EYE_HEIGHT = DEFAULT_AVATAR_HEIGHT - DEFAULT_AVATAR_E
 const float DEFAULT_AVATAR_SUPPORT_BASE_LEFT  = -0.25f;
 const float DEFAULT_AVATAR_SUPPORT_BASE_RIGHT =  0.25f;
 const float DEFAULT_AVATAR_SUPPORT_BASE_FRONT = -0.20f;
-const float DEFAULT_AVATAR_SUPPORT_BASE_BACK  =  0.10f;
+const float DEFAULT_AVATAR_SUPPORT_BASE_BACK  =  0.12f;
 const float DEFAULT_AVATAR_LATERAL_STEPPING_THRESHOLD = 0.10f;
 const float DEFAULT_AVATAR_ANTERIOR_STEPPING_THRESHOLD = 0.04f;
-const float DEFAULT_AVATAR_POSTERIOR_STEPPING_THRESHOLD = 0.07f;
+const float DEFAULT_AVATAR_POSTERIOR_STEPPING_THRESHOLD = 0.05f;
 const float DEFAULT_AVATAR_HEAD_ANGULAR_VELOCITY_STEPPING_THRESHOLD = 0.3f;
 const float DEFAULT_AVATAR_MODE_HEIGHT_STEPPING_THRESHOLD = -0.02f;
 const float DEFAULT_HANDS_VELOCITY_DIRECTION_STEPPING_THRESHOLD = 0.4f;

scripts/system/controllers/controllerModules/teleport.js

@@ -325,7 +325,7 @@ Script.include("/~/system/libraries/controllers.js");
             } else if (target === TARGET.SURFACE) {
                 var offset = getAvatarFootOffset();
                 result.intersection.y += offset;
-                MyAvatar.goToLocation(result.intersection, false, {x: 0, y: 0, z: 0, w: 1}, false);
+                MyAvatar.goToLocation(result.intersection, true, HMD.orientation, false);
                 HMD.centerUI();
                 MyAvatar.centerBody();
             }

tests/physics/src/CollisionRenderMeshCacheTests.cpp

@@ -1,277 +0,0 @@
-//
-//  CollisionRenderMeshCacheTests.cpp
-//  tests/physics/src
-//
-//  Created by Andrew Meadows on 2014.10.30
-//  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 "CollisionRenderMeshCacheTests.h"
-
-#include <iostream>
-#include <cstdlib>
-
-#include <btBulletDynamicsCommon.h>
-#include <BulletCollision/CollisionShapes/btShapeHull.h>
-
-#include <CollisionRenderMeshCache.h>
-#include <ShapeInfo.h> // for MAX_HULL_POINTS
-
-#include "MeshUtil.h"
-
-
-QTEST_MAIN(CollisionRenderMeshCacheTests)
-
-const float INV_SQRT_THREE = 0.577350269f;
-
-const uint32_t numSphereDirections = 6 + 8;
-btVector3 sphereDirections[] = {
-    btVector3(1.0f, 0.0f, 0.0f),
-    btVector3(-1.0f, 0.0f, 0.0f),
-    btVector3(0.0f, 1.0f, 0.0f),
-    btVector3(0.0f, -1.0f, 0.0f),
-    btVector3(0.0f, 0.0f, 1.0f),
-    btVector3(0.0f, 0.0f, -1.0f),
-    btVector3(INV_SQRT_THREE, INV_SQRT_THREE, INV_SQRT_THREE),
-    btVector3(INV_SQRT_THREE, INV_SQRT_THREE, -INV_SQRT_THREE),
-    btVector3(INV_SQRT_THREE, -INV_SQRT_THREE, INV_SQRT_THREE),
-    btVector3(INV_SQRT_THREE, -INV_SQRT_THREE, -INV_SQRT_THREE),
-    btVector3(-INV_SQRT_THREE, INV_SQRT_THREE, INV_SQRT_THREE),
-    btVector3(-INV_SQRT_THREE, INV_SQRT_THREE, -INV_SQRT_THREE),
-    btVector3(-INV_SQRT_THREE, -INV_SQRT_THREE, INV_SQRT_THREE),
-    btVector3(-INV_SQRT_THREE, -INV_SQRT_THREE, -INV_SQRT_THREE)
-};
-
-float randomFloat() {
-    return 2.0f * ((float)rand() / (float)RAND_MAX) - 1.0f;
-}
-
-btBoxShape* createBoxShape(const btVector3& extent) {
-    btBoxShape* shape = new btBoxShape(0.5f * extent);
-    return shape;
-}
-
-btConvexHullShape* createConvexHull(float radius) {
-    btConvexHullShape* hull = new btConvexHullShape();
-    for (uint32_t i = 0; i < numSphereDirections; ++i) {
-        btVector3 point = radius * sphereDirections[i];
-        hull->addPoint(point, false);
-    }
-    hull->recalcLocalAabb();
-    return hull;
-}
-
-void CollisionRenderMeshCacheTests::testShapeHullManifold() {
-    // make a box shape
-    btVector3 extent(1.0f, 2.0f, 3.0f);
-    btBoxShape* box = createBoxShape(extent);
-
-    // wrap it with a ShapeHull
-    btShapeHull hull(box);
-    const float MARGIN = 0.0f;
-    hull.buildHull(MARGIN);
-
-    // verify the vertex count is capped
-    uint32_t numVertices = (uint32_t)hull.numVertices();
-    QVERIFY(numVertices <= MAX_HULL_POINTS);
-
-    // verify the mesh is inside the radius
-    btVector3 halfExtents = box->getHalfExtentsWithMargin();
-    float ACCEPTABLE_EXTENTS_ERROR = 0.01f;
-    float maxRadius = halfExtents.length() + ACCEPTABLE_EXTENTS_ERROR;
-    const btVector3* meshVertices = hull.getVertexPointer();
-    for (uint32_t i = 0; i < numVertices; ++i) {
-        btVector3 vertex = meshVertices[i];
-        QVERIFY(vertex.length() <= maxRadius);
-    }
-
-    // verify the index count is capped
-    uint32_t numIndices = (uint32_t)hull.numIndices();
-    QVERIFY(numIndices < 6 * MAX_HULL_POINTS);
-
-    // verify the index count is a multiple of 3
-    QVERIFY(numIndices % 3 == 0);
-
-    // verify the mesh is closed
-    const uint32_t* meshIndices = hull.getIndexPointer();
-    bool isClosed = MeshUtil::isClosedManifold(meshIndices, numIndices);
-    QVERIFY(isClosed);
-
-    // verify the triangle normals are outward using right-hand-rule
-    const uint32_t INDICES_PER_TRIANGLE = 3;
-    for (uint32_t i = 0; i < numIndices; i += INDICES_PER_TRIANGLE) {
-        btVector3 A = meshVertices[meshIndices[i]];
-        btVector3 B = meshVertices[meshIndices[i+1]];
-        btVector3 C = meshVertices[meshIndices[i+2]];
-
-        btVector3 face = (B - A).cross(C - B);
-        btVector3 center = (A + B + C) / 3.0f;
-        QVERIFY(face.dot(center) > 0.0f);
-    }
-
-    // delete unmanaged memory
-    delete box;
-}
-
-void CollisionRenderMeshCacheTests::testCompoundShape() {
-    uint32_t numSubShapes = 3;
-
-    btVector3 centers[] = {
-        btVector3(1.0f, 0.0f, 0.0f),
-        btVector3(0.0f, -2.0f, 0.0f),
-        btVector3(0.0f, 0.0f, 3.0f),
-    };
-
-    float radii[] = { 3.0f, 2.0f, 1.0f };
-
-    btCompoundShape* compoundShape = new btCompoundShape();
-    for (uint32_t i = 0; i < numSubShapes; ++i) {
-        btTransform transform;
-        transform.setOrigin(centers[i]);
-        btConvexHullShape* hull = createConvexHull(radii[i]);
-        compoundShape->addChildShape(transform, hull);
-    }
-
-    // create the cache
-    CollisionRenderMeshCache cache;
-    QVERIFY(cache.getNumMeshes() == 0);
-
-    // get the mesh once
-    graphics::MeshPointer mesh = cache.getMesh(compoundShape);
-    QVERIFY((bool)mesh);
-    QVERIFY(cache.getNumMeshes() == 1);
-
-    // get the mesh again
-    graphics::MeshPointer mesh2 = cache.getMesh(compoundShape);
-    QVERIFY(mesh2 == mesh);
-    QVERIFY(cache.getNumMeshes() == 1);
-
-    // forget the mesh once
-    cache.releaseMesh(compoundShape);
-    mesh.reset();
-    QVERIFY(cache.getNumMeshes() == 1);
-
-    // collect garbage (should still cache mesh)
-    cache.collectGarbage();
-    QVERIFY(cache.getNumMeshes() == 1);
-
-    // forget the mesh a second time (should still cache mesh)
-    cache.releaseMesh(compoundShape);
-    mesh2.reset();
-    QVERIFY(cache.getNumMeshes() == 1);
-
-    // collect garbage (should no longer cache mesh)
-    cache.collectGarbage();
-    QVERIFY(cache.getNumMeshes() == 0);
-
-    // delete unmanaged memory
-    for (int i = 0; i < compoundShape->getNumChildShapes(); ++i) {
-        delete compoundShape->getChildShape(i);
-    }
-    delete compoundShape;
-}
-
-void CollisionRenderMeshCacheTests::testMultipleShapes() {
-    // shapeA is compound of hulls
-    uint32_t numSubShapes = 3;
-    btVector3 centers[] = {
-        btVector3(1.0f, 0.0f, 0.0f),
-        btVector3(0.0f, -2.0f, 0.0f),
-        btVector3(0.0f, 0.0f, 3.0f),
-    };
-    float radii[] = { 3.0f, 2.0f, 1.0f };
-    btCompoundShape* shapeA = new btCompoundShape();
-    for (uint32_t i = 0; i < numSubShapes; ++i) {
-        btTransform transform;
-        transform.setOrigin(centers[i]);
-        btConvexHullShape* hull = createConvexHull(radii[i]);
-        shapeA->addChildShape(transform, hull);
-    }
-
-    // shapeB is compound of boxes
-    btVector3 extents[] = {
-        btVector3(1.0f, 2.0f, 3.0f),
-        btVector3(2.0f, 3.0f, 1.0f),
-        btVector3(3.0f, 1.0f, 2.0f),
-    };
-    btCompoundShape* shapeB = new btCompoundShape();
-    for (uint32_t i = 0; i < numSubShapes; ++i) {
-        btTransform transform;
-        transform.setOrigin(centers[i]);
-        btBoxShape* box = createBoxShape(extents[i]);
-        shapeB->addChildShape(transform, box);
-    }
-
-    // shapeC is just a box
-    btVector3 extentC(7.0f, 3.0f, 5.0f);
-    btBoxShape* shapeC = createBoxShape(extentC);
-
-    // create the cache
-    CollisionRenderMeshCache cache;
-    QVERIFY(cache.getNumMeshes() == 0);
-
-    // get the meshes
-    graphics::MeshPointer meshA = cache.getMesh(shapeA);
-    graphics::MeshPointer meshB = cache.getMesh(shapeB);
-    graphics::MeshPointer meshC = cache.getMesh(shapeC);
-    QVERIFY((bool)meshA);
-    QVERIFY((bool)meshB);
-    QVERIFY((bool)meshC);
-    QVERIFY(cache.getNumMeshes() == 3);
-
-    // get the meshes again
-    graphics::MeshPointer meshA2 = cache.getMesh(shapeA);
-    graphics::MeshPointer meshB2 = cache.getMesh(shapeB);
-    graphics::MeshPointer meshC2 = cache.getMesh(shapeC);
-    QVERIFY(meshA == meshA2);
-    QVERIFY(meshB == meshB2);
-    QVERIFY(meshC == meshC2);
-    QVERIFY(cache.getNumMeshes() == 3);
-
-    // forget the meshes once
-    cache.releaseMesh(shapeA);
-    cache.releaseMesh(shapeB);
-    cache.releaseMesh(shapeC);
-    meshA2.reset();
-    meshB2.reset();
-    meshC2.reset();
-    QVERIFY(cache.getNumMeshes() == 3);
-
-    // collect garbage (should still cache mesh)
-    cache.collectGarbage();
-    QVERIFY(cache.getNumMeshes() == 3);
-
-    // forget again, one mesh at a time...
-    // shapeA...
-    cache.releaseMesh(shapeA);
-    meshA.reset();
-    QVERIFY(cache.getNumMeshes() == 3);
-    cache.collectGarbage();
-    QVERIFY(cache.getNumMeshes() == 2);
-    // shapeB...
-    cache.releaseMesh(shapeB);
-    meshB.reset();
-    QVERIFY(cache.getNumMeshes() == 2);
-    cache.collectGarbage();
-    QVERIFY(cache.getNumMeshes() == 1);
-    // shapeC...
-    cache.releaseMesh(shapeC);
-    meshC.reset();
-    QVERIFY(cache.getNumMeshes() == 1);
-    cache.collectGarbage();
-    QVERIFY(cache.getNumMeshes() == 0);
-
-    // delete unmanaged memory
-    for (int i = 0; i < shapeA->getNumChildShapes(); ++i) {
-        delete shapeA->getChildShape(i);
-    }
-    delete shapeA;
-    for (int i = 0; i < shapeB->getNumChildShapes(); ++i) {
-        delete shapeB->getChildShape(i);
-    }
-    delete shapeB;
-    delete shapeC;
-}

tests/physics/src/CollisionRenderMeshCacheTests.h

@@ -1,26 +0,0 @@
-//
-//  CollisionRenderMeshCacheTests.h
-//  tests/physics/src
-//
-//  Created by Andrew Meadows on 2014.10.30
-//  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_CollisionRenderMeshCacheTests_h
-#define hifi_CollisionRenderMeshCacheTests_h
-
-#include <QtTest/QtTest>
-
-class CollisionRenderMeshCacheTests : public QObject {
-    Q_OBJECT
-
-private slots:
-    void testShapeHullManifold();
-    void testCompoundShape();
-    void testMultipleShapes();
-};
-
-#endif // hifi_CollisionRenderMeshCacheTests_h