// ---------------------------------------------------------------------------- // measure path curvature (1/turning-radius), maintain smoothed version void measurePathCurvature(float elapsedTime) { if (elapsedTime > 0) { Vector3 pos = Position; Vector3 fwd = Forward; Vector3 dP = _lastPosition - pos; Vector3 dF = (_lastForward - fwd) / dP.magnitude; //SI - BIT OF A WEIRD FIX HERE . NOT SURE IF ITS CORRECT //Vector3 lateral = dF.perpendicularComponent (forward ()); Vector3 lateral = OpenSteerUtility.perpendicularComponent(dF, fwd); float sign = (Vector3.Dot(lateral, Side) < 0) ? 1.0f : -1.0f; _curvature = lateral.magnitude * sign; /* * If elapsedTime is greater than 0.25, that means that blendIntoAccumulator * will end up clipping the first parameter to [0..1], and we'll lose information, * making this call framerate-dependent. * * No idea where that 4.0f value comes from, probably out of a hat. */ _smoothedCurvature = OpenSteerUtility.blendIntoAccumulator(elapsedTime * 4.0f, _curvature, _smoothedCurvature); _lastForward = fwd; _lastPosition = pos; } }
// ---------------------------------------------------------------------------- // alternate version: keep FORWARD parallel to velocity, adjust UP according // to a no-basis-in-reality "banking" behavior, something like what birds and // airplanes do // XXX experimental cwr 6-5-03 public void regenerateLocalSpaceForBanking(Vector3 newVelocity, float elapsedTime) { // the length of this global-upward-pointing vector controls the vehicle's // tendency to right itself as it is rolled over from turning acceleration Vector3 globalUp = new Vector3(0, 0.2f, 0); // acceleration points toward the center of local path curvature, the // length determines how much the vehicle will roll while turning Vector3 accelUp = _smoothedAcceleration * 0.05f; // combined banking, sum of UP due to turning and global UP Vector3 bankUp = accelUp + globalUp; // blend bankUp into vehicle's UP basis vector // RJM: framerate-dependent, hopefuly we're getting more than 3 frames per second :-) float smoothRate = elapsedTime * 3; Vector3 tempUp = Up; tempUp = OpenSteerUtility.blendIntoAccumulator(smoothRate, bankUp, tempUp); tempUp.Normalize(); Up = tempUp; #if ANNOTATE_LOCALSPACE annotationLine(position(), position() + (globalUp * 4), gWhite); annotationLine(position(), position() + (bankUp * 4), gOrange); annotationLine(position(), position() + (accelUp * 4), gRed); annotationLine(position(), position() + (up() * 1), gYellow); #endif // adjust orthonormal basis vectors to be aligned with new velocity if (Speed > 0) { Forward = (newVelocity / Speed); } }
private void measurePathCurvature(float elapsedTime) { if (elapsedTime > 0f) { Vector3 position = base.Position; Vector3 forward = base.Forward; Vector3 vector = this._lastPosition - position; Vector3 source = (this._lastForward - forward) / vector.get_magnitude(); Vector3 vector2 = OpenSteerUtility.perpendicularComponent(source, forward); float num = (Vector3.Dot(vector2, base.Side) >= 0f) ? -1f : 1f; this._curvature = vector2.get_magnitude() * num; this._smoothedCurvature = OpenSteerUtility.blendIntoAccumulator(elapsedTime * 4f, this._curvature, this._smoothedCurvature); this._lastForward = forward; this._lastPosition = position; } }
public void regenerateLocalSpaceForBanking(Vector3 newVelocity, float elapsedTime) { Vector3 vector = new Vector3(0f, 0.2f, 0f); Vector3 vector2 = this._smoothedAcceleration * 0.05f; Vector3 newValue = vector2 + vector; float smoothRate = elapsedTime * 3f; Vector3 vector3 = base.Up; vector3 = OpenSteerUtility.blendIntoAccumulator(smoothRate, newValue, vector3); vector3.Normalize(); base.Up = vector3; if (base.Speed > 0f) { base.Forward = newVelocity / base.Speed; } }