C++ Vector3::directionEquals方法代码示例

  Ogre::Vector3
  CharacterController::_collideWithWorld(int recursionDepth,
      const Ogre::Vector3& pos, const Ogre::Vector3& vel,
      CollisionPacket& colData, bool gravityStep,
      const Ogre::Degree& slopeSlideThresold)
  {
    // do we need to worry?
    if (recursionDepth > 5)
      return pos;

    // Ok, we need to worry:
    colData.velocity = vel;
    colData.normalizedVelocity = vel;
    colData.normalizedVelocity.normalise();
    colData.basePoint = pos;
    colData.foundCollision = false;

    // ----------------------------
    // OgreOpcode part begin
    _doOgreOpcodeCollision(colData, mVeryCloseDistance);
    // OgreOpcode part end
    // ----------------------------

    // If no collision we just move along the velocity
    if (colData.foundCollision == false)
      {
        return pos + vel;
      }

    // *** Collision occured ***
    // The original destination point
    Ogre::Vector3 destinationPoint = pos + vel;
    Ogre::Vector3 newBasePoint = pos;

    // only update if we are not already very close
    // and if so we only move very close to intersection..not
    // to the exact spot.
    if (colData.nearestDistance >= mVeryCloseDistance)
      {
        Ogre::Vector3 V = vel;
        V.normalise();
        V = V * (colData.nearestDistance - mVeryCloseDistance);
        newBasePoint = colData.basePoint + V;
        // Adjust polygon intersection point (so sliding
        // plane will be unaffected by the fact that we
        // move slightly less than collision tells us)
        V.normalise();
        colData.intersectionPoint -= mVeryCloseDistance * V;
      }

    // Determine the sliding plane
    Ogre::Vector3 slidePlaneOrigin = colData.intersectionPoint;
    Ogre::Vector3 slidePlaneNormal = newBasePoint - colData.intersectionPoint;
    slidePlaneNormal.normalise();
    Ogre::Plane slidingPlane(slidePlaneNormal, slidePlaneOrigin);

    Ogre::Vector3 newDestinationPoint = destinationPoint
        - slidingPlane.getDistance(destinationPoint) * slidePlaneNormal;

    // Generate the slide vector, which will become our new
    // velocity vector for the next iteration
    Ogre::Vector3 newVelocityVector = newDestinationPoint
        - colData.intersectionPoint;

    // Recurse:
    // dont recurse if the new velocity is very small
    if (newVelocityVector.length() < mVeryCloseDistance)
      {
        return newBasePoint;
      }

    // simulate "friction"
    if (gravityStep)
      {
        // apply gravity only if slope is steep enough
        const Ogre::Radian tolerance = Ogre::Radian(slopeSlideThresold);
        Ogre::Vector3 gravity = vel;
        gravity.normalise();
        if (slidePlaneNormal.directionEquals(-gravity, tolerance))
          {
            return newBasePoint;
          }
      }

    return _collideWithWorld(recursionDepth++, newBasePoint, newVelocityVector,
        colData, gravityStep, slopeSlideThresold);
  }