One popular request on the Autodesk 3ds Max Feedback site is the curvature map. While you can't create procedural texture maps with Max Creation Graphs (at least not now) you can create modifiers that set the vertex color map and then use the vertex color map to drive materials.

In the zip file CurvatureMCG.zip there are three tools and a few supporting compounds. To use the simply unzip the file into your MCG user folder (%userprofile%/Autodesk/3ds Max 2016/Max Creation Graph) and restart 3ds Max. Alternatively you can go into the MCG editor and select "Operators > Reload Operators" and then "Build > Evaluate all Tools".

In the package are three MCG modifiers:

1.Curvature - Computes curvature at each face-vertex based on the angle between the vertex normal and the face normal. The value is clamped at 90 degrees +/- a delta (default 10), converted to a gray scale value, and stored in the vertex color channel.

2.SmoothVertexColors - A modifier that smooths the vertex colors in two steps: a.Gives each face the same vertex color across the face. b.At each vertex averages the vertex color based on the vertex color of each contributing corner. 

3.VertexColorGrayScaleToColor - A modifier for visualizing gray scale vertex colors. It converts gray-scale values in the vertex color channel to RGB where 0,0,0 is red, 0.5,0.5,0.5 is green, and 1.0,1.0,1.0 is blue. 

I'm also sharing with you a scene (DragonWithCurvature.zip) with the modifiers and a simple material applied to the Stanford dragon.

Under the hood

In order to understand what is going on in the MCG graphs, the key is to first understand how the TriMesh structure is organized as a set of immutable (unchanging) data-channels.  

Data channels are arrays of data associated with different mesh elements: faces, vertices, face-vertices (i.e. the corners of each face), and edges. Data channels can have different types (Int32, Boolean, Single, Vector3, etc.) and can be either direct or indirect. A direct data channel mean the data buffer has the same length as the associated number of elements, and can be indexed in the same manner. An example of this are the material IDs data channel.  

An indirect data channel has two arrays: the data buffer and an index buffer. The index buffer is the same length as the number of elements, and is used to lookup data elements. The most common example of this is the topology data channel. The topology data channel has a vertex buffer and an index buffer. The index buffer is the same length as the number of face-vertices (i.e. corners of faces). This is how most 3D APIs represent triangular meshes.  We say that the topology channel is an indirect data channel of type "Vector3" that is associated with face-vertices. 

In 3ds Max a common category of data channel is called a MapChannel. In MCG the map channel is an indirect data channel of type Vector3 that is associated with face-vertices. Map channels are exposed to 3ds Max users via the Channel Info Utility which is one way to understand them better.  

About Vertex Colors 

Despite the somewhat misleading name vertex colors are a general purpose mechanism to store Vector3 data (triples of floating point values) with particular face-vertices. A face-vertex is a corner of a triangle. There are exactly N*3 face-vertices in a TrIMesh, where N is the number of face. This is usually different than the number of vertices, because multiple faces can share a vertex.

BUG ALERT: due to a bug in the current version of MCG, the vertex data channel data buffer must have exactly N*3 data elements. 

For more information on Vertex Colors, and an arguably better explanation of mapping channels in general, I suggest reading the topic Understanding Texture Coordinates and Vertex Colors in the MAXScript help.

I hope you find the samples useful, and I'd love to hear what type of MCG tools you come up with that do magic with vertex colors! 

A while ago Ishak Suryo L posted a very useful tool that allows you to stack different geometry on top of each other along the Z axis:

http://vimeo.com/126746868

I’ve developed my own variation of this tool (download it here) that also works along the X or Y axis. In addition if you don’t provide a “target” node to stack, it clones the base mesh along the given axis.

http://www.youtube.com/watch?v=KIj6MzRB2P4

To stay abreast of new and cool MCG tools like these be sure you join the MCG Facebook group.

