Unity Graph Toolkit

https://docs.unity3d.com/Packages/com.unity.graphtoolkit@0.4/manual/
Admin
Unity Graph Toolkit provides a comprehensive framework for developing node-based tools within the...
Tokens:17,709
Snippets:307
Trust Score:10
Update:4 months ago
Show doc for...
Tokens:
Raw
### Complete Node Implementation Example

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/node-implement.html

A final example combining the node class definition and port configuration. This demonstrates a fully functional custom node with input and output ports, including typed ports.

```csharp
[Serializable]
public class BasicNodeFinal : Node
{
    protected override void OnDefinePorts(IPortDefinitionContext context)
    {
        context.AddInputPort("Input").Build();
        context.AddInputPort<int>("a").Build();

        context.AddOutputPort("Output").Build();
        context.AddOutputPort<int>("result").Build();
    }
}

```

--------------------------------

### Customize Port UI

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/node-implement.html

Customize the appearance and behavior of ports using optional methods like `WithDisplayName` and `WithConnectorUI`. This example shows how to set a custom display name and use an arrowhead connector.

```csharp
context.AddInputPort<int>("a")
    .WithDisplayName("My Int")
    .WithConnectorUI(PortConnectorUI.Arrowhead)
    .Build();

```

--------------------------------

### Define a Custom Graph Class with Asset Creation

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/get-started-coding.html

Creates a custom graph class inheriting from 'Graph', specifying an asset extension and a menu item for creating new graph assets in the editor.

```csharp
[Graph(AssetExtension)]
[Serializable]
class MySimpleGraph : Graph
{
    public const string AssetExtension = "simpleg";

    [MenuItem("Assets/Create/Graph Toolkit Samples/Simple Graph", false)]
    static void CreateAssetFile()
    {
        GraphDatabase.PromptInProjectBrowserToCreateNewAsset<MySimpleGraph>();
    }
}
```

--------------------------------

### Define a Custom Node with Input and Output Ports

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/get-started-coding.html

Extends a custom node to include a float input port and a custom type output port using the 'OnDefinePorts' method.

```csharp
[Serializable]
class MySimpleNodeWithPorts : Node
{
    protected override void OnDefinePorts(IPortDefinitionContext context)
    {
        context.AddInputPort<float>("Input").Build();
        context.AddOutputPort<MyCustomType>("Output").Build();
    }
}
```

--------------------------------

### Define Custom Node Options

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/node-option.html

Implement `OnDefineOptions` to add custom integer and enum options to a node. Use `AddOption` with `WithDisplayName` and `WithDefaultValue`. The `Delayed` modifier ensures the option's value is only applied after the user confirms changes.

```csharp
[Serializable]
public class NodeWithOptions : Node
{
    enum PortTypes
    {
        Vec2,
        Vec3
    }

    const string k_PortCountName = "PortCount";
    const string k_PortTypeName = "PortType";

    protected override void OnDefineOptions(IOptionDefinitionContext context)
    {
        context.AddOption<int>(k_PortCountName)
            .WithDisplayName("Port Count")
            .WithDefaultValue(2)
            .Delayed();
        context.AddOption<PortTypes>(k_PortTypeName);
    }

    protected override void OnDefinePorts(IPortDefinitionContext context)
    {
        var portCountOption = GetNodeOptionByName(k_PortCountName);
        portCountOption.TryGetValue<int>(out var portCount);
        for (var i = 0; i < portCount; i++)
        {
            context.AddInputPort<Vector2>($"{i}").Build();
        }

        var portTypeOption = GetNodeOptionByName(k_PortTypeName);
        portTypeOption.TryGetValue<PortTypes>(out var portType);

        if (portType == PortTypes.Vec3)
        {
            context.AddOutputPort<Vector3>("result").Build();
        }
        else
        {
            context.AddOutputPort<Vector2>("result").Build();
        }
    }
}
```

--------------------------------

### Define Node Option for Port Count

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/node-option.html

Override OnDefineOptions to add an integer option that controls the number of ports. Use WithDefaultValue to set an initial port count and Delayed() to defer processing until input is complete.

```csharp
const string k_PortCountName = "PortCount";

protected override void OnDefineOptions(IOptionDefinitionContext context)
{
    context.AddOption<int>(k_PortCountName)
        .WithDisplayName("Port Count")
        .WithDefaultValue(2)
        .Delayed();
}
```

--------------------------------

### Define a Simple Graph Asset

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/get-started-coding.html

This script defines a basic graph asset with a custom asset extension and a menu item for creating new instances in the Project Browser.

```csharp
#region Imports
using System;
using UnityEditor;
using UnityEngine;
using Unity.GraphToolkit.Editor;
#endregion Imports

namespace Samples.DocCodeSamples.Editor
{
    #region SimpleGraph
    [Graph(AssetExtension)]
    [Serializable]
    class MySimpleGraph : Graph
    {
        public const string AssetExtension = "simpleg";

        [MenuItem("Assets/Create/Graph Toolkit Samples/Simple Graph", false)]
        static void CreateAssetFile()
        {
            GraphDatabase.PromptInProjectBrowserToCreateNewAsset<MySimpleGraph>();
        }
    }
    #endregion SimpleGraph

    class MyCustomType : ScriptableObject
    {
    }

    #region SimpleNode
    [Serializable]
    class MySimpleNode : Node {}
    #endregion SimpleNode

    #region SimpleNodeWithPorts
    [Serializable]
    class MySimpleNodeWithPorts : Node
    {
        protected override void OnDefinePorts(IPortDefinitionContext context)
        {
            context.AddInputPort<float>("Input").Build();
            context.AddOutputPort<MyCustomType>("Output").Build();
        }
    }
    #endregion SimpleNodeWithPorts
}
```

