Merge pull request #5100 from AndrewMeadows/inertia

reset simulation bid counters whenever an object is activated

libraries/entities-renderer/src/RenderableBoxEntityItem.cpp

@@ -9,15 +9,18 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+#include "RenderableBoxEntityItem.h"
+
 #include <glm/gtx/quaternion.hpp>
 
 #include <gpu/GPUConfig.h>
 #include <gpu/Batch.h>
 
 #include <DeferredLightingEffect.h>
+#include <ObjectMotionState.h>
 #include <PerfStat.h>
 
-#include "RenderableBoxEntityItem.h"
+#include "RenderableDebugableEntityItem.h"
 
 EntityItemPointer RenderableBoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     return EntityItemPointer(new RenderableBoxEntityItem(entityID, properties));
@@ -28,22 +31,10 @@ void RenderableBoxEntityItem::render(RenderArgs* args) {
     Q_ASSERT(getType() == EntityTypes::Box);
     glm::vec4 cubeColor(toGlm(getXColor()), getLocalRenderAlpha());
     
-    bool debugSimulationOwnership = args->_debugFlags & RenderArgs::RENDER_DEBUG_SIMULATION_OWNERSHIP;
-    bool highlightSimulationOwnership = false;
-    if (debugSimulationOwnership) {
-        auto nodeList = DependencyManager::get<NodeList>();
-        const QUuid& myNodeID = nodeList->getSessionUUID();
-        highlightSimulationOwnership = (getSimulatorID() == myNodeID);
-    }
-    
     Q_ASSERT(args->_batch);
     gpu::Batch& batch = *args->_batch;
     batch.setModelTransform(getTransformToCenter());
-    if (highlightSimulationOwnership) {
-        DependencyManager::get<DeferredLightingEffect>()->renderWireCube(batch, 1.0f, cubeColor);
-    } else {
     DependencyManager::get<DeferredLightingEffect>()->renderSolidCube(batch, 1.0f, cubeColor);
-    }
 
     RenderableDebugableEntityItem::render(this, args);
 };

libraries/entities-renderer/src/RenderableBoxEntityItem.h

@@ -13,7 +13,6 @@
 #define hifi_RenderableBoxEntityItem_h
 
 #include <BoxEntityItem.h>