In other news if you are going to be at Siggraph come on by to the Autodesk Vision Series talk on Procedural Content Creation by Martin Coven and myself which will be on Tuesday, 11 August at 4:30 PM  Los Angeles Convention Center, Room 408A.

I hope to see you there! 

I am pleased to announce that we have added new functionality to MCG in 3ds Max 2016 Extension 1. You can now create animation controllers using Max Creation Graphs. We also have made it easier to create dynamic rigid body physics simulations with the integration of Physics bullet library. Smaller improvements include added support for Vector3 parameter types and arrays of 3ds Max objects (INode) or floating point values (Single). 

In addition to other fixes, one notable bug fix provided with SP1 (to all 3ds Max 2016 users) that enables users to get mapping channels (e.g. Vertex Color Channels, etc.). This means it is now possible to store and access data in map channels.

Here are some of the highlights of the work on MCG this extension. 

MCG Animation controllers 

The extension ships with several new controllers created using MCG: 

• Lookat with Billboard Constraint
• RaytoSurface Position/Orientation/Transform Constraint
• Rotational Spring with one or three degrees of freedom

MAXScript Animation Controller Plugins

While working on MCG animation controller we also added the capability to create scripted animation controller plug-ins in MAXScript. This differs from the traditional “script controller” in that the new controller has a parameter block, a UI displayed in the motion panel, and is listed in the assign controller dialog.

To demonstrate the new MAXScript scripted controller capabilities, I’ve included a “Time Dilation” scripted MAXScript position controller plug-in. You use it by assigning it to an object’s position track that already has a controller assigned. It will cause the object to behave as if time is slowed down and then sped up between the specified begin and end frames. This is done by applying a mathematical function (“pow” to be specific) to the current time and passing the transformed time to the previous controller to get the value. 

Note that one limitation of this tool is that you can only access the previous controller through MAXScript.

Dynamic Rigid Body Simulations with Bullet Physics

We added new operators to MCG that simplify the creation of rigid body simulations using the Bullet physics library. To support this we also have a new property that tools can have called "Is Simulation" that appears in the tool's "properties" dialog. This controls how caches are handled and forces the tool to re-evaluate at each frame.

The new rigid body simulation operators are complex enough that I will be blogging about them in a later post.

For now I leave you with a video from one of our developers Nathan Loofbourrow, where he talks about the work in MCG this release.

https://vimeo.com/135685708

As promised in my previous blog post about MCG features in extension 1 here are two tools created for 3ds Max 2016 Extension 1 that utilize the new Bullet Physics operators. The first tool is an MCG transform controller written by our QA Jean-Thierry Roy that applies basic physics to an object and allows you to pick multiple obstacles. The second tool is an MCG modifier I wrote that clones an object and applies simple physics to all of the cloned objects. Both tools use the new node array parameter.

https://www.youtube.com/watch?v=tNBOFtl49Gg

JT’s animation controller is an example of a new type of MCG tool called a “simulation” graph. A simulation graph is evaluated at regular incremental time intervals regardless of how the user moves the time slider. If the user moves the time slider back in time, the simulation is restarted from the beginning of the graph. This is useful when scene objects can affect the simulation for example if some of the rigid bodies are kinematic. In this case you need the simulation to evaluate at regular intervals.

In the cloned physics demo I simplified things by not making it a simulation graph. I also connect the “time” parameter of the simulation to a slider so that it can be key-framed independently. In the process I wrote some compounds to help simplify the set-up of rigid body simulations when no kinematic bodies are involved. 

If you haven't seen it you also to have to check out this great video made by Chris Murray showing off the MCG Animation Controllers feature. 

https://vimeo.com/135870585

I hope you find these examples useful. Check out the MCG Facebook group and the MCG hub at ScriptSpot for other samples from the user community! 

To celebrate the fact that we now have over 3000 members on the MCG Facebook page, and to make up for the long periods without posts I wanted to share a new set of MCG tools and compounds: you can download the MCG Sample Pack 2 here.

