NodeFlex uses a powerful object oriented and typed C/C++ style interpreter scripting language which gives developers a very common language to work with and powerful set of functionality.
Intellisense menus, function completion dropdown menus, code tips, quick search and real-time template debugger make authoring your own system a breeze.
It has a fully functional VC style code debugger for stepping in, over and out of functions, can jump to breakpoints and inspect and watch local variable and keep help you visualize where you are on the stack
Multiple systems can coexist and be worked on at the same time and even reference shared template files. For example, you could have a DirectX 11 system and a RenderMan system share a bunch of generic math components or share core system utility functions.
The template system pre-loads all the templates from each graph system and compiles them together in a fraction of a second as one huge script. No complicated include system is needed, and you can define functions and classes in any order and still have access to them.
Almost every node-based graph system forces users to choose from finite selection of low level nodes to work with. Some of the better packages allow you to build your own by grouping together nodes and saving them into what I call "sub-graphs" which can be inlined into the graph or can be referenced globally and reused across multiple graphs. With NodeFlex, you get best of both worlds. You can either code up your own nodes using the template language or group them and create your own reusable sub-graphs. This is a great alternative for non-technical users who don't ever want to get involved with the code even though adding a node template is very easy.
One of the most powerful features of this system is how the code is stitched together. Imagine writting a bunch of actual C++ code that performed a bunch of logic on individual strings while trying to insert new code all over the place. You’d be required to add a bunch of line carriages ‘\’ to let your C code know that our multi-line string is not finished. Then you’d have to either end the string, add them together with + or some function and the code would simply be unreadable. This scripting language allows you to mix multi-line text with it’s C++ code without neeing any ‘\’ delimiter. As well, to insert some text into some other text you simply use “the tool named <
The application provides the graph creator with some core script classes to talk to the application with. They are string, graph, block, node, variable, control, list, array, hash, data and a bunch of math functions. I will continue to add more classes and functionality as the requests come in.
Input and output ports can be easilly added from within the node's template code and be exposed in the graph and/or the parameter editor where their values can be tweaked. These input and output ports can be dynamic or static and the graph system chooses how to handle changes to their values.
If you like Visual Studios' Search and Replace tools, you'll love NodeFlex's real-time system-wide search and replace tools.
If your system requires the use of double quotes within your strings, you can simply define your multi-line string using triple quotes like “””my name is “scott” and that is all””” and this will retain the single quotes.
Most node-based authoring systems out there are hard-coded and built to generate only one data format or drive one application therefore their code generating logic and node definitions are almost never exposed to the end user making it impossible to customize, improve or expand their systems programmatically or without some type of restrictive node grouping or sub-graph support.
NodeFlex is one of ( if not ) the only generic node-based code generators that can generate or drive any kind of data without it never knowing what it's actually being used for. NodeFlex exposes all the functionality you need to build custom graph systems, build up reusable node libraries, gather data from your graph any way you want and ultimately generate complex output data to your exact specification.
Any new functions, classes and enums the users adds to their graph system is automatically color coded. User can also fully customize how their graph systems and generated code are color coded by adding their own keyword and function highlighting and changing system colors like comments and such.
Search the available templates in your graph system using a real-time search feature in the toolbox window then drag them into the graph or simply hit the TAB key to quickly search for templates using a special quick menu control.
NodeFlex comes with a lightweight C++ API which is used to connect NodeFlex to 3rd party applications to send generated output files or dynamic port values from NodeFlex or receive per-node previews or errors from the 3rd party application. ShaderFlex also uses this API to comunicate with NodeFlex.
A graph can generate any amount of output files it wants, so for example, it can generate a .hlsl shader file as well as a .def material definition file specifically formatted for your pipeline.
Adding input ports to nodes are as simple as calling a node function like “AddInputNode_Float1( “NodeName”, true, 14 );” which can be completely customized for each graph system. Each node class can be customized to expose any UI controls it needs and can lay them out how they want. For our DirectX 11 graph system, we have node classes for ssNode_Float, ssNode_Texture, ssNode_Combo, ssNode_Color, ssNode_Bool, ssNode_String, etc. which again can be fully customized per system.
Some people like node-based systems that flow from left to right like ShaderForge and some like them to flow from left to right like Unreal's material editor. Not a problem. Each graph system defaults graphs to a specific direction, but users can switch the flow direction per-graph with the click of a button.
Graphs can be exported when changed or manually by clicking a button or hitting Ctrl-E. You can also batch export all your shaders automatically in under a second, so fixing bugs or making changes to thousands of shaders is effortless and is one of the huge advantages of high level template based code-generator systems.
Each component derives from a base application script class and can be customized to have any functionality it wants. This also gives system creators the ability to share base/core class functionality across graph systems but still have the ability to customize each derived class per graph system.
A non-linear photoshop style undo/redo history is supported which even allows you to go back, make changes, then come back and go down another history branch.
The user interface is 100% GPU accelerated and very responsive. The api was developed in-house, from the ground up and abstracted from the OS for future portability. Not that we’d ever want to, but with a bit of work, we could be ported the application to an XBox One or iPad as everything you see in every window is simply a render target, all windowing is and messaging is 100% abstracted from MFC/Win32 and handled within our API. Given more time, we plan on eventually porting the API to work on OSX.
The user interface currently uses DirectX 11 but can fallback to use DirectX 9 or 10 or even DirectX’s WARP software renderer if need be.