Virtual-Reality Procedural Experiences with 3ds Max Software’s Max Creation Graph and Stingray

LOUIS MARCOUX: All right, so thank you everybody for skipping the keynote this morning. I was told it was going to be the best keynote ever at AU. So you're all going to miss it. So thank you for coming. My name is Lou Marcoux. That's pretty much enough you need to know about me because we need to focus on the class. I got tons of content, and going to focus on it.

So this is a very long name for the class. What I submitted to the company was VRIs and MCG. So I got it extended to a paragraph. So that's-- now we're going to talk about virtual reality procedural experiences with 3Ds Max, Max Creation Graph and Stingray.

So basically what I want to do during the class is kind of defining my objectives at the bottom there. We're going to look at MCG to create procedural content. And in the end, we're going to bring it in Stingray to experience it in VR. And I'm going to use the roller coaster project that I've been working on for a while.

Some of you may have seen some people, like Matthew Doyle, doing a video on YouTube on how he used it. What I'm going to cover today is completely different. We're going to dig into the Max Creation Graph, the thinking process on how to build procedural content, and how we can-- what we need to bring the Stingray in order to create the VR experience out of it.

How did it start for me to work with the Max Creation Graph? Basically, in August 2015, one of my colleagues was presenting to the CTO Council for game developers at SIGGRAPH. And he said to me, I'd like to be able to present these guys-- the Max Creation Graph was just out. It was 2015 last year. And he said, I'd like to be able to present to them a procedural tool that would allow them to very quickly create a racetrack, be able to redefine the path of the racetrack, add a few settings to make it automatic, like the width, the curb size, and all of that.

Also, he wanted it to be flexible enough to be able to add the correct decoration on the sides, like lights, barriers, things like that. But he wanted everything to be interactive. So that was the project that I built to learn the Max Creation Graph. It was a very fun project. It was a learning project for me, but it's also the kind of tool that you can build for-- with the Max Creation Graph.

This was my first project. And after that, we used it for multiple contexts. We used it at AU last year. We built an experience for the [INAUDIBLE]. Someone built [INAUDIBLE]. So we used the vehicle template in Stingray. We've drawn a path with it, and we use this tool to decorate the environment.

So that was my first project. And believe me, after this project, I was like, oh my god, I need to do a post-mortem, and rethink how I build things in the graph. Because I approached it the hard way. And after that, I was like, I need to rethink all of this. I had a big spaghetti of nodes. It was very hard for me to go back to these nodes and trying to figure out what I did. So what I did was I stepped back, and I said, what are the building blocks of this, and how can I create blocks or components that would be reusable and allow me to reuse in a different context and be more flexible?

So that's kind of-- after that project, I was like, I need-- this is kind of my thinking process. And I came up with a few recipes. And what I'm going to talk about today mainly is, we're going to use a roller coaster project as the base for the class. But it's-- going to show you my recipes. I'm going to give you my recipes. And I'm going to give you enough material for you to go back home and redo what we're doing here. I'm going to cover the high-level concepts.

And if you stay until the last slide, like any other classes I've given at AU before, on the last slide, there's a big surprise. I've recorded a lot of content for you to go back home and try the things that we are going to do today. You will have access to everything that I'm showing and also detailed explanation to go a bit further.

Because in one hour, to build a roller coaster, it's impossible. So we're going to go over the concepts, the tools, and then you're going to be able to go back home and try them yourself. But nothing that you're going to see on screen today will-- sorry, let me rephrase. Everything you see on screen today will be available to you after the class. So those will be my recipes.

Before we get into the actual technicality of it, I want to define procedural content because everybody has a different definition. My understanding of it, of procedural content, is we are going to use procedural tools to build or to model something inside of 3ds Max. So for me, procedural content is a meaningful system. It's something that I can describe with very few settings-- second line-- very, very few parameters, but it allows me to define something that's meaningful.

The drawing of a forest there kind of represents that. If I am in 3ds Max and I start, I open a new scene, and I want to create a forest, I will go into the Edit Poly. And will start to model a leaf and then a trunk, and then I'll probably copy that a few times around the tree. And that's what I call manually creating the content. But in a procedural kind of thinking process, I want to define a forest to be-- this is about this length and this width, this wide. I want it to be about this high, and I want to define a few parameters and generate a forest.