Before installing the Sample Pack I recommend you first back-up your entire MCG user folder (%userprofile%/Autodesk/3ds Max 2016/Max Creation Graph). You can then un-zip the file contents directly into your MCG user folder. This package includes all of the tools and compounds from the original sample pack and includes updates to the MCG curvature sample, so overwriting existing files should be fine, unless of course you made your own modifications to these tools or compounds, which is why I strongly recommend backing up your folder!

At the core of this sample pack is a set of modifiers called the Flux toolkit for performing object cloning, placement, and creating animations. These mini-tools work together to enable users to create sophisticated effects as demonstrated in this video:

http://www.youtube.com/watch?v=CDkP1cjOLBU

Even if you don't find the Flux toolkit directly useful it does demonstrate a very powerful workflow for MCG tools: using Map Channels to share data between tools. It also serves to showcase and test a large number of new compounds the address common challenges that arise when writing MCG tools. For example orienting objects towards another, generating random points on a surface, interpolating positions and tangents along a spline, and so forth. 

How Flux Works

Flux works by storing transform matrices in a map channel to represent the position, rotation, and scale of each cloned object. You place a Flux initializer modifier (e.g. Flux_Initialize_Vertices) on an object to initialize the map channel. Next you place the Flux modifiers you want. Finally you add a Flux_Evaluate modifier on top to generate clone a mesh at each of the matrices.

Things get very interesting when you use the Flux blend modifiers (e.g. Flux_Blend_Falloff) to interpolate between the top and previous Flux effect. This is where the “combine effect” check-box can be useful. Most Flux effects also have a "strength" value that allows you to control an interpolation between the Flux effect (or combined effect) and the previous effect. Flux effects can also be copied to and from other map channels to enable your to reuse intermediate effects (e.g. using Flux_Store_Data and Flux_Load_Data). 

Extending Flux Yourself

While Flux is very flexible and powerful you may find that non-trivial compound effects require a lot of clicking to switch back and forth between modifiers, not to mention your scene will slow down substantially when there are too many modifiers on your stack. This is where you can look into using MCG to create your own Flux tools that combine effects. The graphs for these tools are designed to be small and easy to understand so that you can reuse and extend them.

Some of the samples even show how Flux can be extended to do unexpected things like creating meshes.

Final Words 

A big thank you to the amazing team working on Max Creation Graph and to the support of our user community! 

Introduction

For those of you new to this blog, my name is Christopher Diggins, and I am a principal developer on 3ds Max. I work at Autodesk out of Montreal, Canada, and I have been fascinated with programming language implementation and design for 20 years. 

The last couple of years have been a real high point in my career, because I was being paid to design and implement a commerical programming language! The result was a functional visual programming language built into Autodesk 3ds Max 2016 called "Max Creation Graph" or MCG for short.  

In case you are unfamiliar with 3ds Max, it is a comprehensive 3D modeling, animation, and rendering, solution for games, film, and motion graphics artists. It is also free for students and educators:  http://www.autodesk.com/education/free-software/3ds-max.  

About MCG

MCG was initially developed as a way for people to create add-ins for 3ds Max that could create and manipulate geometry. Since geometry is mostly arrays of data (indices, vertices, faces, colors, UVs, selection sets) we decided to make a language that could efficiently manipulate large arrays of data. Because we wanted the language to perform efficiently and predictably in a multi-threaded environment it made sense to take ideas from the functional programming community, and to make a statically typed pure functional language. To be fair, while the core language is pure functional, there are currently a number of stateful objects (e.g. Caches, random rumber generators) and large number of operations with side effects. Interestingly, we have found the pure functional approach to be very rewarding and will continue to work towards making it more pure in the future. 

Language Influences

Statically Typed

MCG is statically typed. This means that the certain ill-formed programs and computations are detected at compile-time. For example in MCG you cannot add an integer (Int32) to a floating point value (Single), so the type system will detect this at compile-time and reject the program. In addition to the increased assurances that your program is correct, a static type system also enables the compiler to emit more efficient code than when types are checked dynamically at run-time.  

