Editor

First, add transition components to your GameObject. If you click the Add Component button and type in "Transition", you will see a list of all available components. For example, the Transform.localPosition Transition (LeanTransformLocalPosition) component can be added to your GameObject, allowing you t alter the Transform component's localPosition setting.

Next, you must begin the transition. This can be done using many different methods:

Code

First, you must use the Lean.Transition namespace. Put this at the top of your source file:

using Lean.Transition;

This namespace includes all the extension methods for you to use.

Next, simply replace your normal code with transition variants. For example:

// Instantly change our transform component's localPosition to 10, 10, 10
transform.localPosition = new Vector3(10, 10, 10);

Can be turned into:

// Gradually change our transform component's localPosition to 10, 10, 10 over 0.5 seconds
transform.localPositionTransition(new Vector3(10, 10, 10), 0.5f);

It's as simple as that!

Basic

Ease functions allow you control how a value transitions from its original value to its target value.

Advanced

The advanced list of ease functions contains most ease methods commonly seen in other software, though their names may be hard to understand. You can view more information online on sites like THIS.

Editor

Simply add the LeanJoin component between them.

Code

You must call the JoinTransition() method between them. For example:

transform.
	localPositionTransition(new Vector3(10, 10, 10), 0.5f).
	JoinTransition().
	localPositionTransition(new Vector3(1, 1, 1), 0.5f);

Editor

Instead of connecting transitions with the LeanJoin component, use the LeanJoinDelay component.

Code

Instead of calling the JoinTransition() method, use the JoinDelayTransition() method. For example:

transform.
	localPositionTransition(new Vector3(10, 10, 10), 0.5f).
	JoinDelayTransition(5.0f).
	localPositionTransition(new Vector3(1, 1, 1), 0.5f);

Editor

Instead of connecting transitions with the LeanJoin component, use the LeanJoinInsert component.

Code

Instead of calling the JoinTransition() method, use the JoinInsertTransition() method. For example:

transform.
	localPositionTransition(new Vector3(10, 10, 10), 0.5f).
	JoinInsertTransition(gameObjectWithTransitions).
	localPositionTransition(new Vector3(1, 1, 1), 0.5f);

Editor

Instead of connecting transitions with the LeanJoinInsert component, you can manually add the LeanJoin and LeanInsert components.

Instead of connecting transitions with the LeanJoinDelay component, you can manually add the LeanJoin and LeanDelay components.

Code

Instead of calling the JoinDelayTransition() method, you can manually call the JoinTransition() and DelayTransition() methods.

Instead of calling the JoinInsertTransition() method, you can manually call the JoinTransition() and InsertTransition() methods.

Editor

Insert the LeanTime() component into your transition, and all transitions after it will use the specified time.

Code

Simply call the TimeTransition() method, and all transitions after it will use the specified time.

Editor

You can add the LeanEvent component into your transition, and make the event call a custom function.

Code

Simply call the EventTransition() method, and the specified action will be invoked after the specified time. For example:

transform.EventTransition(() => Debug.Log("Hello World!"), 1.0f);

LeanState
PreviousState

Each time this transition method registers a new state, it will be stored here.

static float
Smooth
LeanEase ease, float x

This will take the input linear 0..1 value, and return a transformed version based on the specified easing function.

T
GetAliasedTarget<T>
T current

This allows you to get the current Target value, or an aliased override.

List<Entry>
Entries

This stores a list of all Transforms containing transitions that will be played, and their settings.

void
Begin

This method will begin all transition entries.

float
Duration

The transition will complete after this many seconds.

float
Age

The current amount of seconds this transition has been running (-1 for pending Begin call).

List<LeanState>
Prev

If this transition is chained to another, then this tells you which must finish before this can begin.

List<LeanState>
Next

If this transition is chained to another, then this tells you which will begin after this finishes.

bool
Ignore

If this is enabled then the current transition will no longer update, but will otherwise act as normal and not be removed. This is so any transition chain can still work as expected.

float
Remaining

This tells you how many seconds remain until this state completes.

void
BeginAfter
LeanState previousState

If you want this transition to begin after another completes, then call this method.

void
Skip

This will instantly skip this transition to its final state.

void
SkipAll

This will instantly skip this transition to its final state, and all others joined to it.

void
Stop

This will stop this transition at its current position.

void
StopAll

This will stop this transition at its current position, and all others joined to it.

T
Target

This is the target of the transition. For most transition methods this will be the component that will be modified.

LeanTiming
DefaultTiming

This allows you to set where in the game loop animations are updated when timing = LeanTime.Default.

static List<LeanTransition>
Instances

This stores a list of all active and enabled LeanTransition instances in the scene.

static LeanTiming
CurrentDefaultTiming

This property gives you the first DefaultTiming instance value.

static int
Count

This tells you how many transitions are currently running.

static LeanState
PreviousState

After a transition state is registered, it will be stored here. This allows you to copy it out for later use.

static LeanState
CurrentQueue

If you want the next registered transition state to automatically begin after an existing transition state, then specify it here.

static LeanTiming
CurrentTiming

This allows you to change where in the game loop all future transitions in the current animation will be updated.

static float
CurrentSpeed

This allows you to change the transition speed multiplier of all future transitions in the current animation.

static Dictionary<string, Object>
CurrentAliases

This allows you to change the alias name to UnityEngine.Object association of all future transitions in the current animation.

static LeanTiming
GetTiming
LeanTiming current = LeanTiming.Default

This method will return the specified timing, unless it's set to Default, then it will return UnscaledTime.

static LeanTiming
GetTimingAbs
LeanTiming current

This method works like GetTiming, but it won't return any unscaled times.

static void
RequireSubmitted

If you failed to submit a previous transition then this will throw an error, and then submit them.

static void
ResetTiming

This will reset any previously called CurrentTiming calls.

static void
ResetQueue

This will reset any previously called CurrentQueue calls.

static void
ResetSpeed

This will reset any previously called CurrentSpeed calls.

static void
ResetState

This will reset the CurrentTiming, CurrentQueue, and CurrentSpeed values.

static void
Submit

This will submit any previously registered transitions, and reset the timing.

static void
BeginAllTransitions
Transform root, float speed = 1.0f

This will begin all transitions on the specified GameObject, all its children, and then submit them.

If you failed to submit a previous transition then this will also throw an error.

static void
InsertTransitions
GameObject root, float speed = 1.0f, LeanState parentHead = null

This will begin all transitions on the specified GameObject, and all its children.

static void
InsertTransitions
Transform root, float speed = 1.0f, LeanState parentHead = null

This will begin all transitions on the specified Transform, and all its children.

static Dictionary<string,System.Type>
FindAllAliasTypePairs
Transform root

This method returns all TargetAliases on all transitions on the specified Transform.

int
RemainingCount

The amount of times this component can begin the specified transitions.

-1 = Unlimited.

float
RemainingTime

When this reaches 0, the transitions will begin.

float
TimeInterval

When RemainingTime reaches 0, it will bet set to this value.

UnityEvent
OnAnimation

The event will execute when the transitions begin.

LeanPlayer
Transitions

This allows you to specify the transitions this component will begin.

You can create a new transition GameObject by right clicking the transition name, and selecting Create.

For example, the Graphic.color Transition (LeanGraphicColor) component can be used to change the color back to normal.

void
BeginTransitions

This method will execute all transitions on the Transform specified in the Transitions setting.

void
StopTransitions

This method will stop all transitions that were begun from this component.

void
SkipTransitions

This method will skip all transitions that were begun from this component.