So procedural content is with very few settings, be able to create relationships and cloning and transformation, mathematical functions, that will define all of the internals of building a forest so that at the end, you can only define a few things and you get a forest inside of your scene. So our goal with procedural content is to create simple tools that within the production will have a large influence on your scene. Like I said, if you have to model the forest leaf by leaf, you're going to be working on that for a week or two. But if you have to just give it a length and a width and a height, you'll be able to create it much faster.

So you can also create conditions, that if you are in the winter, the forest doesn't have trees, it doesn't have leaves. So in my country at least, we don't have leaves during the winter. So that's the kind of stuff that you want to define procedurally. There's different tools that you can use to work procedurally. You can use MAXScript. You can use C++. You can write C++ plugin plugin.

At Autodesk, there's Dynamo, which also a good procedural content creation tool. If you look at SideFX Houdini, there's a node graph in there where you can also build procedural tools. But in my case, I'm using the Max Creation Graph because I'm a 3ds Max artist. I've been using Max for a long time now and this is what I use. And this, I started to use it a couple of years ago when it got released with 3ds Max.

So what is the Max Creation Graph? The Max Creation Graph is a system to build procedural tools. And it allows you to build the packages that will be available in 3ds Max. In Max, if you're a Max user, you're probably familiar with the concept of wire parameters. So you have a node and you connect the exposition with the scale of this thing. So it has nothing to do with that. So visually, you could think that oh, yeah, we're wiring things, and it's a wire parameter tool.

No. What we're doing in here, we're taking inputs from the users. We're going to pick nodes inside of 3ds Max. We are going to connect nodes to create or to modify these things. And we're going to create an output. And this output could be a primitive, modifiers. You can create your own modifiers. You can create your own controllers. There's a lot of things you can create more than this. But mainly, the graph will allow you to create tools that you can package for use in your production.

So that's kind of the idea. And when you're going to look at the graph, you'll see that we have a lot of nodes, a lot of compounds, a lot of functions that you can use to process the data, to change the data, to create custom primitives, and output that through the graph. So let me just show you very quickly how the graph works. So the graph is in scripting. If you go to Max Creation Graph, open the Max Creation Graph window. When you open it for the first time, it's empty.

And when you create a new project, it's always good to give it-- define who's the author for it and give it a category. The category will define where this tool will reside in the 3ds Max interface. So the category here, we're creating a primitive. It's going to have its own category in primitive, It's going to be called AU and this is where your tool is going to land. So I'm giving you the category. And when you save it, you give it a name. And that's also the name that I'm calling it-- AU Box.

It's funny, I was in the Eric Craft's class yesterday. And he was giving a class on MCG, and he's doing a box as well. So you'll be able to create boxes when you go back home if you've seen the two classes. So-- OK, now we have an empty graph. To create a box, we need to define how is it going to create the box. So on the left here, you have all the nodes. They're about 1,000 nodes that you can use for creating content in the Max Creation Graph. And yes, I'm going to cover every single one of them before the end of the class. No, I'm not.

I'm only going to use the ones that we're going to-- but what I recommend, and I still haven't learned them all, that there's-- you search and then you find something that makes sense. You bring it and you try it. And it helps you. But there's no way to cover-- and, like I said, I didn't even study all of them yet. So we have about 1,000 nodes. When we want to define what type of tool we want to build, we want to look for the output.

So we have a few outputs there. We have transformation controllers, compounds. What do we want to do is we want to create a box. So we want to create a custom geometry. When you press the X key anywhere in the user interface, it brings the search window as well. So you can search directly from there. So I'm going to search for create box. I'm going to find it. And now we have a node that allows us to create a box.

The create box has an output called TriMesh. TriMesh means it's a triangular mesh. This is the raw triangle of data that creates a primitive. So this we can connect it to the output and we now have a tool to create a box. It needs input so we need to define a width, a height and a depth. So we can drag out the width. And when you drag out like this, it shows you only the parameters or the nodes that are compatible with this input.

So we know that it's a singles. We're going to look for a parameter single. And a parameter is something that's going to be visible in the user interface of this tool, which means that now I'm going to define the name for it. It's going to be called a width. I give it a default value. And this is now what I'm going to see in the user interface to be able to provide the width.