Functional Programming

In a functional programming language such as MCG functions are first class citizens. They can be dynamically created, passed as function arguments, or returned from functions like any other data type. They can even be stored in arrays. In my opinion, an excellent explantion of functional programming can be found here on the Haskell Wiki. 

Graphs as Computation 

Computations in MCG are represented visually as directed acyclic graphs. Connections are implicitly directed from left-to-right. Each node in the graph represents a function (called an operator) that is applied to its input values. Each graph rooted at a particular node is an expression that represents the application of the function to its inputs. If the “function” output of a node is used then the value output is an anonymous function (lambda abstraction) representing the graph’s computation. 

When capturing a graph’s computation as a function the function arguments are the set of unconnected inputs in the graph.

The order of the arguments are determined by the order in which they appear when searching the graph right to left and top to bottom. The following example is from “OffsetMeshes” which offset each mesh in an array by a vector multiplied by its index in the aray.

For a more detailed tutorial on how function connectors work in MCG, check out Martin Ashton’s excellent two-part function tutorial on the MCG blog.

Creating New Operators with Compounds

New operators in MCG can be created from graphs called “compounds”. A compound graph is saved with the extension “.maxcompound”. Compounds graphs must use an “Output: compound” operator as the terminal node of the graph, and use “Input” nodes (as opposed to “Parameter” nodes used by tools) to represent the graph’s inputs.

When a new compound is created and saved, it will be made available to the user (assuming it validates correctly) when the “Reload Operators” menu option is chosen. The next time 3ds Max starts up its signature will also appear in the help file. 

Because MCG has a type-inference engine you don’t have to explicitly specify the output type of compounds, and can even specify “Any” for input parameters. The MCG compiler will attempt to assign the most precise type signature that can be determined will be assigned to the new operator. You can use “Pass-through” operators to help the type engine determine more precise types if needed. 

A compound is akin to defining functions in a text-based programming language. Like any programming language MCG is most effective when you break complex algorithms up into small well-defined reusable functions.  

MCG Type System

The MCG type system is a subset of the C# type-system. Like C# the type system of MCG supports generic types and typed functions. The core primitive types of the MCG type system are:

• array type (IArray<T>)
• function types (Func<T>, Func<T0, T1>, etc.)
• tuple types (Tuple<T0, T1> and Tuple<T0, T1, T2>)
• integer numbers (Int32)
• floating point values (Single)
• and Boolean values (Boolean).

There are a number of additional types that have been added to help with geometric processing (such as TriMesh and Vector3) and for interfacing with 3ds Max (e.g INode). 

What is displayed in the UI of the operators is actually an approximation of the type (e.g. IArray) but if you read the operator help or hover your mouse over a socket, you can see a more precise representation of the type. The approximation of the type is provided to do a preliminary type checking in the UI. For example the UI won’t let you connect an Int32 to an IArray, but it will let you connect an IArray<IArray<Vector3>> where only an IArray<Single> is allowed. The final type-checking is done during the graph validation stage (which is also performed during evaluation and saving). 

Immutable Data and Purity

A key feature of MCG is that it encourages a “pure functional” approach to constructing programs that avoids the usage of side-effects or mutable state. Most data structures in MCG (e.g. arrays, meshes, tuples, vectors) are immutable data structures, meaning that they cannot be changed, you can only construct new versions of these structures. One result of this is that repeated calls to an operator like “SetValue” may create an entire copy of an array and can be inefficient. That said the MCG compiler employs strategies such as lazy evaluation to mitigate the performance issue.

Immutable data structures offer several advantages :

1. It is easier to reason about the result of a computation: order of evaluation in inconsequential 
2. Once a valid data structure has been constructed it cannot “go wrong”. This eliminates a very significant category of software defects. 
3. Multi-threading becomes most efficient: locks are no longer needed to synchronize access to data elements. Because values never change, there is no possibility of race conditions
4. The compiler can perform employ advanced optimization techniques

