public static float GetHorizontalDistance(ViVector3 pos1, ViVector3 pos2)
{
float deltaX = pos1.x - pos2.x;
float deltaY = pos1.y - pos2.y;
return(ViMathDefine.Sqrt((deltaX * deltaX) + (deltaY * deltaY)));
}
public void Update(float desireDistance, float delatTime)
{
float diff = desireDistance - _currentDistance;
if (diff == 0.0f)
{
}
else if (diff > 0.0f)
{
float newSpd = _currentSpeed + _accelerate * delatTime;
float maxSpd = ViMathDefine.Sqrt(diff * _accelerate * 2.0f);
_currentSpeed = ViMathDefine.Min(ViMathDefine.Min(newSpd, maxSpd), _maxSpeed);
float delatDist = _currentSpeed * delatTime;
_currentDistance += delatDist;
if (_currentDistance >= desireDistance)
{
_currentDistance = desireDistance;
_currentSpeed = 0.0f;
}
}
else
{
float newSpd = _currentSpeed - _accelerate * delatTime;
float maxSpd = -ViMathDefine.Sqrt(-diff * _accelerate * 2.0f);
_currentSpeed = ViMathDefine.Max(ViMathDefine.Max(newSpd, maxSpd), -_maxSpeed);
float delatDist = _currentSpeed * delatTime;
_currentDistance += delatDist;
if (_currentDistance <= desireDistance)
{
_currentDistance = desireDistance;
_currentSpeed = 0.0f;
}
}
}
public static float Distance(ViVector3 a, ViVector3 b)
{
float deltaX = a.x - b.x;
float deltaY = a.y - b.y;
float deltaZ = a.z - b.z;
return(ViMathDefine.Sqrt((deltaX * deltaX) + (deltaY * deltaY) + (deltaZ * deltaZ)));
}
public float GetDistance(ViGeographicObject obj)
{
if (obj == null)
{
return(1.0f);
}
float diff = GetHorizontalDistance(Position, obj.Position);
return(ViMathDefine.Max(0.0f, diff - BodyRadius - obj.BodyRadius));
}
public override void _Update(float deltaTime, ViVector3 target)
{
ViVector3 diffDir = target - Translate;
diffDir.Normalize();
if (_direction == diffDir)
{
_velocity = _direction * _speed;
}
else
{
ViVector3 rotateAxis = ViVector3.Cross(_direction, diffDir);
rotateAxis.Normalize();
const float STABLE = 0.0001f;
// 计算公式与变量定义
// V 线速度
// W 角速度
// A 侧向加速度
// R 运动半径
// W = V/R;
// A = (V*V)/R = W*W*R = V*W;
float angleDiff = ViVector3.Angle(diffDir, _direction);
float destW = 4.0f * Math.Abs((angleDiff + STABLE) / (_duration + STABLE));
float destA = destW * Speed;
float destLateralAngle = (float)Math.Atan2(destA, _gravity);
//
_rollSpd = 3.0f * (destLateralAngle - _lateralAngle + STABLE) / (_duration + STABLE);
if (destLateralAngle > _lateralAngle)
{
_lateralAngle = ViMathDefine.MoveTowards(_lateralAngle, destLateralAngle, _rollSpd * deltaTime);
}
else
{
_lateralAngle = destLateralAngle;
}
float currentA = (float)Math.Tan(_lateralAngle) * _gravity;
float currentW = currentA / Speed;
float deltaAngle = currentW * deltaTime;
//
ViQuaternion rotateQuat = ViQuaternion.FromAxisAngle(rotateAxis, deltaAngle);
ViVector3 newDir = rotateQuat * _direction;
newDir.Normalize();
_velocity = (newDir + _direction) * _speed * 0.5f;
if (ViVector3.Dot(ViVector3.Cross(_direction, newDir), ViVector3.Cross(newDir, diffDir)) < 0.0f) // 插值抖动
{
_lateralSign = 0.0f;
_direction = diffDir;
}
else
{
_direction = newDir;
_lateralSign = (rotateAxis.z > 0.0f) ? 1.0f : -1.0f;
}
}
}
public override void Start(float duration)
{
ViDebuger.AssertWarning(Target);
if (Target == null)
{
Target = new ViSimpleProvider <ViVector3>();
}
_velocity = ViVector3.ZERO;
_duration = ViMathDefine.Max(0.01f, duration);
ViVector3 targetPos = Target.Value;
float distanceH = ViMath2D.Length(targetPos.x, targetPos.y, Translate.x, Translate.y);
float distanceV = targetPos.z - Translate.z;
float time = distanceV / m_GravityAcc / _duration;
float preDeltaTime = _duration * 0.5f + time;
float aftDeltaTime = _duration * 0.5f - time;
_velocity.z = preDeltaTime * m_GravityAcc;
}
public bool Update(float deltaTime, float newDir)
{
if (newDir == _curDiretion)
{
return(false);
}
float maxRot = deltaTime * _rotSpd;
float deltaAngle = newDir - _curDiretion;
ViAngle.Normalize(ref deltaAngle);
if (Math.Abs(deltaAngle) < maxRot)
{
_curDiretion = newDir;
}
else
{
_curDiretion += maxRot * ViMathDefine.Sign(deltaAngle);
}
ViAngle.Normalize(ref _curDiretion);
return(true);
}
public bool Update(float deltaTime, float newDir)
{
float deltaAngle = newDir - _curDiretion;
if (deltaAngle == 0.0f)
{
return(false);
}
ViAngle.Normalize(ref deltaAngle);
float maxRot = 0.0f;
if (deltaAngle > 0.0f)
{
_currentSpeed = Math.Abs(_currentSpeed);
float newSpd = _currentSpeed + _accelerate * deltaTime;
float maxSpd = ViMathDefine.Sqrt(deltaAngle * _accelerate * 2.0f);
_currentSpeed = ViMathDefine.Min(ViMathDefine.Min(newSpd, maxSpd), _maxSpeed);
maxRot = _currentSpeed * deltaTime;
}
else
{
_currentSpeed = -Math.Abs(_currentSpeed);
float newSpd = _currentSpeed - _accelerate * deltaTime;
float maxSpd = -ViMathDefine.Sqrt(-deltaAngle * _accelerate * 2.0f);
_currentSpeed = ViMathDefine.Max(ViMathDefine.Max(newSpd, maxSpd), -_maxSpeed);
maxRot = _currentSpeed * deltaTime;
}
if (Math.Abs(deltaAngle) < Math.Abs(maxRot))
{
_curDiretion = newDir;
_currentSpeed = 0.0f;
}
else
{
_curDiretion += maxRot;
}
ViAngle.Normalize(ref _curDiretion);
return(true);
}
public override void _Update(float deltaTime, ViVector3 target)
{
ViDebuger.AssertWarning(deltaTime > 0.0f);
ViDebuger.AssertWarning(_speed > 0.0f);
//
//
ViVector3 targetPos = Target.Value;
float distanceH = ViMath2D.Length(targetPos.x, targetPos.y, Translate.x, Translate.y);
float distanceV = targetPos.z - Translate.z;
float time = distanceH / _speed;
m_GravityAcc = -2.0f * (distanceV / (time * time) - _velocity.z / time);
m_GravityAcc = ViMathDefine.Clamp(m_GravityAcc, -GRAVITY, 5.0f * GRAVITY);
ViVector3 kDir = targetPos - Translate;
kDir.z = 0.0f;
kDir.Normalize();
_velocity.x = kDir.x * _speed;
_velocity.y = kDir.y * _speed;
_velocity.z -= m_GravityAcc * deltaTime;
_direction = _velocity;
_direction.Normalize();
}
public float GetDistance(ViVector3 pos)
{
float diff = GetHorizontalDistance(pos, Position);
return(ViMathDefine.Max(0.0f, diff - BodyRadius));
}
public static ViVector3 Max(ViVector3 lhs, ViVector3 rhs)
{
return(new ViVector3(ViMathDefine.Max(lhs.x, rhs.x), ViMathDefine.Max(lhs.y, rhs.y), ViMathDefine.Max(lhs.z, rhs.z)));
}
public static float Magnitude(ViVector3 a)
{
return(ViMathDefine.Sqrt(((a.x * a.x) + (a.y * a.y)) + (a.z * a.z)));
}
public static float Angle(ViVector3 from, ViVector3 to)
{
return(ViMathDefine.Acos(ViMathDefine.Clamp(Dot(from.normalized, to.normalized), -1f, 1f)));
}