-#include "RenderableDebugableEntityItem.h"
 #include "RenderableEntityItem.h"
 
 class RenderableBoxEntityItem : public BoxEntityItem {

libraries/entities-renderer/src/RenderableDebugableEntityItem.cpp

@@ -10,58 +10,57 @@
 //
 
 
+#include "RenderableDebugableEntityItem.h"
 
 #include <glm/gtx/quaternion.hpp>
 
 #include <gpu/GPUConfig.h>
 #include <gpu/Batch.h>
-
 #include <DeferredLightingEffect.h>
-#include <PhysicsEngine.h>
+#include <ObjectMotionState.h>
-
-#include "RenderableDebugableEntityItem.h"
 
 
 void RenderableDebugableEntityItem::renderBoundingBox(EntityItem* entity, RenderArgs* args,
                                                       float puffedOut, glm::vec4& color) {
     Q_ASSERT(args->_batch);
     gpu::Batch& batch = *args->_batch;
-    batch.setModelTransform(entity->getTransformToCenter());
+    Transform transform = entity->getTransformToCenter();
+    //transform.postScale(entity->getDimensions());
+    batch.setModelTransform(transform);
     DependencyManager::get<DeferredLightingEffect>()->renderWireCube(batch, 1.0f + puffedOut, color);
 }
 
-void RenderableDebugableEntityItem::renderHoverDot(EntityItem* entity, RenderArgs* args) {
+void RenderableDebugableEntityItem::render(EntityItem* entity, RenderArgs* args) {
-    const int SLICES = 8, STACKS = 8;
+    if (args->_debugFlags & RenderArgs::RENDER_DEBUG_SIMULATION_OWNERSHIP) {
-    float radius = 0.05f;
-    glm::vec4 blueColor(0.0f, 0.0f, 1.0f, 1.0f);
-    
         Q_ASSERT(args->_batch);
         gpu::Batch& batch = *args->_batch;
         Transform transform = entity->getTransformToCenter();
-    // Cancel true dimensions and set scale to 2 * radius (diameter)
+        transform.postScale(entity->getDimensions());
-    transform.postScale(2.0f * glm::vec3(radius, radius, radius) / entity->getDimensions());
         batch.setModelTransform(transform);
-    DependencyManager::get<DeferredLightingEffect>()->renderSolidSphere(batch, 0.5f, SLICES, STACKS, blueColor);
+
+        auto nodeList = DependencyManager::get<NodeList>();
+        const QUuid& myNodeID = nodeList->getSessionUUID();
+        bool highlightSimulationOwnership = (entity->getSimulatorID() == myNodeID);
+        if (highlightSimulationOwnership) {
+            glm::vec4 greenColor(0.0f, 1.0f, 0.2f, 1.0f);
+            renderBoundingBox(entity, args, 0.08f, greenColor);
         }
 
-void RenderableDebugableEntityItem::render(EntityItem* entity, RenderArgs* args) {
-    bool debugSimulationOwnership = args->_debugFlags & RenderArgs::RENDER_DEBUG_SIMULATION_OWNERSHIP;
-
-    if (debugSimulationOwnership) {
         quint64 now = usecTimestampNow();
         if (now - entity->getLastEditedFromRemote() < 0.1f * USECS_PER_SECOND) {
             glm::vec4 redColor(1.0f, 0.0f, 0.0f, 1.0f);
-            renderBoundingBox(entity, args, 0.2f, redColor);
+            renderBoundingBox(entity, args, 0.16f, redColor);
         }
 
         if (now - entity->getLastBroadcast() < 0.2f * USECS_PER_SECOND) {
             glm::vec4 yellowColor(1.0f, 1.0f, 0.2f, 1.0f);
-            renderBoundingBox(entity, args, 0.3f, yellowColor);
+            renderBoundingBox(entity, args, 0.24f, yellowColor);
         }
 
         ObjectMotionState* motionState = static_cast<ObjectMotionState*>(entity->getPhysicsInfo());
         if (motionState && motionState->isActive()) {
-            renderHoverDot(entity, args);
+            glm::vec4 blueColor(0.0f, 0.0f, 1.0f, 1.0f);
+            renderBoundingBox(entity, args, 0.32f, blueColor);
         }
     }
 }

libraries/entities-renderer/src/RenderableDebugableEntityItem.h

@@ -17,7 +17,6 @@
 class RenderableDebugableEntityItem {
 public:
     static void renderBoundingBox(EntityItem* entity, RenderArgs* args, float puffedOut, glm::vec4& color);
-    static void renderHoverDot(EntityItem* entity, RenderArgs* args);
     static void render(EntityItem* entity, RenderArgs* args);
 };
 

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -201,14 +201,6 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
     glm::vec3 position = getPosition();
     glm::vec3 dimensions = getDimensions();
 
-    bool debugSimulationOwnership = args->_debugFlags & RenderArgs::RENDER_DEBUG_SIMULATION_OWNERSHIP;
-    bool highlightSimulationOwnership = false;
-    if (debugSimulationOwnership) {
-        auto nodeList = DependencyManager::get<NodeList>();
-        const QUuid& myNodeID = nodeList->getSessionUUID();
-        highlightSimulationOwnership = (getSimulatorID() == myNodeID);
-    }
-
     if (hasModel()) {
         if (_model) {
             if (QUrl(getModelURL()) != _model->getURL()) {
@@ -274,11 +266,6 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
                 }
             }
         }
-
-        if (highlightSimulationOwnership) {
-            glm::vec4 greenColor(0.0f, 1.0f, 0.0f, 1.0f);
-            RenderableDebugableEntityItem::renderBoundingBox(this, args, 0.0f, greenColor);
-        }
     } else {
         glm::vec4 greenColor(0.0f, 1.0f, 0.0f, 1.0f);
         RenderableDebugableEntityItem::renderBoundingBox(this, args, 0.0f, greenColor);

libraries/entities-renderer/src/RenderableSphereEntityItem.cpp

@@ -9,6 +9,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+#include "RenderableSphereEntityItem.h"
+
 #include <glm/gtx/quaternion.hpp>
 
 #include <gpu/GPUConfig.h>
@@ -18,7 +20,7 @@
 #include <DeferredLightingEffect.h>
 #include <PerfStat.h>
 
-#include "RenderableSphereEntityItem.h"
+#include "RenderableDebugableEntityItem.h"
 
 EntityItemPointer RenderableSphereEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
     return EntityItemPointer(new RenderableSphereEntityItem(entityID, properties));
@@ -39,4 +41,6 @@ void RenderableSphereEntityItem::render(RenderArgs* args) {
     gpu::Batch& batch = *args->_batch;
     batch.setModelTransform(getTransformToCenter());
     DependencyManager::get<DeferredLightingEffect>()->renderSolidSphere(batch, 0.5f, SLICES, STACKS, sphereColor);
+
+    RenderableDebugableEntityItem::render(this, args);
 };

libraries/physics/src/EntityMotionState.cpp

@@ -180,10 +180,6 @@ btCollisionShape* EntityMotionState::computeNewShape() {
     return nullptr;
 }
 
-// RELIABLE_SEND_HACK: until we have truly reliable resends of non-moving updates
-// we alwasy resend packets for objects that have stopped moving up to some max limit.
-const int MAX_NUM_NON_MOVING_UPDATES = 5;
-
 bool EntityMotionState::isCandidateForOwnership(const QUuid& sessionID) const { 
     if (!_body || !_entity) {
         return false;
@@ -495,6 +491,10 @@ void EntityMotionState::measureBodyAcceleration() {
         glm::vec3 velocity = bulletToGLM(_body->getLinearVelocity());
         _measuredAcceleration = (velocity / powf(1.0f - _body->getLinearDamping(), dt) - _lastVelocity) * invDt;
         _lastVelocity = velocity;
+        if (numSubsteps > PHYSICS_ENGINE_MAX_NUM_SUBSTEPS && !_candidateForOwnership) {
+            _loopsSinceOwnershipBid = 0;
+            _loopsWithoutOwner = 0;
+        }
     }
 }
 glm::vec3 EntityMotionState::getObjectLinearVelocityChange() const {

libraries/physics/src/ObjectMotionState.h

@@ -53,8 +53,6 @@ const uint32_t OUTGOING_DIRTY_PHYSICS_FLAGS = EntityItem::DIRTY_TRANSFORM | Enti
 class OctreeEditPacketSender;
 class PhysicsEngine;
 
-extern const int MAX_NUM_NON_MOVING_UPDATES;
-
 class ObjectMotionState : public btMotionState {
 public:
     // These poroperties of the PhysicsEngine are "global" within the context of all ObjectMotionStates

libraries/physics/src/PhysicsEngine.cpp

@@ -227,8 +227,7 @@ void PhysicsEngine::stepSimulation() {
     // (3) synchronize outgoing motion states
     // (4) send outgoing packets
 
-    const int MAX_NUM_SUBSTEPS = 4;
+    const float MAX_TIMESTEP = (float)PHYSICS_ENGINE_MAX_NUM_SUBSTEPS * PHYSICS_ENGINE_FIXED_SUBSTEP;
-    const float MAX_TIMESTEP = (float)MAX_NUM_SUBSTEPS * PHYSICS_ENGINE_FIXED_SUBSTEP;
     float dt = 1.0e-6f * (float)(_clock.getTimeMicroseconds());
     _clock.reset();
     float timeStep = btMin(dt, MAX_TIMESTEP);
@@ -245,7 +244,7 @@ void PhysicsEngine::stepSimulation() {
         _characterController->preSimulation(timeStep);
     }
 
-    int numSubsteps = _dynamicsWorld->stepSimulation(timeStep, MAX_NUM_SUBSTEPS, PHYSICS_ENGINE_FIXED_SUBSTEP);
+    int numSubsteps = _dynamicsWorld->stepSimulation(timeStep, PHYSICS_ENGINE_MAX_NUM_SUBSTEPS, PHYSICS_ENGINE_FIXED_SUBSTEP);
     if (numSubsteps > 0) {
         BT_PROFILE("postSimulation");
         _numSubsteps += (uint32_t)numSubsteps;

libraries/shared/src/PhysicsHelpers.h

@@ -15,6 +15,7 @@
 #include <glm/glm.hpp>
 #include <glm/gtc/quaternion.hpp>
 
+const int PHYSICS_ENGINE_MAX_NUM_SUBSTEPS = 4;
 const float PHYSICS_ENGINE_FIXED_SUBSTEP = 1.0f / 60.0f;
 
 // return incremental rotation (Bullet-style) caused by angularVelocity over timeStep