﻿ Unity Script Reference:
Vector3.Lerp
static function Lerp(from: Vector3, to: Vector3, t: float): Vector3;
static Vector3 Lerp(Vector3 from, Vector3 to, float t);
static def Lerp(from as Vector3, to as Vector3, t as float) as Vector3
Description

Linearly interpolates between two vectors.

Interpolates between `from` and `to` by the fraction `t`. This is most commonly used to find a point some fraction of the way along a line between two endpoints (eg, to move an object gradually between those points). This fraction is clamped to the range [0...1]. When `t` = 0 returns `from`. When `t` = 1 returns `to`. When `t` = 0.5 returns the point midway between `from` and `to`.
```	// Transforms to act as start and end markers for the journey.
var startMarker: Transform;
var endMarker: Transform;

// Movement speed in units/sec.
var speed = 1.0;

// Time when the movement started.
private var startTime: float;

// Total distance between the markers.
private var journeyLength: float;

var target : Transform;
var smooth = 5.0;

function Start() {
// Keep a note of the time the movement started.
startTime = Time.time;

// Calculate the journey length.
journeyLength = Vector3.Distance(startMarker.position, endMarker.position);
}

// Follows the target position like with a spring
function Update () {
// Distance moved = time * speed.
var distCovered = (Time.time - startTime) * speed;

// Fraction of journey completed = current distance divided by total distance.
var fracJourney = distCovered / journeyLength;

// Set our position as a fraction of the distance between the markers.
transform.position = Vector3.Lerp(startMarker.position, endMarker.position, fracJourney);
}
```
```using UnityEngine;
using System.Collections;

public class Example : MonoBehaviour {
public Transform startMarker;
public Transform endMarker;
public float speed = 1.0F;
private float startTime;
private float journeyLength;
public Transform target;
public float smooth = 5.0F;
void Start() {
startTime = Time.time;
journeyLength = Vector3.Distance(startMarker.position, endMarker.position);
}
void Update() {
float distCovered = (Time.time - startTime) * speed;
float fracJourney = distCovered / journeyLength;
transform.position = Vector3.Lerp(startMarker.position, endMarker.position, fracJourney);
}
}
```
```import UnityEngine
import System.Collections

public class Example(MonoBehaviour):

public startMarker as Transform

public endMarker as Transform

public speed as float = 1.0F

private startTime as float

private journeyLength as float

public target as Transform

public smooth as float = 5.0F

def Start() as void:
startTime = Time.time
journeyLength = Vector3.Distance(startMarker.position, endMarker.position)

def Update() as void:
distCovered as float = ((Time.time - startTime) * speed)
fracJourney as float = (distCovered / journeyLength)
transform.position = Vector3.Lerp(startMarker.position, endMarker.position, fracJourney)

```