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

Interpolates between `min` and `max` with smoothing at the limits.

This function interpolates between `min` and `max` in a similar way to Lerp. However, the interpolation will gradually speed up from the start and slow down toward the end. This is useful for creating natural-looking animation, fading and other transitions.
```	// Minimum and maximum values for the transition.
var minimum = 10.0;
var maximum = 20.0;

// Time taken for the transition.
var duration = 5.0;

private var startTime: float;

function Start() {
// Make a note of the time the script started.
startTime = Time.time;
}

function Update() {
// Calculate the fraction of the total duration that has passed.
var t = (Time.time - startTime) / duration;
transform.position = Vector3(Mathf.SmoothStep(minimum, maximum, t), 0, 0);
}
```
```using UnityEngine;
using System.Collections;

public class Example : MonoBehaviour {
public float minimum = 10.0F;
public float maximum = 20.0F;
public float duration = 5.0F;
private float startTime;
void Start() {
startTime = Time.time;
}
void Update() {
float t = (Time.time - startTime) / duration;
transform.position = new Vector3(Mathf.SmoothStep(minimum, maximum, t), 0, 0);
}
}
```
```import UnityEngine
import System.Collections

public class Example(MonoBehaviour):

public minimum as float = 10.0F

public maximum as float = 20.0F

public duration as float = 5.0F

private startTime as float

def Start() as void:
startTime = Time.time

def Update() as void:
t as float = ((Time.time - startTime) / duration)
transform.position = Vector3(Mathf.SmoothStep(minimum, maximum, t), 0, 0)

```