The lazy way of doing this, you can right click, and at the bottom there it says generate parameters. When you say generate parameters-- you get all your parameters created automatically. You can set up the default values so that they are meaningful. And now we have a tool that creates a box. You evaluate it. You look for it in the category called AU. And now we have AU Box and we can create box.

We support everything which means that AutoGrid is also accessible. So we can use all the Max tool with this new primitive that you've created with the Max Creation Graph. What's interesting is now we can create a box. And you're going to say, wow, I could create a box in the Max user interface? Yes, good point. I'm glad you bring it up. The idea is that now that we have this box within the graph, we can do other things with it, and then we can start to build something that's a little bit more complex.

So in this case, I'm going to create a new node called the Transform Mesh. The Transform Mesh is your best friend because it allows you to take a mesh, transform it-- translation, rotation scale-- and output the transform mesh. So what you can do is you can bring it into the graph. If you hold the Control key as you drag it into a line, it automatically connects. So it's a very nice workflow to add nodes.

As I said, when you drag out of a node or an input, it shows you only compatible things. So it's going to look for the translation matrix. I want to add a translation matrix here. Then the translation matrix needs a position. The position is defined by three values and generating parameters. And now I'm using Control-Alt to move this. But the idea is it's very quick to start to build tools.

The thing about the graph as well is every time that you have a description of a mesh, you can take that mesh and you can combine it so that you can have multiple versions of that mesh. What I mean by that is that right now we're outputting the transformed mesh as the output. I'm going to connect that. And I'm going to use a tool called Combined Mesh. And this Combined Mesh tool allows me to bring in two meshes together for the output.

So what I'll do is I'll just grab the transformed mesh, and I'll grab the original mesh and connect the two together. So now I have two cubes that will be translated from one to the other. So if I look at the parameters, now you have a bit more parameters. So I translated an x, but I can change the width, the height, and the depth of the box. And we've created a system of two boxes.

When you start to-- you see we only created two boxes, but already we have a big spaghetti in front of us and it's hard to find. Where did I do this box again? So what I recommend is when you're done with something, create a group. You can color code it. Give it a name. And you can even put comment in the group so you know that now this is where I create the box. I can-- if I go back to this graph, I'll be able to find where it is, where I did create the box.

But now let's go to our real project, which is not a box but a roller coaster. So I want to show you the thinking of how we're going to build a roller coaster. This is an image that I took from the internet. So I have absolutely no rights for this. So-- but the thing is when I approach this-- when I finish the racetrack toolkit, I said, I want to do a roller coaster. That's going to be fun. And I can reuse some of the stuff that I've done. But I need to have reference. So I went on the internet. I look at a couple of images that are typical of roller coaster. And I chose this one, and that was my reference to do pretty much everything that I did for the roller coaster.

So what do we have here? What do we need to build to generate a procedural roller coaster? We have the rails. Yeah, the rails will have a size the distance-- I want to be able to change that. I don't want to be stuck with the rail that the system is going to give me. Same thing with the central beam. It has a size, it has a distance from the main rail so I want to be able to adjust that. I want that to be flexible.

Then we have the ribs. Some roller coasters have a lot of ribs. Some have less depending on the structure. But this is also part of the system. We have the section joints. They had little-- every-- you know, it's kind of a-- its a detail that stands out when you look at roller coasters is those joints. And I wanted to be able to see them as I built my roller coaster.

Then we have the pillars. One of the main thing is they need to not be in the way. So I can not put pillars only under my roller coaster because when they start to twist, I want my roller coaster to be able to go through and not have pillars in the way of the roller coaster. So also the pillars will have a size. Some roller coasters will have more. Some will have less. They are all based on the ground. So we have to take that into consideration.

Then we have the train. The train is made of wagons. It follows the track, hopefully. If it's safe, it's going to follow the track. It has a traction at the beginning of the ride and then after that it's all moving based on gravity. So I need to take that into consideration into the system as well.

To define where the roller coaster goes, that's something I've learned as I was building. We define what we call a heart line. The heart line is where your heart goes through the ride. And then you define the up direction for everywhere on the roller coaster. So if you want to make it twist upside down, you will need to define the other direction.

