750 lines · 31.0 KB · C++
RawDownload
            bool movingSlowlyAngular = glm::length2(_entity->getAngularVelocity()) <                    (DYNAMIC_ANGULAR_VELOCITY_THRESHOLD * DYNAMIC_ANGULAR_VELOCITY_THRESHOLD);            bool movingSlowly = movingSlowlyLinear && movingSlowlyAngular && _entity->getAcceleration() == Vectors::ZERO;             if (movingSlowly) {                // velocities might not be zero, but we'll fake them as such, which will hopefully help convince                // other simulating observers to deactivate their own copies                glm::vec3 zero(0.0f);                _entity->setVelocity(zero);                _entity->setAngularVelocity(zero);            }        }        _numInactiveUpdates = 0;    }     // remember properties for local server prediction    Transform localTransform;    _entity->getLocalTransformAndVelocities(localTransform, _serverVelocity, _serverAngularVelocity);    _serverPosition = localTransform.getTranslation();    _serverRotation = localTransform.getRotation();    _serverAcceleration = _entity->getAcceleration();    _serverActionData = _entity->getActionData();     EntityItemProperties properties;     // explicitly set the properties that changed so that they will be packed    properties.setPosition(_entity->getLocalPosition());    properties.setRotation(_entity->getLocalOrientation());     properties.setVelocity(_serverVelocity);    properties.setAcceleration(_serverAcceleration);    properties.setAngularVelocity(_serverAngularVelocity);    if (_entity->actionDataNeedsTransmit()) {        _entity->setActionDataNeedsTransmit(false);        properties.setActionData(_serverActionData);    }     if (properties.parentRelatedPropertyChanged() && _entity->computePuffedQueryAACube()) {        // due to parenting, the server may not know where something is in world-space, so include the bounding cube.        properties.setQueryAACube(_entity->getQueryAACube());    }     // set the LastEdited of the properties but NOT the entity itself    quint64 now = usecTimestampNow();    properties.setLastEdited(now);     #ifdef WANT_DEBUG        quint64 lastSimulated = _entity->getLastSimulated();        qCDebug(physics) << "EntityMotionState::sendUpdate()";        qCDebug(physics) << "        EntityItemId:" << _entity->getEntityItemID()                         << "---------------------------------------------";        qCDebug(physics) << "       lastSimulated:" << debugTime(lastSimulated, now);    #endif //def WANT_DEBUG     if (_numInactiveUpdates > 0) {        // we own the simulation but the entity has stopped so we tell the server we're clearing simulatorID        // but we remember we do still own it...  and rely on the server to tell us we don't        properties.clearSimulationOwner();        _outgoingPriority = 0;        _entity->setPendingOwnershipPriority(_outgoingPriority, now);    } else if (Physics::getSessionUUID() != _entity->getSimulatorID()) {        // we don't own the simulation for this entity yet, but we're sending a bid for it        quint8 bidPriority = glm::max<uint8_t>(_outgoingPriority, VOLUNTEER_SIMULATION_PRIORITY);        properties.setSimulationOwner(Physics::getSessionUUID(), bidPriority);        _nextOwnershipBid = now + USECS_BETWEEN_OWNERSHIP_BIDS;        // copy _outgoingPriority into pendingPriority...        _entity->setPendingOwnershipPriority(_outgoingPriority, now);        // ...then reset _outgoingPriority in preparation for the next frame        _outgoingPriority = 0;    } else if (_outgoingPriority != _entity->getSimulationPriority()) {        // we own the simulation but our desired priority has changed        if (_outgoingPriority == 0) {            // we should release ownership            properties.clearSimulationOwner();        } else {            // we just need to change the priority            properties.setSimulationOwner(Physics::getSessionUUID(), _outgoingPriority);        }        _entity->setPendingOwnershipPriority(_outgoingPriority, now);    }     EntityItemID id(_entity->getID());    EntityEditPacketSender* entityPacketSender = static_cast<EntityEditPacketSender*>(packetSender);    #ifdef WANT_DEBUG        qCDebug(physics) << "EntityMotionState::sendUpdate()... calling queueEditEntityMessage()...";    #endif     EntityTreeElementPointer element = _entity->getElement();    EntityTreePointer tree = element ? element->getTree() : nullptr;     properties.setClientOnly(_entity->getClientOnly());    properties.setOwningAvatarID(_entity->getOwningAvatarID());     entityPacketSender->queueEditEntityMessage(PacketType::EntityEdit, tree, id, properties);    _entity->setLastBroadcast(now);     // if we've moved an entity with children, check/update the queryAACube of all descendents and tell the server    // if they've changed.    _entity->forEachDescendant([&](SpatiallyNestablePointer descendant) {        if (descendant->getNestableType() == NestableType::Entity) {            EntityItemPointer entityDescendant = std::static_pointer_cast<EntityItem>(descendant);            if (descendant->computePuffedQueryAACube()) {                EntityItemProperties newQueryCubeProperties;                newQueryCubeProperties.setQueryAACube(descendant->getQueryAACube());                newQueryCubeProperties.setLastEdited(properties.getLastEdited());                 newQueryCubeProperties.setClientOnly(entityDescendant->getClientOnly());                newQueryCubeProperties.setOwningAvatarID(entityDescendant->getOwningAvatarID());                 entityPacketSender->queueEditEntityMessage(PacketType::EntityEdit, tree,                                                           descendant->getID(), newQueryCubeProperties);                entityDescendant->setLastBroadcast(now);            }        }    });     _lastStep = step;} uint32_t EntityMotionState::getIncomingDirtyFlags() {    assert(entityTreeIsLocked());    uint32_t dirtyFlags = 0;    if (_body && _entity) {        dirtyFlags = _entity->getDirtyFlags();         if (dirtyFlags & Simulation::DIRTY_SIMULATOR_ID) {            // when SIMULATOR_ID changes we must check for reinterpretation of asymmetric collision mask            // bits for the avatar groups (e.g. MY_AVATAR vs OTHER_AVATAR)            uint8_t entityCollisionMask = _entity->getCollisionless() ? 0 : _entity->getCollisionMask();            if ((bool)(entityCollisionMask & USER_COLLISION_GROUP_MY_AVATAR) !=                    (bool)(entityCollisionMask & USER_COLLISION_GROUP_OTHER_AVATAR)) {                // bits are asymmetric --> flag for reinsertion in physics simulation                dirtyFlags |= Simulation::DIRTY_COLLISION_GROUP;            }        }        // we add DIRTY_MOTION_TYPE if the body's motion type disagrees with entity velocity settings        int bodyFlags = _body->getCollisionFlags();        bool isMoving = _entity->isMovingRelativeToParent();         if (((bodyFlags & btCollisionObject::CF_STATIC_OBJECT) && isMoving) // ||            // TODO -- there is opportunity for an optimization here, but this currently causes            // excessive re-insertion of the rigid body.            // (bodyFlags & btCollisionObject::CF_KINEMATIC_OBJECT && !isMoving)            ) {            dirtyFlags |= Simulation::DIRTY_MOTION_TYPE;        }    }    return dirtyFlags;} void EntityMotionState::clearIncomingDirtyFlags() {    assert(entityTreeIsLocked());    if (_body && _entity) {        _entity->clearDirtyFlags();    }} // virtualuint8_t EntityMotionState::getSimulationPriority() const {    return _entity->getSimulationPriority();} // virtualQUuid EntityMotionState::getSimulatorID() const {    assert(entityTreeIsLocked());    return _entity->getSimulatorID();} void EntityMotionState::bump(uint8_t priority) {    assert(priority != 0);    upgradeOutgoingPriority(glm::max(VOLUNTEER_SIMULATION_PRIORITY, --priority));} void EntityMotionState::resetMeasuredBodyAcceleration() {    _lastMeasureStep = ObjectMotionState::getWorldSimulationStep();    if (_body) {        _lastVelocity = getBodyLinearVelocityGTSigma();    } else {        _lastVelocity = Vectors::ZERO;    }    _measuredAcceleration = Vectors::ZERO;} void EntityMotionState::measureBodyAcceleration() {    // try to manually measure the true acceleration of the object    uint32_t thisStep = ObjectMotionState::getWorldSimulationStep();    uint32_t numSubsteps = thisStep - _lastMeasureStep;    if (numSubsteps > 0) {        float dt = ((float)numSubsteps * PHYSICS_ENGINE_FIXED_SUBSTEP);        float invDt = 1.0f / dt;        _lastMeasureStep = thisStep;        _measuredDeltaTime = dt;         // Note: the integration equation for velocity uses damping:   v1 = (v0 + a * dt) * (1 - D)^dt        // hence the equation for acceleration is: a = (v1 / (1 - D)^dt - v0) / dt        glm::vec3 velocity = getBodyLinearVelocityGTSigma();         _measuredAcceleration = (velocity / powf(1.0f - _body->getLinearDamping(), dt) - _lastVelocity) * invDt;        _lastVelocity = velocity;        if (numSubsteps > PHYSICS_ENGINE_MAX_NUM_SUBSTEPS) {            _loopsWithoutOwner = 0;            _lastStep = ObjectMotionState::getWorldSimulationStep();            _numInactiveUpdates = 0;        }         glm::vec3 gravity = _entity->getGravity();        float gravityLength = glm::length(gravity);        float accVsGravity = glm::abs(glm::length(_measuredAcceleration) - gravityLength);        const float ACCELERATION_EQUIVALENT_EPSILON_RATIO = 0.1f;        if (accVsGravity < ACCELERATION_EQUIVALENT_EPSILON_RATIO * gravityLength) {            // acceleration measured during the most recent simulation step was close to gravity.            if (_accelerationNearlyGravityCount < (uint8_t)(-2)) {                ++_accelerationNearlyGravityCount;            }        } else {            // acceleration wasn't similar to this entities gravity, so reset the went-ballistic counter            _accelerationNearlyGravityCount = 0;        }    }} glm::vec3 EntityMotionState::getObjectLinearVelocityChange() const {    // This is the dampened change in linear velocity, as calculated in measureBodyAcceleration: dv = a * dt    // It is generally only meaningful during the lifespan of collision. In particular, it is not meaningful    // when the entity first starts moving via direct user action.    return _measuredAcceleration * _measuredDeltaTime;} // virtualvoid EntityMotionState::setMotionType(PhysicsMotionType motionType) {    ObjectMotionState::setMotionType(motionType);    resetMeasuredBodyAcceleration();}  // virtualQString EntityMotionState::getName() const {    assert(entityTreeIsLocked());    return _entity->getName();} // virtualvoid EntityMotionState::computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const {    assert(_entity);    _entity->computeCollisionGroupAndFinalMask(group, mask);} void EntityMotionState::upgradeOutgoingPriority(uint8_t priority) {    _outgoingPriority = glm::max<uint8_t>(_outgoingPriority, priority);}

Lines 501–750 of 750. Previous lines

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t