User Interface Basics
The GraphN user interface is roughly split between two main sections: the Homepage, and the Graph view.
The GraphN homepage contains everything you need to quickly get started:
The first section contains:
The GraphN version you're currently using.
The Create New Project button, which is the easiest way of creating a new graph.
The Install Autodesk Maya Integration button, which helps you connect Maya to GraphN. To use it, click on that button and the following popup will show up. All you have to do then is drag and drop the Polygonflow logo onto the Maya viewport, and you should be all set!
The Install Unreal Engine Integration button, which helps you connect Unreal Engine 5 to GraphN. Keep in mind that only UE5.0+ is supported, and the UE5.0EA versions are not supported, nor are the 4.X versions. To install this integration, simply click on the button and you should see the follow-up popup:
By default, we automatically detect the latest version of UE5.X that you have on disk, but if you happen to have UE5 in multiple locations, what you can do is open up the version of UE5 you want to install the integration to, then click again on the button on the homepage, and GraphN will detect the currently running UE version, and ask you to confirm the installation there.
The second section contains various links to tutorials, this documentation, and other learning content.
The third and fourth sections contain the Preset Graphs section and the Recent Graphs section. We highly recommend you to check out the preset graphs as they're a treasure trove of information that can help you quickly get up to speed on how GraphN works, and how to get the most out of it.
And then you have the graph view, which is where you can create your graphs, run them in other 3D software, or export them to the GraphN Library. For starters, the graph view provides various base layouts for you to pick from:
You could also create your own custom layout by simply adding or removing various panels, then saving the layout like so:
If you look at the menu bar right here:
The first four square icons on the left represent four different base layouts for your GraphN user interface. The button with the green text is a dropdown that shows you the list of DCCs that are currently running on your machine, with GraphN installed in them. You can select any software in that dropdown, and GraphN will connect to it.
- The Export Graph button helps you export your graphs to use them straight within your DCC, without needing GraphN (more on that right here).
- The Runtime checkbox is there to toggle runtime execution to your connected DCC, in this case, Maya 2023. If checked, anytime you change a parameter or move a slider in GraphN, the graph will run in your DCC and update its result.
- If Runtime is unchecked, you'd have to either press on the Run button to the right or hit CTRL+R to run your graph.
You can zoom in and out of the graph with your mouse wheel, pan with the middle mouse button, and focus on any selected nodes with the F shortcut. Moving nodes is as simple as selecting them and dragging them with your left-click mouse button. Deleting a node can be done by hitting Backspace or Del on your keyboard.
To add a node, simply press Space or Tab, and the node search bar will show up; from there you can type in the name of your node, use the up and down keys to move along your search stack, and select the node of your choosing by hitting Enter while it's highlighted, or by simply clicking on it.
Nodes offer a wide range of interactions, let's dive into each one of them.
To connect nodes, simply drag one compatible socket to another corresponding compatible socket. Connections follow a bunch of different rules to avoid illogical behaviors. For example, an input socket cannot be connected to another input socket, and for a connection between two sockets to happen, they need to share the same type.
If you select the node Create Sphere, you'll notice that it has a bunch of properties in the properties editor, yet they don't show up visually on the node in the GIF above; This is because most properties are hidden by default, and only visible through the properties editor. You can easily change that by clicking on the three dots on the top-right corner of the node, then either checking specific properties you want to display on the node's body, or showing all of them at once.
If we wanted to set the radius of the Create Sphere node, we could either manually enter the radius we want in the properties editor panel, or derive our radius from a node named Values, which allows you to create basic values like floats, integers, strings and so on. To create it, simply hit space and type "values" to find the node, or hit ALT+V as a shortcut to spawn the node. The Values node has a Type dropdown with all the data types in GraphN, and the value we want to modify is of type Float. You can check that by hovering over its socket:
As you can see, hovering over a node socket gives you its description, and supported types. Back to our Values node, this is how we'd create it, then connect it:
Lastly, one common concept you'll come across is that of Variants, which allows one property to have multiple data types. For example, you may have a node that rotates all your objects by a certain angle, and it could either accept one floating value like 90 to rotate them all by that value or it could accept multiple values like 90, 68, 56, 87 and so on, where each object would have one random rotation, basically. This is where variants are crucial: they allow one property to accept either of those two data types.
To illustrate this, look at this node screenshot, and notice how the Angle socket has an arc in front of it; that arc is there to tell you that this property is a variant, and when you hover over it, you'll see the different data types that can be connected to it, in this case, a Float and FloatArray.
Connecting variant properties is pretty straightforward: just give it a Float or FloatArray, and the node will intuitively accept them:
We dive more into GraphN data types right here, but the gist of it is that:
- You can hover over any socket to know its data type.
- There are three main types:
- Arrays types (like float array, mesh container, etc..).
- Single types (like float, int, string).
- Others (callback type, Any type), which are much less common.
- All data types are color-coded
- There are a lot of safeguards to assist you with socket connections.
GraphN features a wide range of editor panels that can help you with various tasks. You can open them in the Panels menu in the top-left corner of the software. The first and most useful one is the Log panel, which displays all the editor log data in your current GraphN session; such as bugs and other info that can be useful to understand why something isn't behaving properly. This is how you can open the log panel:
Other panels such as the History panel help you visualize all your Undo steps, and you can go up and down in that history stack very intuitively
At its core, GraphN converts the graphs you build into executable Python code, and you can visualize that Python code by opening the Code View panel:
While still fairly early, the Preferences in GraphN gives you some basic control over your software. For starters, you can quickly change the background drawing style grom grid, dots, stars, and empty background overlays.
You can also adjust the behavior of Autosave:
Or enable hardware acceleration, which ensures that most of the graph's rendering happens on the GPU instead of the CPU.