So my goal is to create a system where I can adjust any of these parameters. But I just want to use the heart line to define where the roller coaster goes. And I want to use an up line to define the up direction of my roller coaster. And I want it to be connected to the ground so that all the pillars, all the support, will be done automatically. So as a user of this tool, I'll create a couple of lines. One for the heart line or for the up. And then we're going to use a ground with that and it's going to be our system. And then the rest will be all adjustable with parameters.

So now that we know the project, we're going start studying how we are able to create a custom mesh. We're not going to do a box anymore. We are going to create our own mesh with an MCG. But before that, we need to understand how we create a mesh procedurally because we're used to 3ds Max, where we're going to create a primitive, add flows and edges and rings and all of that. That's interactive modeling. But we're not doing interactive modeling. We are creating the procedural tool.

So when we look at the rectangle procedurally, if I use Max script, it's going to be the same kind of thinking, or C++ plugin, as I write my own thing. It's the same thinking. So you have a rectangle. It's made of four vertices. And it has two faces. So I need to describe that to the system. It's good to start with numbering the vertices because you need to make some connections or correspondence. But the concept is always the same. So we start by describing the vertices. We define the position in space. So if I want to create a 5 by 5 rectangle, that would be the position in space of the four vertices that I'm using to create the space, this rectangle.

Then we need to define the face and where they point forward. So if we want a face to point towards us, we need to define the vertices that will create that face. And we need to define them in the order counter-clockwise so that it's pointing forward to me. If I wanted it to point away from me, I would say clockwise, define the vertex order.

This is what we call face indices. So face number one is defined by 3, 2, 1. The 3, 2, 1 vertices. And indices for the face number 2 is 3, 4, and 2. And it's counter-clockwise. That's how we defined this. But that's not all because a lot of that stuff, a lot of what I'm going to talk about now happens automatically in Max. If you create a rectangle in Max, it's going to generate UV Map, smoothing group, material IDs. If you do it procedurally, you need to define it manually as well.

So we're going to define smoothing grooves for all the faces. We need to define material IDs. And we need to define UV Map for every single vertex. Where is that vertex in the UV Map space, the one-by-one space that defined how a texture will be applied to the rectangle.

So if we want to do this in MCG, a single rectangle, simple rectangle of two triangles, this is how it would be done. You would create the output to geometry like we've seen. We would use a node called Create Mesh. Create Mesh accepts vertices, as we saw, and indices. So what we need to do is that we need to define an array. We have four vertices so we're going to use an array of four. And we have two faces, so we're going to use an array of two. And we then need to feed that with the data about the vertices and the faces so we can use Vector3 input. Vector3 in the first case, is the position of every vertex. And in array number two, the Vector3 is the three points or the three vertices that will generate the face.

But all we have now is the description of the rectangle. Now we need to define the set smoothing group. Again, we had a new node. We send a smoothing group with an array, and we define the array. Like we would say, smoothing group one or two. And you would define that as constant.

Then we define material IDs. And then we define the UV maps. Then we get what? A rectangle. That's a lot of work. But if you look at the simplest component of my roller coaster, it's a bolt. A bolt has 36 vertices and 50 faces. That's a bolt that I've modeled in 3ds Max very quickly. That's the bolt that I want to use in place around my roller coaster so that it all holds together.

So I have to replicate all these nodes to create the bolts. And believe me, I've done it with the racetrack tool kit. This is how I learned it. And I was kind of junior using the graph and I've build faces one by one. And it was very time consuming. And I said, never again. So I'm going to share with you a recipe that you can bring back home to make it in a very much simple fashion.

What I discover in the graph, there's a tool here called Split. You provide it with a string, and a delimitation character. Does that say delimitation? That exists? And what it does, it creates an array of values based on your string. So I can use that to create vertice-- the vertices description. So I can provide a string, and it's going to put an array. And my array could be the description of my vertices. Oh, I'm saving a bit of time.

