weet

NodeFlex™ is an extremely powerful fully programmable node-based data generator designed to greatly simplify any tedious, redundant or error-prone data authoring tasks. Its visual template-driven graph systems help you automate the creation of any type of text or binary data ( shaders, scripts, HTML/CSS/JS code, forms, XML, you name it ). NodeFlex was initially developed to generate data for many popular graphics and gaming industry fomats but due to its flexibility, it has broad usage potential spanning multiple industries.

Node-based authoring has been a core feature to almost every major graphics package on the market for years, and now with NodeFlex, you can add that same capability to your own tools and pipeline.

For a great example of NodeFlex in action, check it out along side ShaderFlex, being used to generate some very complex multi-pass rendering effect code.

Scroll down for an overview of NodeFlex or check out the Features page for more in-depth information.

NOTE: NodeFlex is still in development and a beta program is planned for later this year.

Above is a screenshot of NodeFlex using a powerful Unity graph-system to generate a complex C# scripts and shader code for a compute-based fur simulation effect rendered in Unity.

Above is a screenshot of NodeFlex using a custom IRay graph-system to generate complex MDL shaders for NVidia's IRay renderer.

Above is a screenshot of NodeFlex using a custom graph-system to generate a PBR/IBL HLSL shader for ShaderFlex.

Above is a screenshot of NodeFlex using a custom ShaderFlex graph-system to generate a fast fourier transform based water shader.

Above is a screenshot of NodeFlex using a custom VRay graph-system to generate a BRDF shader with displacement mapping.

Above is a screenshot of NodeFlex using a custom ShaderFlex graph-system to generate a complex geometry shader based lens flare.

Here are some of the main features found in NodeFlex. Check out the Features page for more in-depth information

• Multiple Graph Systems: Work simultaneously with multiple graph systems and even share template logic between each system. For example, you may want to share simple math nodes similar HLSL, GLSL and RenderMan shader graph systems.
• Template Driven: Uses a powerful template-driven graph system which gives you the means to build and reuse code logic between individual graphs or whole graph systems.
• Fully Programmable - Uses a fully programmable object oriented C/C++ style scripting language which is familiar to most developers and gives you the flexibility to generate the quality of code you need.
• Sub-Graphs: Supports lobal and global sub-graphs ( node grouping ) so you can package nodes into higher level sub-graph nodes and reuses in other graphs.
• Auto-Export: Add a feature, fix a bug or make an optimization and push it into hundreds of your data files with a click of a button
• Intellisense menus, code tips, quick search and real-time template debugger make authoring your own system a breeze
• Let the graph system work for you, have it generate complex code that you would not be able to perform manually
• Open Systems: Unlike other node-based system, all the code and logic behind each graph system is 100% open and fully customizeable by the user. This allows you to easilly create your own low/high level nodes, build up your own node libraries, change the code generating logic used to gather data from the graph and generate your assets, add your own functionality or features, extend existing graph systems or build your own systems from scratch.
• Code Editing and Debug: NodeFlex comes with a built-in template editor with code completion helpers and intellisense style tips as well as important Visual Studios style code debugging tools for code stepping, adding/removing breakpoints, watch variables, walking the stack. All these built-in tools make it easaier understand how data is being created and gathered in a graph and ultimately helps you output that data properly to your file format.
• Multi-Direction Graph Flow: Some users prefer working with graph systems that go left to right, some rather right to left. With NodeFlex, you can tell your graph system which to default to or you can switch direction back and forth per-graph simply by clicking a button.

Here are some of the benefits of using NodeFlex to generate your data.

