Interpolation¶

Interpolation ist eine sehr grundlegende Operation in der Grafikprogrammierung. Es ist gut sich damit vertraut zu machen um Ihren Horizont als Grafikentwickler zu erweitern.

Die Grundidee ist, dass Sie von A nach B wechseln möchten. Ein Wert t repräsentiert die dazwischen liegenden Zustände.

Wenn beispielsweise t 0 ist, ist der Zustand A. Wenn t 1 ist, ist der Zustand B. Alles dazwischen ist eine * Interpolation *.

Zwischen zwei reellen (Gleitkomma-) Zahlen wird eine einfache Interpolation normalerweise beschrieben als:

interpolation = A * (1 - t) + B * t

Und oft vereinfacht zu:

interpolation = A + (B - A) * t

Der Name dieser Art der Interpolation, die mit konstanter Geschwindigkeit einen Wert in einen anderen umwandelt, lautet "linear". Wenn Sie also von Lineare Interpolation hören, wissen Sie, dass sie sich auf diese einfache Formel beziehen.

Es gibt andere Arten von Interpolationen, die hier nicht behandelt werden. Eine empfohlene Lektüre ist anschließend die Seite Bezier.

Vektorinterpolation¶

Vektortypen (Vector2 and Vector3) können auch interpoliert werden, sie verfügen über praktische Funktionen, um dies zu tun Vector2.linear_interpolate() und Vector3.linear_interpolate().

Für die kubische Interpolation gibt es auch Vector2.cubic_interpolate() und Vector3.cubic_interpolate(), welche eine Interpolation im Stil einer Bezier-Kurve durchführen.

Hier ist ein einfacher Pseudocode für die Strecke von Punkt A nach Punkt B mithilfe von Interpolation:

var t = 0.0

func _physics_process(delta):
    t += delta * 0.4

    $Sprite.position = $A.position.linear_interpolate($B.position, t)

private float _t = 0.0f;

public override void _PhysicsProcess(float delta)
{
    _t += delta * 0.4f;

    Position2D a = GetNode<Position2D>("A");
    Position2D b = GetNode<Position2D>("B");
    Sprite sprite = GetNode<Sprite>("Sprite");

    sprite.Position = a.Position.LinearInterpolate(b.Position, _t);
}

Es wird die folgende Bewegung produzieren:

Interpolation transformieren¶

Es ist auch möglich ganze Transformationen zu interpolieren (stellen Sie sicher, dass sie entweder eine einheitliche Skalierung oder mindestens dieselbe ungleichmäßige Skalierung haben). Hierzu kann die Funktion Transform.interpolate_with() verwendet werden.

Hier ist ein Beispiel für die Umwandlung eines Affen von Position1 in Position2:

../../_images/interpolation_positions.png

Beim Benutzen des folgenden Pseudocodes:

var t = 0.0

func _physics_process(delta):
    t += delta

    $Monkey.transform = $Position1.transform.interpolate_with($Position2.transform, t)

private float _t = 0.0f;

public override void _PhysicsProcess(float delta)
{
    _t += delta;

    Position3D p1 = GetNode<Position3D>("Position1");
    Position3D p2 = GetNode<Position3D>("Position2");
    CSGMesh monkey = GetNode<CSGMesh>("Monkey");

    monkey.Transform = p1.Transform.InterpolateWith(p2.Transform, _t);
}

Und wieder wird die folgende Bewegung erzeugt:

Glatte Bewegung¶

Interpolation kann verwendet werden, um Bewegung, Drehung, usw. zu glätten. Hier ist ein Beispiel für einen Kreis, der der Maus mit geglätteter Bewegung folgt:

const FOLLOW_SPEED = 4.0

func _physics_process(delta):
    var mouse_pos = get_local_mouse_position()

    $Sprite.position = $Sprite.position.linear_interpolate(mouse_pos, delta * FOLLOW_SPEED)

private const float FollowSpeed = 4.0f;

public override void _PhysicsProcess(float delta)
{
    Vector2 mousePos = GetLocalMousePosition();

    Sprite sprite = GetNode<Sprite>("Sprite");

    sprite.Position = sprite.Position.LinearInterpolate(mousePos, delta * FollowSpeed);
}

So sieht es aus:

Dies ist nützlich für sanfte Kamerabewegungen, Ihnen folgende Verbündete (um sicherzustellen, dass sie in einem bestimmten Bereich bleiben) und viele andere gängige Spielmuster.