I apply the same context for indices, Mat IDs, UV Maps, and Smoothing Groups. And I was able to build a single compound that allowed me to input a string, and it outputs a mesh after. So this node here is now your best friend. It's called LM String to Mesh. LM is for Louis Marcoux, that's me. It's mine. But I'm giving it to you as part of the distribution file. And also I have recorded a small tutorial on how to install it on your system. But if you are serious about using the Max Creation Graph and you want to hard code some geometry as part of your tools, you can use this simple tool and you can output the geometry.

So the way it works is very simple. It's very simple now. But at the beginning, it was not simple. The idea is you provide it with a string that describes all your mesh. And it processes it, and it outputs the geometry that you want. In the graph, if you want to write that script-- well, not that script, but that description-- you use the constant node and you go in and you type all of this manually.

And I got bored by this very quickly. So what I did is I built a script that I called Get Mesh Info. So you select the mesh in 3ds Max that you've modeled. You just run this little macro script. And it puts the string into the clipboard. You can paste it and then you have your description for your mesh.

So for the roller coaster, this-- I'm going to use it a lot today. That was my best friend. And then like I said, I'm giving you both the macro script and this so that you don't have to ever think about anything else than this. So this is now the-- my recipe for you to create custom mesh and combine them into the graph.

So let me show you very quickly how we can use this. So this is the bolt here. I select it. Then I run the Get Mesh Info. Once it's run, the data is in the clipboard. I use the constant node. And all I have to do is just to use Control-V to paste the string. And I'm not going to read the string. I know I trust it. I've tested it a few times. It's going to work. And now I connect it and I'm looking for LM String To TriMesh. And I know that it's going to generate the TriMesh. I'm going to output that as a geometry. We compile it. It's in the AU. And now I've got an AU bolt. I've taken the model. And we have-- and it supports the auto grids so I can put bolts anywhere in my scene.

But now that we have this in to the Max Creation Graph, what's going to be interesting is we can now start to build systems of bolts. So creating one bolt is cool, but we want to create systems of bolts so that we can make a bit more complex system. So I'm going to use a tool here called Combine All Meshes. Combine All Meshes accepts an array of meshes. So I'm going to create an array of meshes by using another node, called Clone Mesh at Position. So Clone Mesh at Position takes the input of the mesh, and then it takes an input-- an array of position in space. And it's going to clone that mesh everywhere on that.

So instead of creating the array manually, I'm using another node called Circular Arc of Points, which creates a circle of points. And it has a count, a degree and a radius. I'm just generating the parameters, automatically compiling this. And now what I've got is a tool that allows me to put bolts on a circle very quickly, define how many I want. And you can do some interesting things with it already.

If you think about it in the context of the roller coaster and how the roller coaster holds together, we can put this at every section. It's very few nodes, and we get that into the system.

So system of components. This is what I just did. I created one component, and I create a system of them. And we have a ring of bolts. So let's take a look at the problem of a pillar. So I want to create a pillar. And if you look at the pillar, it could be represented by a set of a few primitives. I want to be able to change the height. So if I change to height, the ladder will change. I'll have more steps on the ladder. I'll have maybe more sections. I want to be able to adjust the size and all of that. But if I want this system to be procedural, I want to narrow it down to the simplest description as possible so that someone that creates a pillar just have to enter a few parameters, and we have a pillar.

So I came up with this conclusion. The size, how big it is. It's going to influence a lot of things like the base. It's going to influence the size of this and the size of the ladder. The total height, where is it that it needs to be to support the roller coaster. The base height. This is the concrete part here. And the section length is how far these sections are apart from each other.

Once I've got that, I think I can build the pillar. So if we look at this, we can create a small primitive for the base. And if we scale this up and down and sideways in the width and the length, I can create pretty much any base I want, and I can find out the right proportions when using those parameters. Then I can put the anchor, which is that part over here, I can just put it on top over there. And I'm able to put it in the right place. And again, scale it so that it fits to the top. Then we can put bolts to put it all together. I can create the main pole by just using a simple cylinder. I can create a section using the same type of idea. Then I can have a very simple primitive that represents one step in the ladder. Clone it multiple times to the top, and scale it as needed.

And then I have this little primitive for the base of the support there. Like I said, I face it on the reference that I had at the beginning. So I'm trying to replicate it as much as I can. So you start by using all of these simple primitives. And by transforming them based on relationships here, I can create the pillar. So that's kind of the thinking process when you are building something procedurally.

