# Connect<U, V>(U, int, V, int)

> Connects two Playable instances.

## Definition

* **Type:** Method
* **Namespace:** [UnityEngine.Playables](/engine/6000.5/script-reference/unityengine/playables.md)
* **Assembly:** UnityEngine.CoreModule

## Connect\<T, U>(T, int, T, int)

```csharp
public bool Connect<U, V>(U source, int sourceOutputPort, V destination, int destinationInputPort) where U : struct, IPlayable where V : struct, IPlayable
```

### Parameters

**** (T): The source playable or its handle.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The port used in the source playable.**** (T): The destination playable or its handle.**** (\[int]\(https\://learn.microsoft.com/dotnet/api/system.int32)): The port used in the destination playable. If set to -1, a new port is created and connected.

### Returns

| Type                                                          | Description                               |
| ------------------------------------------------------------- | ----------------------------------------- |
| [bool](https://learn.microsoft.com/dotnet/api/system.boolean) | Returns true if connection is successful. |

### Remarks

The connections determine the topology of the [PlayableGraph](/engine/6000.5/script-reference/unityengine/playables/playablegraph.md) and how it is evaluated.

Playables can be connected together to form a tree structure. Each Playable has a set of inputs and a set of outputs. These can be viewed as “slots” where other Playables can be attached to.

When a Playable is first created, its input count is reset to 0, meaning that it has no children Playables attached. Outputs behave a little differently—every Playable has a default output created when first created.

You connect Playables together using the method [PlayableGraph.Connect](/engine/6000.5/script-reference/unityengine/playables/playablegraph/connect.md), and you can disconnect them from each other using [PlayableGraph.Disconnect](/engine/6000.5/script-reference/unityengine/playables/playablegraph/disconnect.md).

There is no limit set on the amount of inputs a Playable can have.

### Examples

```csharp
using UnityEngine;
using UnityEngine.Animations;
using UnityEngine.Playables;

public class GraphCreationSample : MonoBehaviour
{
    PlayableGraph m_Graph;
    public AnimationClip clipA;
    public AnimationClip clipB;

    void Start()
    {
        // Create the PlayableGraph.
        m_Graph = PlayableGraph.Create();

        // Add an AnimationPlayableOutput to the graph.
        var animOutput = AnimationPlayableOutput.Create(m_Graph, "AnimationOutput", GetComponent<Animator>());

        // Add an AnimationMixerPlayable to the graph.
        var mixerPlayable = AnimationMixerPlayable.Create(m_Graph, 2);

        // Add two AnimationClipPlayable to the graph.
        var clipPlayableA = AnimationClipPlayable.Create(m_Graph, clipA);
        var clipPlayableB = AnimationClipPlayable.Create(m_Graph, clipB);

        // Create the topology, connect the AnimationClipPlayable to the
        // AnimationMixerPlayable.
        m_Graph.Connect(clipPlayableA, 0, mixerPlayable, 0);
        m_Graph.Connect(clipPlayableB, 0, mixerPlayable, 1);

        // Use the AnimationMixerPlayable as the source for the AnimationPlayableOutput.
        animOutput.SetSourcePlayable(mixerPlayable);

        // Set the weight for both inputs of the mixer.
        mixerPlayable.SetInputWeight(0, 1);
        mixerPlayable.SetInputWeight(1, 1);

        // Play the graph.
        m_Graph.Play();
    }

    private void OnDestroy()
    {
        // Destroy the graph once done with it.
        m_Graph.Destroy();
    }
}
```