• Fully programmable graph system means no more spaguetti graphs
• Spend less time writing redundant data and spend more time creating meaningful content
• Hide your data format's complex syntax and semantics behind a powerful template-driven graph system
• Generate cleaner and more consistent data using NodeFlex's dynamic and flexible C/C++ style template language
• Write logic into your graph system to auto-generate data for you
• Free your engineers by having non-technical users take over tedious data athoring tasks
• Plug-and-Play graph systems means no more errors
• Add a feature, fix a bug or make an optimization and push it into hundreds of your data files with a click of a button
• Visualize, organize and make sense of your data even years after writing it
• C-style graph system is familiar to most developers
• Intellisense menus, code tips, quick search and real-time template debugger make authoring your own system a breeze
• Let the graph system work for you, have it generate complex code that you would not be able to perform manually
• 100% open-sourced graph systems, all traversal and code-generation is done in graph and customizeable
• Visual authoring helps you be more creative
• Avoid having to use black box systems which force you to use hundreds of redamentary nodes to perform complex math or logic.
• Share template code between systems
• Use one familiar tool for all your data authoring needs

Node-based systems have taken the graphics industry by storm over the last 20 years with hundreds of commercial applications sporting their own proprietary visual node editors. Despite their widespread popularity, when it comes to node-based systems, you usually either love them or hate them. Artists and non-technical users love node-based systems because they visually expose an application's internal functionality which use to be off limits to them. On the other hand, engineers and technical users generally hate being forced into using node-based systems that cannot be extended because trying to express complex functionality and logic using only a subset of simple nodes is like having to build a full sized house using only Legos. It's just not practical having to wire up hundreds of nodes to accomplish some logic you could have did in 10 lines of code. These closed systems lead to what we call "Spaghetti Graphs" which quickly get out of hand and defeat the whole purpose of having a node-based systems.

Unfortunately most systems cater to one level of user while alienating the other. Thankfully, this does not have to be the case. A properly designed node-based system like NodeFlex can be extremelly useful for both non-technical and technical users. The ideal node-based system can be easilly extended, has an easy to use and familiar template language, a built-in template editor and has full debugging capabilities.

NodeFlex has all these features and was designed with engineers in mind.

From left to right: NoFlo, ShaderFX, MentalMill, Visual Studios Graph, Strumpy Shader, ShaderForge, not sure, Dark Tree, Substance Designer, Strumpy Shader, not sure, not sure, LightWave Node Editor, not sure, ShaderWorks, not sure, Apple node editor, ShaderMan, FilterForge, not sure, 3DS Max, Maya Hypershade, Modo ( I think ), not sure, not sure, not sure, not sure, not sure, Blender, not sure.

There are literally thousands of different data formats, some mainstream and some proprietary. Many of these formats don't have any editing tools available for them therefor companies are either forced to invest in creating their own makeshift tools or forced to painstakingly author these files by hand. With NodeFlex you can skip having to create your own custom editors and simply create a graph system for your format which will help your users automate the creation of your data files.

NodeFlex is very well suited for generating data for the graphics industry like shaders, but can also be used to generate any type of data format you want.

Every data format has its own syntax, complexity, semantics, guidelines and annoyances, and regardless how great of a coder you are, you still have to follow ALL the rules and routinely come up with 100% bug free content which can be daunting at times, especially when that content is in high demand. So why not hide all that complexity behind a graph system, expose only the options you want you or your users to see, automate your work and concentrate on being creative and efficient. NodeFlex helps you make data authoring easy and fun again.

Every data format has its own syntax, complexity, semantics, guidelines and annoyances, and regardless how great of a coder you are, you still have to follow ALL the rules and routinely come up with 100% bug free content which can be daunting at times, especially when that content is in high demand. So why not hide all that complexity behind a graph system, expose only the options you want you or your users to see, automate your work and concentrate on being creative and efficient. NodeFlex helps you make data authoring easy and fun again.

I've developed some pretty complex shaders in my time, and I can say one thing for certain. Without the right tools to help me iterate faster, most of them would have never been achievable, been as functional or looked as amazing. If iteration is too slow, the quality of work and productivity drop significantly, but when iteration is high, you'll be able to achieve things you never though possible and this is when things get fun again.

Let's compare this to a CEO running of a billion dollar company but without any staff under him. He's spending most of his day putting together press kits, making coffee, setting up the media room and demo PCs, managing the finances and taking support calls. How good of a CEO would you be if you only spent 2% of your time actually doing CEO things? That's why CEOs have staff to help them operate at their full potential and concentrate on the bigger picture. This can be applied to every level of a production pipeline and is why you need tools like NodeFlex to automate your data authoring tasks so you can operate at your fullest and be more productive while creating better content.

