Hareket, Time.deltaTime kullanılmasına rağmen kare hızına bağlı gibi görünüyor

Ben denir Unity, bir oyun nesnesini taşımak için gerekli çeviri hesaplamak için aşağıdaki kodu var LateUpdate. Anladığım kadarıyla, benim kullanımım Time.deltaTime, son çeviri kare hızını bağımsız hale getirmelidir (lütfen dikkat edin CollisionDetection.Move(), sadece rekolte yapmak).

public IMovementModel Move(IMovementModel model) {    
    this.model = model;

    targetSpeed = (model.HorizontalInput + model.VerticalInput) * model.Speed;

    model.CurrentSpeed = accelerateSpeed(model.CurrentSpeed, targetSpeed,
        model.Accel);

    if (model.IsJumping) {
        model.AmountToMove = new Vector3(model.AmountToMove.x,
            model.AmountToMove.y);
    } else if (CollisionDetection.OnGround) {
        model.AmountToMove = new Vector3(model.AmountToMove.x, 0);
    }

    model.FlipAnim = flipAnimation(targetSpeed);
    // If we're ignoring gravity, then just use the vertical input.
    // if it's 0, then we'll just float.
    gravity = model.IgnoreGravity ? model.VerticalInput : 40f;

    model.AmountToMove = new Vector3(model.CurrentSpeed, model.AmountToMove.y - gravity * Time.deltaTime);

    model.FinalTransform =
        CollisionDetection.Move(model.AmountToMove * Time.deltaTime,
            model.BoxCollider.gameObject, model.IgnorePlayerLayer);
    // Prevent the entity from moving too fast on the y-axis.
    model.FinalTransform = new Vector3(model.FinalTransform.x,
        Mathf.Clamp(model.FinalTransform.y, -1.0f, 1.0f),
        model.FinalTransform.z);

    return model;
}

private float accelerateSpeed(float currSpeed, float target, float accel) {
    if (currSpeed == target) {
        return currSpeed;
    }
    // Must currSpeed be increased or decreased to get closer to target
    float dir = Mathf.Sign(target - currSpeed);
    currSpeed += accel * Time.deltaTime * dir;
    // If currSpeed has now passed Target then return Target, otherwise return currSpeed
    return (dir == Mathf.Sign(target - currSpeed)) ? currSpeed : target;
}

private void OnMovementCalculated(IMovementModel model) {
    transform.Translate(model.FinalTransform);
}

Oyunun karesini 60FPS'ye kilitlersem, nesnelerim beklendiği gibi hareket eder. Ancak, kilidini Application.targetFrameRate = -1;açarsam ( ), bazı nesneler çok daha yavaş bir hızda hareket edecek, o zaman 144hz monitörde ~ 200FPS elde ederken beklenir. Bu, yalnızca bağımsız bir yapıda gerçekleşiyor gibi görünüyor, Unity editöründe değil.

Editör içindeki nesne hareketinin GIF'i, kilidi açılmış FPS

http://gfycat.com/SmugAnnualFugu

Bağımsız yapı içindeki nesne hareketinin GIF'i, kilidi açılmış FPS

http://gfycat.com/OldAmpleJuliabutterfly

Kare tabanlı simülasyonlar, güncellemeler doğrusal olmayan değişim oranlarını telafi edemediğinde hatalarla karşılaşır.

Örneğin sıfırın konum ve hız değerleriyle başlayan bir nesneyi, sabit bir ivmelenmesi ile düşünün.

Bu güncelleme mantığını uygularsak:

velocity += acceleration * elapsedTime
position += velocity * elapsedTime

Bu sonuçları farklı kare hızlarında bekleyebiliriz:

Hata, nihai hızın tüm çerçeve için uygulanmış gibi işlenmesinden kaynaklanır. Bu, Sağ Riemann Toplamına benzer ve hata miktarı kare hızına göre değişir (farklı bir işlevde gösterilmiştir):

MichaelS'ın işaret ettiği gibi , kare süresi yarıya düştüğünde bu hata yarıya iner ve yüksek kare hızlarında önemsiz hale gelebilir. Öte yandan, performans artışı veya uzun süren kareler yaşayan oyunlar bunun öngörülemeyen davranışlar ürettiğini görebilir.

Neyse ki kinematik , doğrusal hızlanmanın neden olduğu yer değiştirmeyi doğru bir şekilde hesaplamamızı sağlar:

d =  vᵢ*t + (a*t²)/2

where:
  d  = displacement
  vᵢ = initial velocity
  a  = acceleration
  t  = elapsed time

breakdown:
  vᵢ*t     = movement due to the initial velocity
  (a*t²)/2 = change in movement due to acceleration throughout the frame

Bu güncelleme mantığını uygularsak:

position += (velocity * elapsedTime) + (acceleration * elapsedTime * elapsedTime / 2)
velocity += acceleration * elapsedTime

Aşağıdaki sonuçları elde edeceğiz:

Adımınızı nereden aradığınıza bağlıdır. Güncelleme'den çağırıyorsanız, Time.deltaTime ile ölçeklendirirseniz, hareketiniz gerçekten kare hızından bağımsız olacaktır, ancak FixedUpdate'den çağırıyorsanız, Time.fixedDeltaTime ile ölçeklendirmeniz gerekir. Adımınızı FixedUpdate'den çağırdığınızı, ancak Time.deltaTime ile ölçeklendirdiğinizi düşünüyorum, bu da Unity'nin sabit adımı ana döngüden daha yavaş olduğunda görünen hızın düşmesine neden olacak, bu da bağımsız derlemenizde gerçekleşiyor. Sabit adım yavaş olduğunda fixedDeltaTime büyüktür.