So as you can see, transformations are very important. And when you want to use small primitives to create complex system. But in the 3ds-- in the Max Creation Graph, the transformation are very picky. If you are transforming things inside of the user interface of 3ds Max, you pick an object, you decide if you rotate it on its local pivot. If you want to scale, is it going to be scaled on the local pivot?

But in the Max Creation Graph, when you click with the mouse to create your primitive, this is becoming the local space of the object, and this is 0, 0, 0. Even if in world space it's at 10,000, it doesn't matter for the Max Creation Graph when it's creating a primitive. The local space is always always centered at 0, 0, 0, which is where you clicked to create that object. So all of those transformations are based on that location.

That has significant impact on your transformation. Because let's say that I have an object here-- well, let me use this. That's my pivot point. I create it here, then I translate it, then I rotate it, and then I scale it. And it goes away from me. So if we do the transformation in the wrong order, we get really bad result in its unpredictable results. So we always have to remember that when we modify things or when we transform a mesh inside of Max Creation Graph, there's no idea of parenting. There's no concept of arbitrary pivot point. You rotate everything at 0, 0, 0. You scale everything at 0, 0, 0. Everything happens at 0, 0, 0.

Therefore if you want to be successful at transforming meshes inside of the graph, you need to do the transformation in the following order. First, you scale so that you can scale without distorting your geometry. Then you rotate it at the origin, and then you translate it to bring it at the final location. And because you have to do all these things, you have to think about how to do them and all of that, there's a lot of mathematics involved.

So you'll have-- if you want to do these types of transformation, yes, you'll have to open your college books, and you'll have to learn mathematics again. And you'll probably say, ah, I don't want to do this. And-- but the reality is yes, you have to learn a bit of math. But in the handout, I've given you three links for refreshing, I think, the most three important concepts that I use for pretty much everything when I use the graph. The rule of three, which is very useful when you scale objects and you want to maintain proportions, or that you want to scale to a certain factor, the rule of three is very useful.

Algebra. So vector algebra, the normal of a surface where a vector cross a plane. Things like that. And I've given you a link to the formulas that you need to use. So you can just follow that link and use that as a reference. And also trigonometry is always useful, cos tangent, and all of that. When you do translation, place object in-- and you want to give them a position based on an angle that's always good to refresh.

So let's take a look at quickly how we can use these things together. So this is my basic primitives for the pillar. I'm not going to build everything in front of you. I'm just going to show you the high-level concepts. So I've just grabbed the mesh for this, the mesh definitions. So I'm using a constant, pasting that in here. I'm using the LM String to TriMesh. And then I'm going to create a geometry out of that.

And I want to define a transformation so that I can transform this object. So I'm going to do it in the right-- in the wrong order first so you can get an idea. I'm going to use a transform mesh node. This is your friend when you want to transform a mesh. This needs a matrix. I'm going to use a translation matrix to start. It needs a Vector3. So I'm going to grab the parameters and quickly name them so that they have a unique name in the user interface.

So all of this node system is for the translation. I'm going to do the same thing for the rotations or transform mesh with a rotation matrix with the proper parameters. And we have now the parameters to rotate the mesh. And we can do the same thing for the scaling using a translation-- sorry, the scaling matrix and all of that. We name it correctly.

So now we have three groups. The groups for translation, for rotation and scale. Now we can start to connect those transformations. So I am using the base mesh on the left there that we grabbed from the Max modeling. I translate it first, then I rotate it. And then we scale it, and we output the result as the geometry. So we save that. And if we use the tool, I called it Pillar Parts. Go click there. We have the 0, 0, 0 so we can translate it from that 0, 0, 0. We can rotate it. But immediately when you start to scale it, you see that it becomes tapered. It's distorted. It's not exactly the transformation that we would like.

This is because we've done the transformation in the wrong order. So I'm just to cut all of that and reorder my transformation to first do the scaling. So it scaled at the center. Then we rotate it at the center. And then we translate it and we bring it to the final position. So we're going to get much better results when we do something like this. So if I do now scale it up in any direction, and if I do rotate it, you'll see that it's going to rotate in place. This is the right way to do these things.

