UI Series
Version 2.0, Updated Jan 2025 using Octane 2024.1 and Cinema 4D 2025.1.1
About this guide
This guide contains four parts:
- Part I shows how to access and use the node editor in C4D.
- Part II breaks the nodes down into categories and explains what they’re used for.
- Part III is a simple walkthroughs to follow along with.
- Part IV has some general tips and pointers.
This guide is also available in 📄 PDF format here
Introduction
Octane Render - at its core - is a node-based system. If we were to take a look at Octane Standalone (Otoy’s desktop implementation of just the render engine itself), we’d see that there’s no object manager or material manager - everything is done in a node editor, and then it’s only when we select one of the nodes that we see a somewhat familiar list of attributes we can modify on the right.
In order to integrate Octane into Cinema 4D, all the Octane nodes had to be mapped to C4D’s various managers. This is great for quick edits, but becomes incredibly cumbersome and painful when it comes to creating more complicated setups. Fortunately, we do have access to a node editor in Octane for Cinema 4D to help us make sense of it.
When we’re first starting out in Octane - especially if we’ve come from 2D or a non-node based 3D apps - using nodes can be intimidating. It’s a completely different way of thinking about information. This guide was written to help with the transition and make it easier to understand (and eventually learn to love) the Node editor.
When Octane first started out, material editing was the primary focus of the node editor, but as more objects were introduced, the node editor expanded to include lights, environments, other objects, and eventually AOVs.
Important: The main thing to remember is that everything we change in the Node Editor ALSO changes in various editors and attribute managers, and vice versa. It’s the same information, represented in a different way.
A Note about Mac OS
The Mac version of Octane 2024 for C4D mostly has 1:1 parity with the Windows version, but there are visual bugs and issues with the new rounded node style. Things like lack of thumbnails and icons are resolved by going to the Octane Settings (gear icon), then in Settings>Nodes, unchecking “New style”.
Part I
Interacting with the Node Editor
How to access the Node Editor
Depending on what we want to edit, the node editor window can be popped up by either hitting a button that says “Node Editor” (like in a material) or with the small squares-and-connectors icon (like in a light, environment, or other object).
Anatomy of the Node Editor
The gridded area In the middle is where we create and connect nodes. On the left is a scrollable list of available nodes that we can drag out into the node graph area (hidden by default). At the top are small colored boxes that we can use to filter the available node list by category. On the right is an attributes manager window that lets we adjust parameters for the selected node.
Navigating
The same navigation that works in one of C4D’s orthographic views (pan and zoom, but obviously not orbit) also works in the node editor. If we lose track of where we are, we can go to the View menu in the Node Editor and select Frame All, or hit H on the keyboard.
we can scroll the list of nodes on the left by grabbing it with the middle mouse button and dragging up and down. Two-finger scrolling on a trackpad or the scrollwheel on a mouse works here too if we’re not using a 3-button input device.
Editing the Node Editor
There are a bunch of options available for customizing the Node Editor. Some of these are found under the Edit menu, and the rest are in the Octane Settings, in the Settings Tab in Nodes (a shortcut directly to those settings is found in the Node Editor’s Edit menu>Settings).
Creating New Nodes
There are a lot of ways to create new nodes. The most obvious one is to grab a node from the list on the left and drag it into the Node Editor window area somewhere. we can filter this list by turning on and off categories by clicking the little colored boxes in the top left. We can also use the search box at the top to filter the list if we know the name of the node.
We need to make sure we clear the search box and/or turn back on all the tabs at the top once we’re done searching/filtering.
As we become more comfortable with the names of the nodes, we can search for them either by hitting Shift-C or spacebar while we’re in the Node Editor.
If none of those methods work for us, we can also right-click anywhere in the Node Editor and pull up a list of nodes or use the Create menu to get a list.
Making a node from a pin
One of the best ways to create new nodes - especially when starting out - is to think about it in reverse and drag out a wire from a pin in an existing node. When we drop that in and empty space somewhere, it gives us a selection box that only shows nodes that can connect to that pin. This is incredibly helpful while we’re still getting our bearings and don’t know what attaches to what. It’s also helpful after we do know what we’re doing because it’s super fast to add things like projection and transform nodes.
Adjusting Nodes
Important: As of this writing (Octane 2024), there’s a bug in the Mac version of the node editor where the shortcuts don’t appear in the titlebar of a node. They’re actually still there, but the icons are missing.
The workaround is to go to the gear icon in the Live Viewer (Octane Settings), then under the Settings tab and Nodes subtab, uncheck “New style”. This will square off the nodes and generally make them less attractive, but allow us to see the icons.
Octane nodes are made up of a few parts. At the top is a colored titlebar with the name of the node in it. The color refers to the classification of node it is (we’ll learn more about that in the next part of this guide).
The name defaults to the internal name of the node type, but we can change that if we select the node and go to the Basic tab in the attributes manager on the right.
There are a few icons that appear when clicking the titlebar that turn on/off certain info. The arrow to the left of the name collapses the node to just the titlebar. The list icon hides or shows the editable parameters.
Right-clicking the node brings up a list of other things we can do to it. One of the more useful functions here is the ability to disable the preview if we don’t need it.
Finally, resizing a node is done by clicking and dragging the bottom right corner only - we can’t just resize from any edge.
Connecting nodes
Nodes have inputs and outputs. The small yellow circle at the right of the node’s titlebar next to the name is an output, and the gray circle or circles on the left are inputs or pins.
The primary way of connecting two nodes together is to drag a wire (or connector) from the output of one node into the input of another. When dragging a wire, it’ll either turn red or green when it hits a pin in another node. Green means it can connect, red means it can’t (we’ll look at what connects to what later).
The output of one node can connect to the inputs of several nodes. This means we can use a single texture to drive several different channels in a material at the same time, or several different nodes that will eventually feed into the same system.
While this possible to do in C4D’s manager system, it’s super frustrating and easy to lose track of what connected where. With nodes, it’s all there visually, so it’s easy to follow and change if needed.
Each input port on the left side of a node can only receive one connector. We can’t run several nodes into a single pin. If we try connecting a second wire to a pin, it’ll replace the first wire. If we want to combine the data from two or more nodes, we’d just use a specialized node like Add or Multiply to do so, and then go from that node to wherever we want the combined data.
If we want to disconnect nodes, we can double-click the wire, or drag a wire out of the input pin it’s connected to and drop it into the ether and it will disconnect.
Inserting Nodes in a Chain
We can drag from the node list on the left directly into an open port on the Material and it will create the new node and connect it automatically.
If we want a node to sit between two existing nodes, we can drag a node from the left and drop it on the wire, and it will put it between the two. We can also hover over the connecting wire and a yellow square will appear - if we click that, a list of nodes will appear that we can choose to insert.
Organizing Nodes
We can select a bunch of nodes and move them around as a unit by dragging a selection box through any of the nodes we want selected. We can also shift-click individual nodes that we want to move.
If Child Selection is on, then when we move a node, any nodes attached to it upstream (to the left of it) will move with it. We probably don’t want this on most of the time, but sometimes it’s helpful.
If we select a group of nodes, we can right-click and choose Auto-arrange. This has varying levels of success, but usually it will take a messy graph and give we a good starting point for reorganizing it. We can also select a bunch of nodes, right click, and choose Align Nodes > Horizontal or Vertical. This also works with varying levels of success - vertical tends to work better than horizontal.
Grouping Nodes
If our graph starts getting too large and unwieldy, we can group several nodes together by left-click dragging a rectangle around them, then right-clicking one of the nodes and choosing “Group Items”. If we right-click a group node, we can choose “UnGroup Items” to expand it back out.
As of this writing, we can’t dig into the group and edit it, but we can expand it back out, make our edits, and regroup it we need to.
Important: It’s a good idea to rename the group in the Basic tab so we don’t end up with a whole bunch of nodes that just say “NodeGraph” that don’t mean anything to us when we open the project back up. It’s also a good idea to include the word “group” in the name so we quickly know to ungroup it if we want to see what’s inside.
Comments
Comments are a fantastic way to organize and keep track of large node structures. The comment object itself is a node (called “Comment”) that we create the same way as any other node. When we create a Comment, we see a large box with some text placeholders in it. We can change all the settings (both the content and visual look) by selecting the comment and messing with the attribute panel on the right.
The comment box can be resized by hovering over an edge or corner so we only see one (edge) or two (corner) arrows and then clicking and dragging.
We can move the comment box around by hovering inside of it until we see all four orange arrows appear, and then click and drag. When a comment box is resized to fully overlap any other nodes, moving the content box itself also moves those nodes. If we want to unlink nodes from a comment, we can either move the nodes out of the comment area or shrink the comment area so it’s not overlapping.
If we select a bunch of comment nodes, we can change the color and styling of all of them at once without messing with the title or comments which is great for color-coding groups of nodes.
If we copy or delete a comment, it doesn’t affect any of the nodes attached to it.
Soloing a node
When we solo a node, it disregards anything further downstream (to the right). This is really helpful for seeing the effects that node is having by itself when troubleshooting a system.
In the example above, we can see that all the specular reflections went away and the background blacked out. That’s because this particular Noise4D node isn’t routed into the Specular channel and isn’t used in the background (so 0 contribution, or black), so it truly only shows the effects of that particular node.
We’ll also notice that it kept the effects of the transform node, which is an upstream node (to the left).
Disabling a node
Disabling a node removes any contribution of that node. This is also useful for troubleshooting or evaluating whether the node is even worth having in the chain.
We do this by clicking the little plug icon in the right hand side of the titlebar (appears when we click the titlebar) or right-clicking the node and choosing “Disable node”.
Part II
The Nodes
General Workflow
An Octane node network (or tree, graph, or chain) reads left to right in C4D. When two nodes are connected, the node on the left drives an attribute in the node on the right.
Only certain nodes can drive other nodes. Octane will not let us connect nodes that don’t work together as we saw earlier. We can tell what’s likely to work by understanding the categories the nodes are in. To make this easier, node categories are color-coded.
In most cases we’ll have a dark blue-gray Transform type node on the far left. These nodes directly control how a texture is applied to an object (what type of projection, and then tweaking the position/scale/rotation of the texture on the object).
Those hook into a texture node - these are nodes that actually create data, like generators (gradients, patterns, etc.) or bitmap textures (jpegs or pngs from disk).
Textures are mixed, modified, and remapped using a series of different mapping nodes, and then the output is finally fed into one or more channels into a node at the end of the chain that corresponds to a material, light, or other Octane object.
Categories of Nodes
This guide won’t go over every node, it’ll just point out the more common ones in each category. Knowing the category gives us a good idea of where the node will sit in the chain and more or less the type of thing it’ll do for us. Other guides go into more detail on specific categories, notably the Mixing and Layering and Procedural Textures guides.
The nodes and groupings below are what’s found in Octane Render 2024.
One more thing to note is that some of the nodes are Octane-native. This means they’re unique to Octane and tend to be very stable and versatile. Octane’s Node Editor allows for other types of nodes, however. The blue OSL and dark magenta C4D nodes are not native, but Octane can use information generated by them with varying levels of success. Whenever possible, it’s always best to use Octane-native nodes.
Transform & Projection Nodes (dark blue-gray)
These two nodes are under the Other category and are dark bluish gray. They sit to the left of a Texture or Generator-type node and plug into the appropriate ports.The UVW Transform (magenta Mapping-type) node will accept them as well.
Transform lets us change the position/scale/rotation of a texture, and Projection allows us to change how it’s projected on geometry. Each texture can have its own projection to create some interesting effects.
Texture Nodes (mostly medium blue)
These nodes and the green generator nodes are what provide most of the source data for our node networks.
The most common one in this section is the Image Texture node. This is an Octane-native container that holds bitmap images (PNG/JPG/TIFF/EXR/etc). While we can use dark magenta C4D-native Bitmap nodes to hold images, they are not anywhere near as versatile as the Image Texture node, and they cause problems when trying to use them with things like an HDRI environment. General rule - if we want to use a bitmap image in Octane, use an Image Texture node.
We can either drag in an Image Texture node and find our image through the popup window, or we can navigate to our image files in Windows Explorer or the Mac’s Finder, and drag them directly into the Node Editor that way. This will create Image Texture nodes for those automatically.
There are also some nodes in this category that create a single value. RGB Spectrum produces a single RGB color. Gaussian Spectrum produces a light wavelength which is sometimes good for lighting setups and emissive textures. The Float node produces a single numerical value. Not overly useful on its own, but good when we’re building out mathy node networks and want a constant that can drive several values at once.
The Composite Texture node is a system for building complex materials. This is covered more in the Mixing and Layering guide.
Generator Nodes (green)
These are Octane-native nodes that mathematically generate image data. These are going to sit in a similar location to Texture Nodes on our node graph (usually on the left of the chain).
There are a few patterns here like Checker and Marble, and some noises like Octane Noise and Noise4D, Turbulence, and Ridged Fractal that are pretty self-explanatory.
The Procedural Textures guide goes into detail and shows examples of all the texture/pattern-making generator nodes, especially the ones contained in the Custom Pattern node.
The geometry-based ones like Curvature, Dirt, Side, and Falloff generate different grayscale values that are based on different properties of the actual model we’re putting them on. Curvature and Dirt are affected by the topology of the model. Falloff calculates the angle of the polygon normals compared to the camera and assigns grays based on that. Side has to do with the “front” and “back” of a polygon sheet.
In the example above, a falloff texture was applied to the elephant and run through an Octane Gradient to show what it’s actually doing when it covers different parts of the model.
There are also three nodes that use data from a cloner/scatter/particle system to affect different instances.
Endpoints: Material (red) or Object (indigo)
This is the node representation of a material or an object. As a rule, every material or object can only have one of these (the one exception being the Mix Material).
Important: These nodes are representations of the actual material or object. If we delete the node, the actual material/object/tag gets deleted as well. If we’re in the node editor and drag a new material in, it will create a new material in the material manager.
This behavior seems confusing at first, but we’ll go into it more in Part III when we walk through editing multiple materials in the same window.
Most of the time we’ll be using a red Octane Material node - this can be made into a Diffuse, Glossy, Specular, Metallic, Toon, or Universal Material in the Basic tab in the Attribute Manager off to the right. There are other speciality materials as well like Standard Surface, Hair, Clipping, Null, and Shadow Catcher.
Composite and Layered materials use Submaterials and Material Layers as inputs rather than other Octane materials. This is a pretty complex subject by itself and is covered in detail in the Mixing and Layering guide.
Currently, we can also use the node editor for lights, environments, volumes, and scatter, but most of the time these are easy enough to edit in the Attributes Manager, so we wouldn’t really dive into the node editor unless we needed to do something particularly complex.
Mapping Nodes (magenta)
This is where the magic happens in the Node Editor. These nodes are not used to generate textures (that’s what the blue and green nodes are for). Instead they’re used to nondestructively mix, modify, and adjust texture nodes.
Texture Mixing nodes are for combining textures using blend modes. Details for these are also covered in the Mixing and Layering guide.
Image adjustment nodes are similar to what we do in a 2D app - adjusting things like levels, contrast, etc. Many of these nodes overlap functionality because they were created at different times, and the old nodes need to stick around for compatibility purposes. If we’re new to this whole thing, the appropriately-named Image Adjustment node would be a good place to start.
Utilities are for more advanced things like creating a switch, comparing values, or adjusting texture projection.
The Octane Gradient is simultaneously one of the most used and least understood nodes in the arsenal. The one key thing we have to remember about it is that it’s a mapping node. It’s not a generator, and it’s not a texture. This means it’s not meant to be used to generate a gradient, as weird as that sounds. We’ll cover this a bit more in the next section to understand it better.
Channel-specific nodes (gold/purple/teal/brown/orange)
This is a particularly confusing concept for those of us just starting out. Most of the time nodes will just connect to each other, but sometimes nothing seems like it’ll connect to an open port/pin/input, and that gets frustrating.
Important: The thing to know here is that certain pins can only take one type of node.
The Displacement, Emission, Medium, Round edges, and Material Layer channels of a material require special intermediate nodes before we can connect textures/generators/mapping nodes to them. There are also certain systems like the Composite Texture/Material and some of the AOV nodes that require certain helper nodes.
Note: The Round Edges and Material Layer pins/channels need to be turned on from the Basic tab before we can see these pins.
Fortunately, these particular pins have utilities built into the nodes themselves for adding the proper connective nodes. If we look at the Displacement tab in a material for example, we’ll see a button that says “Add displacement”. Same thing for the Medium channel or Composite Texture / Material, etc.
We can also do the trick where we drag a wire from the pin to the left and let go, and we’ll see a list of the appropriate nodes that connect into these pins. If nothing else seems to connect, this is a great way to see what it’s actually expecting.
Cinema 4D Nodes (dark magenta)
Cinema 4D nodes are properties that are fed in from Cinema 4D that Octane can use to affect the behavior of materials and objects.
Important: C4D nodes are inherently more unstable than Octane nodes - we should really only use them if we have to.
Most of these don’t have Octane equivalents like W coordinate, Vertex Map, and MoGraph Color Shader and Multi Shader, so odds are good we’ll continue to use them going forward.
There are also ones that were needed in earlier versions of Octane like Noise and Gradient that have since been converted to their OSL equivalents. This means that if we open an old project that was using a C4D Gradient, it now gets converted to a more stable OSL Gradient node.
The one node that’s still a thorn in our sides is the C4D Bitmap Node. This is the cause for a lot of confusion, and can be created if we’re building materials using the Material Manager instead of in the Node editor which uses the far superior ImageTexture node by default.
Simply put, the Bitmap node is pure evil and should be avoided at all costs. We want to make sure we’re using an Octane ImageTexture node instead for every external image file we’re using. Bitmap nodes are unstable and lack a lot of the features and control of the Image Texture node.
Advanced Nodes
Utility (various colors)
Utility nodes are for doing specific calculations, or converting, breaking apart, and recombining data, or other random things . A few notable ones are:
Baking Texture takes procedural data and bakes it into a bitmap image - some nodes require bitmap data to work with (like Texture Displacement for instance).
Confusingly, Image Tiles does not tile images or patterns - it’s used for UDIMs.
The Chaos node takes a texture and... well.. applies chaos to it. It’s a lot of fun to play with and creates some really interesting effects.
Ray Switch lets us change the appearance of an object based on various rays (camera/light/etc). It’s pretty technical, but we can do some cool things with it.
OSL (dark blue)
Octane supports Open Shader Language nodes, which allow we to write our own behaviors programmatically. This is way out of the scope of this guide, but if we’re into writing our own shaders or adapting ones we find on the web, just know that these nodes are here to help with that.
Output AOV Nodes (lavender)
These are for the AOV system. There’s a whole guide on that here, but if you’re brand new to AOVs, start with this one instead.
Part III
Walkthrough
Housekeeping
Before we get started, there are a few settings to look at. We can get to the node settings by clicking the gear button (Octane Settings) in the Live Viewer Window, and then going to Settings>Nodes.
The first thing we want to do is turn OFF Auto hide menu. This is a good thing to leave on until we’re comfortable enough with the node editor that we no longer need to see a list down the side.
Important: If we’re on a Mac, some of the UI stuff doesn’t work using the new node style as of this writing (Octane 2024.1). There’s an option here to uncheck that and get back to the older squared-off nodes. They don’t look as pretty, but all the functionality (including image previews) will suddenly work again, so it’s worth the tradeoff until the new style is fixed and updated.
Building a Simple Node Graph
Getting into the node editor
Starting with a new scene, let’s create a new Octane material (Universal is shown above, but any will do). Now let’s click the thumbnail for it in the Material Manager, and use the “Node Editor” button in the upper left of the Basic tab to view it in the Node Editor. The only thing we should see is an Octane Material (material type) node, which is the node representation of the material. On the right hand side of the editor, we have all the same controls that we have in the Material Editor popup window.
Dropping in an image
Next, let’s grab any PNG or JPEG we have handy, or we can download this one to follow along with the guide, and drag it from Finder/Explorer into the node editor. There are several other ways of doing this as we learned in Part II of this guide, but this is a quick and efficient way.
Connecting the nodes
Next up we want to connect the nodes - let’s draw a wire from the yellow output circle in the titlebar of our ImageTexture node to the material’s Albedo channel pin (gray circle next to the word “Albedo”). We’ll notice it turns green when it hits the pin, meaning we’re good to go with connecting it.
Once connected, we’ll see that the material preview doesn’t update. The preview itself is actually a render - Octane sets up a little scene with a sphere and checkerboard, applies the material, and literally renders the preview.
Important: This means that if Octane isn’t rendering, it’s not building new previews either. If we hit the Start Render button in the Live Viewer - even if there’s nothing in the scene - we’ll see our preview update in the Node Editor.
We don’t need to keep it constantly rendering though - just unpausing the render for a minute and re-pausing after the previews update when we need it is usually the best way to go.
Adding a transform node
The fastest and easiest way to add a transform or projection node is to drag a wire out from the transform or projection pin and drop it into space somewhere. That will pop up a little window showing all the available nodes that can connect to that pin. The Transform pin can only accept a Transform node, so let’s pick that, and presto - a new Transform node is now created.
The gray values to the right of the pin’s name are directly editable, so we can just select one and type in a value. Let’s set all of these to 0.25, which will scale the texture to by 25% of its original size. We could also select the Transform node and edit the attributes on the right, but this is a little faster.
Driving Multiple Nodes
Next up, let’s take a look at how Octane handles one-to-many and many-to-one relationships between nodes.
Just to rehash, Octane allows the output of a node to connect to the input pins of as many nodes as we want - this allows us to just use one instance of a node drive the properties of several others, which is great.
An input pin, however, can only take one wire at a time, so we can’t have several nodes feeding into the same port. We need to using some sort of mixing node to merge them first. Let’s see this in action:
Let’s drag out a Checker (green generator type) node from the list on the left and stack it under the Image Texture. Now we can drag a second wire from the Transform node’s output and attach that to the Checker’s Transform pin as well.
If we start/stop the render, we’ll see that the checkerboard was shrunk down to 25% just like our Image texture.
This starts to show the versatility and power of the Node Editor. Until now, we could have easily built this type of material out in the Material Editor, but now we want the same Transform node to affect two different texture nodes. This is possible in the Material Editor, but it’s an annoying and complicated process that gets more difficult and tedious the more complex our material gets.
Far, FAR easier with nodes.
Now let’s say we want to combine the Image and the checkerboard so we can use the data from both nodes in the Albedo channel. We know we can’t just run the output of both the image texture and the checkerboard directly into the Albedo channel - any one pin can only take one input. So how do we combine these so we have one wire going into the Albedo?
Combining Multiple Nodes
For this we need one of the mixing nodes, which are a magenta color. These nodes work the same as blend modes in our 2D apps, so an Octane Add node would combine the output of two nodes the same way applying the Linear Dodge: Add mode would in a 2D compositing app like Affinity Photo or Photoshop.
For this walkthrough we’re going use a Multiply node to merge them, so let’s drag that out from the list on the left and drop it right on the wire that’s currently connecting the Image Texture node to the Material Node. This shoves the Image Texture over and connects the Multiply up. It does do its best to move the nodes out of the way, but we’ll have to clean it up a little bit.
Now we just need to hook the Checkerboard node into Texture 2, and we’ll get the combined contribution of both nodes going into the material channel. If we do a quick render and pause, we’ll see the results update in the preview.
Modifying a Node
Let’s add some color to our pattern using an Octane Gradient node. The Octane Gradient is a mapping utility, not a color value generator (that’s what the Gradient Generator node is for). This takes grayscale values and remaps them to color values, which means we can colorize our texture.
Let’s hover over the wire that connects the Multiply node to the Albedo pin, and click the orange square in the middle of the wire. The familiar node list box pops up and we can search at the top for Gradient. Let’s select Octane Gradient, and it will drop one in for us. Nothing changes initially because the default black-to-white gradient is the same as the input it’s expecting.
Let’s hit the Load Preset button and pick the Rastafari gradient. Now anything that was originally black (far left) is now remapped to red, anything originally white (far right) has been remapped to green, anything originally 50% gray has been remapped to yellow, and then all the other grayscales are converted to whatever color they align to throughout the gradient.
That’s about as basic of a material as we’d be making with nodes.
Part IV
Things to Keep in Mind
Left to right
Nodes on the left modify nodes on the right. Usually transform and projection is the furthest left on any branch, then the source (texture or generator), which are mixed and modified using the magenta mapping type nodes, and then all that is fed into the various channels of our material.
Reuse nodes
This is one of the Node Editor’s superpowers. We should strive to reuse as many nodes as we can. We can always put in mapping nodes further downstream to create different versions of the same base texture or generator for different purposes. This makes it much easier to swap out a texture later if needed and keeps the number of nodes down in our graph.
Simplify
When something isn’t working as expected, disable/disconnect nodes or duplicate the material or object, isolate one channel or node branch at a time and build it up piece by piece to see what the issue is. Even if nothing is wrong, sometimes rethinking the network will reveal better ways of achieving the effect we’re after with fewer nodes.
Reverse engineer materials
Go find or buy a bunch of Octane materials, and then open them up and see how they were made. What we find there may not be best practices, but they might give we some ideas when constructing our own materials. Rip them apart and disable or disconnect portions to see how a specific effect is achieved, and steal and reuse those processes for our own materials.
Keep organized
This is probably one of the most important aspects of working in 3D, and especially so when we’re creating complex node networks. We should think about coming back to the material two months later to edit it, and consider what our future self (or someone else looking at our file) would want to see in order to be able to modify it easily.
Watch the wires: Try not to cross wires if possible - it doesn’t affect how anything works, but it’s much easier for our eye to follow if things are straightforward and orderly. Sometimes it’s unavoidable, but most of the time we can just rearrange the nodes. Making wires as horizontal as possible makes them easier to follow and it just looks better.
Utilize the organization tools: Use the alignment tools (right click after selecting a few) and the auto-arrange tool (View menu in the Node Editor).
Name the nodes: In the Basic tab of every node, we have the option to name our nodes. This can be helpful if we have several of the same mapping node in a row. If we combine renaming with minimizing nodes, we can have a ton of them on our graph and easily be able to tell what’s what.
Minimize nodes: Shrink them down (double-click the node’s title bar, resize, use the little icons in the upper right of the title bar) to only what we need to see if we’re starting to get overwhelmed. If we name them appropriately we can still easily follow our thought process.
Use groups: Select a bunch of nodes, right-click and choose “Group items” - this will clean up the Node Editor. Unlike Octane Standalone, we unfortunately can’t then dive into a group in a different tab, so we’ll have to ungroup them to make any edits.
Annotate: Use the Comment node to visually group chunks of nodes together that are part of a system. Name them and color-code them.
Wrap up
At this point you should have a pretty good understand of what the node editor is, how it works, what the categories of nodes are, and why we’d want to use it to make complex materials.