Lazy Evaluation and Referential Transparency

The MCG compiler may choose a different internal representation of an immutable data structure if a computation always returns the same results given the same inputs and is side effect free. This property is called referential transparency. 

An example of an optimization performed by MCG is the “Range” operator which creates an immutable array of N integers from 0 to N-1. It is implemented “lazily” in that it generates values as requested rather than allocating a large block of memory filled with integers. 

This is similar to how LINQ (Language Integrated Natural Query) expressions work in C# and the lazy evaluation strategy of Haskell.

Side Effects

Functions with side effects create observable changes in the computation environment. For example they might change the state of a data structure, update the file system, or print something to a console. Examples of operators with side effects in MCG are “Print”, “PseudoRandomFloat”, and “CreateEditableMesh”. In computations with side effects the order of evaluation matter. 

Wherever possible you should avoid using functions with side effects, especially in higher-order array operations like “Map”, “Filter”, and “Combine” where there compiler may choose to evaluate the argument in different orders. 

Higher Order Functions: Map, Filter, Combine, and Aggregate 

Using MCG effectively requires the usage of a special class of higher-order array processing functions. Any function that takes another function as an argument or returns a function as a result, is called a “higher-order function” or HOF for short. Higher order functions are very useful for working with sequences or arrays of data, as they enable you to describe succinctly data transformations without having to use loops or variables.  

In MCG arguably the most important array operations are “Map”, “Filter”, "Combine" and “Aggregate”. These are similar to the LINQ operations in C# “Select”, “Where”, "Zip" and “Aggregate”. In some programming languages the "Aggregate" function is called "fold" or "reduce". 

Map 

The map operation transforms an array into a new array by applying a function to all elements in a source array. 

Filter

The filter operation applies a predicate function (a function with one argument that returns a boolean) to an array and returns a new array that contains only elements for which the predicate is true. 

Aggregate

An aggregate operation applies a binary function to each element in an array with an accumulator value, updating the accumulator value as it goes. The following example computes the sum of an array of values (whether they are Int32, Single, or Vector3). 

Combine

The combine operator applies a binary function to pairwise elements in two separate arrays to create a new array. The following example computes a dot product of two arrays. 

MapWithIndexes and Beyond

With the initial building blocks of “Map”, “Filter”, “Aggregate”, and “Combine”, it is possible to create new operators that are more specialized such as “MapWithIndexes” that acts as a “Map” but takes a binary function which takes the current index as the second input. 

SelectByIndex

Another compound (built using "Map") that is very useful in array processing and that deserves special mention is "SelectByIndex". The "SelectByIndex: operator takes an array of indices and an array of valeus, and returns a new array that contains the values as specified by the indices. Using this you can for example retrieve the vertices of a mesh arranged by face. 

Multithreaded Operators: ParallelMap and ParallelCombine

Currentlly there are two operators in MCG that compute results in parallel: ParallelMap and ParallelCombine. These are functionally equivalent to Map and Combine, but are multi-threaded. You should only use them when you have identified a performance bottleneck. It is very important that the function arguments do not call any of the 3ds Max operations, since 3ds Max is not thread-safe. Note that overusing these operators can actually slow down your code.  

Debugging MCG Graphs in Visual Studio

MCG tools emit a text output in the same folder as tool (e.g. mytool.txt) that can be loaded in the Visual Studio debugger. If you attach the Visual Studio debugger instance to 3ds Max you can set breakpoints in the text file and inspect the various values. 

This text format can be useful for understanding how MCG graphs are converted to byte-code. You’ll notice that variables are declared and the results of the expression are assigned to variables. This allows graphs to be reused in multiple computations and to only be computed once. 

Control Flow Operations

MCG is designed primarily for the processing of arrays of data. Many computations in MCG are more easily and efficiently solved when they can be expressed in terms of array operations. There are only a handful of basic control flow operations in MCG, but more can be defined using a bit of ingenuity and functional programming. 