When using a NodeFlex graph system to generate your data, you don't ever have to worry about generating buggy data files, you simply add and connect the nodes you need, tweak some parameters and your file is automatically generated and ready to use. With NodeFlex you now have an air-tight and dummy-proof plug-and-play authoring environment for your pipeline so you can concentrate on being creative.

The visual nature of NodeFlex not only allows non-technical users to play a role in the authoring of complex data, NodeFlex was also designed with developers in mind and will help them visualize their data, iterate quicker, create reusable logic and manage large amounts of data all while being more productive.

Our brains are wired differently than traditional computers. It take 13 milliseconds for your brain to identify the contents of an image and make sense of it, yet researchers are still struggling to accomplish this same task with today's most powerful computers. Analytically, computers can parse a whole library of information in a blink of an eye, where it would take a human a lifetime. So it's no surprise that we use so many visual tools to author and represent our data.

This connection we have with visualizing data is one of the reasons the computer industry is obsessed with node-based systems to represent logic, generate code and drive applications. Besides the standard node-based editors found in most commercial graphics applications these days, there are literally hundreds of attempts at creating node-based systems and tools for various uses, each with their own interesting functionality.

Click here for Eric Hosick's comprehensive list of nearly 200 visual programming languages and tools.

When it comes to auto-generating text-based data, your algorithm basically need to stitch together tons of static of dynamically generated text and doing this with regular C/C++ code can get pretty ugly. With NodeFlex, we took the time to make this process as easy and clean as possible. Here's a few ways NodeFlex makes this process easier.

NodeFlex gives you all the tools you need to debug and understand your graph system. Similar to Visual Studios, you can step through your graph system code line by line, put breakpoints on variables and inspect their values. NodeFlex has intellisense-style tooltips and dynamic completion drop down menus to help you code quicker.

NodeFlex has a lightweight connection API so that you can connect to the application its authoring data for. Every time the graph is updated or changed or whenever the user edits node parameters, messages are sent through the connection API to your application and if there were any errors made in generated data, your application has the opportunity to send the error back to NodeFlex to display to the user. Your application can also send back thumbnail previews for each of the graph nodes.

Above is an image of NodeFlex connected to ShaderFlex.

Unlike most of the black-boxed graph systems built into commercial software packages, NodeFlex's graph system is 100% exposed to the user and can be extended directly within the application using its C++ style template language and template editor. This makes it easy to customize new or existing graph systems, make fixes or learn from others. You can even control how your system walks through the graph to gather and generate data.

NodeFlex's C++ style template language is fully programmable from within the software. This makes it easy to customize new or existing graph systems, make fixes or learn from others. Also, with most closed systems, users are forced into using only the nodes available to them, which can quickly turn into a mess if you try to do anything complex. Imagine having to create a complex particle system shader using only "mul", "add", "div", "sin", "pow" and other simple nodes to express its complex mathematical algorithm. What you'd have is an unmanageable "speghettie graph" which defeats the whole purpose of having a graph system in the first place. With NodeFlex more experienced users would simply package most of their complex algorithm within one custom node and only expose aspects of their algorithm which they feel should be editable by others.

Closed "black-box" graph systems are bad news. Expressing complex mathematical algorithms or logic by connecting hundreds and hundreds of rudamentary graph nodes should be frowned upon. These graphs becomes impossible to make sense of and it takes more time hooking up and disconnecting nodes than it would have taken to just code up a custom node to do the same thing. Some graph systems do have sub-graphs, which doesn't solve the problem, they just help hide it. To make a node-based system truly funcitonal, you need to let users add or edit their own nodes and ideally control every aspect of the graph system and data generation. And the template language and d.

So you have 2000 data files and realized you needed to make a global fix or change your file format mid project. Without NodeFlex you'd have to manually edit all 2000 files by hand or have a developer try to write some complex parser to read and re-format your files for you. With NodeFlex, it's easy. All you do is make your fix in the graph system, and hit the batch export button and let NodeFlex quickly re-generate all 2000 files for you.