So now I'm going to grab the second mesh, which is the anchor. I'm going to grab the mesh info. I'm going to paste it in a constant. Same idea. So I'm going to paste it here. And I'm lazy, so I'm just going to copy all of that. And I'm going to connect it to this. So we have the string. We have all the transformation. We only can have one output per nodes. I'm going to delete one of them. And then I'm going to use the Combine Mesh tool that we've used before, combine these two together. And now we have a primitive that is based on these two.

I need to name everything uniquely, so what I'm doing for the second part here, I'm just adding the anchor prefix. And now we have a new set of parameters. And you see that now I can put those two in relationship to each other. I can scale it up, rotate it, adjust the base and all of that.

But now, what we have is a whole bunch of parameters. And if I want to create my pillar, I would have to do this manually. Like all-- and adjust all these parameters for my primitives. This is not what I want. I want to start making connection. I want to simplify this. And this is where the mathematics comes in. Mathematics will allow you to take the scale of the sky and connect it with the position of the sky, and depending on the height and all of that. So that's where the mathematics comes in.

Simple example, what we're going to do is the first node system is the base, and the second is the anchor. So we're going to take the scale of the base, and we're going to define the zed position, or z position, of the anchor. So that's what I'm doing here. I'm removing one parameter from that whole list. So I'm going to go into the scale there. We're going to open up the scale in zed. I'm taking this output. And I'm going to connect it to the zed position of the zed translation of the anchor.

You can compile. And now you can see that when we do scale up, it's adjusting, but it's not to the right factor. The base has a height of 3. So we need to scale it correctly. So this is where the real-- the rule of three comes in. I need to multiply this by 3. And I'm saying 3 because I know it's 3. But you would have to do it for your own calculation here.

So if I multiply the translation by a value of 3, it's going to be correct. So just adding a constant, putting a value of 3. And here we go. We have our final tool. So now if I do scale the base, you see that anchor will be on top. So if you continue this for a long time, and you make all these connections, you can create a pillar primitive. And the pillar primitive as only as you can see on the right there, four parameters.

So by using those four parameters, as you'll see there, I can change the size, I want it bigger or smaller. So just the scaling, the transformation, the total height, the base height. You see that the cloning of the ladder happens how it needed. The section length defines how many sections do we have. And those-- everything that's done here is just transforming these objects in relation to each other. So define this on paper first, how you can create this. Define your components, and that's how you can build something like a pillar.

Now that we have a pillar, we also need to build the rails and the ribbons and everything that's related to the ride itself. So we need to work with splines. And working with splines in MCG is cool when you want to create a spline. But when you want to interpret the spline to-do tools, it's a little bit different. But we're going to use the spline to create to loft along for the beam and the rails. And we're going to use the spline to also clone the ribbons with the proper transformation along the splice.

But the thing is, when you bring-- when we pick a spline, and we analyze it in the Max Creation Graph, we don't have access to a lot of information about that spline. We can extract. We could have access to the construction of the spline, how many vertices it has. But for us, it's not important. That's not something we care about. What do we care about is the position and the percentage.

So when we query a spline, yes, we can get a position at a certain percent on the spline, and that's it. You don't get anything more. There's no more data out of that. So if you want to know in which direction it's going because you want to create a rotation at that point, you have nothing. So what you need to do is you calculate the position at a percentage forward. And from that, you can deduct the direction vector for this.

Then the problem is, we have no up. We have no idea-- there's no notion of up or orientation when you're using a spline. So what we need is a second spline. And that second spline is kind of the copy-- you can use a reference. You can use anything you want. But you want to look up to find where-- at the same percentage, to find where is the up direction. So if you use that second spline, you can go and say, at this point, it's going to be upside down, then it's going to twist back up, and it's going to twist upside down. And you can bank it, and you can have a second spline to define where the up direction is.

Once you have that, because we have vector algebra in our back pocket, I can deduct the right vector. And now I have a coordinate system that allows me to rotate and translate for any point along the spline. So again, I'm lazy and I don't like to do this mathematics every single day and every single time. So if you want to clone multiple person values, what you would do is you will lay out your mesh and the origin. We have the ribs so we can just model it at the origin. And then we can scale it, depending on the size of our roller coaster. Rotate it, translate it, and it's going to be in the right spot.