--------------------------------

### Define Ports Based on Port Count Option

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/node-option.html

Implement OnDefinePorts to create input ports dynamically based on the value of the port count option. The number of ports is determined by the user-configured option.

```csharp
protected override void OnDefinePorts(IPortDefinitionContext context)
{
    var portCountOption = GetNodeOptionByName(k_PortCountName);
    portCountOption.TryGetValue<int>(out var portCount);
    for (var i = 0; i < portCount; i++)
    {
        context.AddInputPort<Vector2>($"{i}").Build();
    }

    context.AddOutputPort<Vector2>("result").Build();
}
```

--------------------------------

### Import Necessary Namespaces for Graph Toolkit

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/get-started-coding.html

Imports essential namespaces for creating custom graph and editor functionalities within Unity's Graph Toolkit.

```csharp
using System;
using UnityEditor;
using UnityEngine;
using Unity.GraphToolkit.Editor;
```

--------------------------------

### Define a Basic Block Node

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/context-node-implement-block-node.html

This snippet shows the basic implementation of a block node, inheriting from BlockNode and connected to a single context node using the UseWithContext attribute.

```csharp
[UseWithContext(typeof(MyContextNode))]
[Serializable]
public class MyBlockNode : BlockNode
{
}
```

--------------------------------

### Define Node Ports

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/node-implement.html

Override the `OnDefinePorts` method to configure input and output ports. Use `AddInputPort` and `AddOutputPort` to define ports with or without specific data types. Ports can be connection-only if no type is specified.

```csharp
protected override void OnDefinePorts(IPortDefinitionContext context)
{
    context.AddInputPort("Input").Build();
    context.AddInputPort<int>("a").Build();

    context.AddOutputPort("Output").Build();
    context.AddOutputPort<int>("result").Build();
}

```

--------------------------------

### Define a Block Node with Multiple Contexts

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/context-node-implement-block-node.html

This snippet demonstrates how to associate a block node with multiple context nodes by listing them in the UseWithContext attribute.

```csharp
[UseWithContext(typeof(MyContextNode), typeof(MyOtherContextNode))]
[Serializable]
public class MyBlockNodeWithMultipleContexts : BlockNode
{
}
```

--------------------------------

### Define Node Option for Port Type

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/node-option.html

Create a node option that uses an enum to allow users to switch between different port data types. Delayed() is not needed here as the port type should update immediately.

```csharp
enum PortTypes
{
    Vec2,
    Vec3
}

const string k_PortTypeName = "PortType";

protected override void OnDefineOptions(IOptionDefinitionContext context)
{
    context.AddOption<PortTypes>(k_PortTypeName).WithDisplayName("Port Type");
}
```

--------------------------------

### Define a Basic Node Class

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/node-implement.html

Create a new node type by inheriting from the `Node` base class. Ensure the class is marked as `Serializable` for graph asset persistence. The class name will be used as the node's title.

```csharp
[Serializable]
public class BasicNode : Node
{
}

```

--------------------------------

### Assembly Definition for Graph Toolkit Editor Scripts

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/get-started-coding.html

Defines an assembly targeting the Editor, including necessary Graph Toolkit references. Ensure this targets the Editor platform only.

```json
{
    "name": "Unity.GraphToolkit.DocCodeSamples",
    "rootNamespace": "Unity.GraphToolkit.DocCodeSamples",
    "references": [
        "Unity.GraphToolkit.Editor",
        "Unity.GraphToolkit.Common.Editor"
    ],
    "includePlatforms": [
        "Editor"
    ]
}
```

--------------------------------

### Define a Basic Custom Node

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/get-started-coding.html

A minimal custom node class that extends 'Node'. It is automatically registered and discoverable due to being in the same assembly as the graph.

```csharp
[Serializable]
class MySimpleNode : Node {}
```

--------------------------------

### Define Ports Based on Port Type Option

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/node-option.html

Implement OnDefinePorts to conditionally add output ports based on the selected enum value from the port type option. This allows the node to output different data types.

```csharp
protected override void OnDefinePorts(IPortDefinitionContext context)
{
    var portTypeOption = GetNodeOptionByName(k_PortTypeName);
    portTypeOption.TryGetValue<PortTypes>(out var portType);

    if (portType == PortTypes.Vec3)
    {
        context.AddOutputPort<Vector3>("result").Build();
    }
    else
    {
        context.AddOutputPort<Vector2>("result").Build();
    }
}
```

--------------------------------

### Define a Custom Context Node

Source: https://docs.unity3d.com/Packages/com.unity.graphtoolkit%400.4/manual/context-node-implement-context-node.html

This C# code defines a basic custom context node by inheriting from the `ContextNode` base class. Ensure the class is marked as `[Serializable]` to be used within Unity's serialization system.

```csharp
using System;
using Unity.Graphing;

[Serializable]
public class MyContextNode : ContextNode
{
}
```
Tokens:
Raw