The most basic control flow operator is the “If” operator which performs conditional evaluation of one of two inputs depending on whether the condition input is true or false. 

The “While” operator is a looping operator takes an initial value and two functions a loop body and a termination function. While the termination function returns false for the current value, the body function is called given the current value as an input. The result of the body function is given to the next iteration of the loop. 

The “Repeat” operator is similar to the while function but instead calls the body function a predetermined number of times, and also passes in the current loop index. 

As an example of how to build more control flow operators, this example a “RepeatWithoutIndices” compound is defined using the “Repeat” operator. 

Notice the usage of the operator “IgnoreSecond” which returns the first input, and does nothing with this argument. This operator is noteworthy (along with ignore first) in that it can also be used to help force the arrangement of inputs and function arguments. 

Partial Application (Binding)

A slightly more esoteric higher order function that can be useful in some contexts are the various “Bind” operations (e.g. Bind1Of2) which create functions by binding (fixing) arguments of the function to a particular value. This process is called “Partial Application”. The result is a new function that requires fewer functions than the original. 

This advanced example demonstrates a generalized cartesian product function (f(xs[0], ys[0]), f(xs[0], ys[1]) … f(xs[n], ys[n]). The “FlatMap” operator applies a function (T -> IArray<U>) to each element of an array (IArray<T>) but instead of returning IArray<IArray<U>> flattens the entire result into an IArray<U>. 

One area where Bind has become quite useful is dealing with stateful objects like the random number generator. I'll refer you here to another excellent Blog post by Martin Ashton for more detail on this usage of Bind in this context. 

Final Words

Thanks for following me down this long rabbit hole. I hope this article whetted your appetite for functional visual programming and that you consider give MCG a try!

PS: I'm especially interested in hearing from computer science educators interested in using MCG to teach functional or visual programming to their students. 

In the M&E division at Autodesk we have periodical hackathons where entire groups are given the opportunity to work on projects of our chosing for two-three days. We are then given the opportunity to showcase our work to the entire division and receive feedback from our leadership. I love this, because I get to work together with some really smart people on some interesting ideas. 

One of my hackathon projects last year, which I worked on with Kelvin Zelt, was to develop a simple particle system with MCG. Kelvin dubbed it project "Sprinkles". We managed to get a demo to work quite decently by using MCG as-is without any changes. We also found ways to make the core MCG evaluation much faster via lazy evaluation of arrays, but I'll save that for another post. 

In the Montreal Autodesk office at 10 Rue Duke, we have been hiring a lot of interns. This program is a huge success, and I encourage students to check out the listings. In fact several recent hires have come from the intern program.  On the MCG team over the last year I have gotten to work with Kevin Derler, Marc-Antoine Nadeau, and Remi Cosette-Roberge. It has been a great experience for me, and they seem to have enjoyed it as well! 

Recently Remi took the particle project to another level: encapsulating a lot of the behavior in compounds and multi-threading the graph evaluation.  

https://www.youtube.com/watch?v=-NNu6amC3i4

Because this was done using 3ds Max 2016, I thought I would share it with you is as both an inspirational use of MCG, and a tutorial for some advanced concepts such as:

• Parallel pseudo-random number generation - see "RandInt" and "RandFloat"
• Using Ray Trace scene to quickly compute collision 
• Caching to manage ray trace sceen 
• Using simulation graphs to have predicatable results 
• Encapsulating complex behavior in compounds and using functions to describe behavior (e.g. particle construction, destruction, and updating). 

This MCG tool is not a real particle system, it is just a geometry objec that it generates a TriMesh that consists camera facing squares with UV coordinates, and vertex colors. Neither Remi or I are particularly good users of 3ds Max (though Remi has more skills than me already) so hopefully someone can share a better example! 

Here is the tool and a couple of sample 3ds Max files. You will need 3ds Max 2016, with at least SP1 installed. I hope you find it fun and useful!