Author: RoaringTide (page 1 of 17)



Molding02_Shape is a basic chamfer sitting atop a vertical line.



Molding02_Shape Palette

The two main parameters, width and height control the outer bounds of the Molding02_Shape.

The moldingHgt is the height of the upper portion of the Shape.

The edge parameter determines the size of the square that defines the upper edge.

SceneView Handles

The upper point handle controls the width and height of the molding. The lower handle controls the moldingHgt.

Turtle Script Description

The script for this molding creates an edge at top.

mov 0 0 90

fwd height-moldingHgt
drw width-edge height-edge
right edge
fwd edge
left width


Making Hard Edges

Archimatix gives a some control over the the smoothing or hard-edge faceting of edges in the meshes it generates. In this short tutorial, we will show how to specify that an object should have hard edges. We will also see how to control the hardness separately in the U and V directions.

The simplest curved object which has smooth edges by default is a Cylinder. Let’s get started with one!

Step 1

Open the Node Graph Editor and on the left side bar, click on the Cylinder to instantiate it from the Library.

You’ll notice that the sides of the Cylinder are smooth while the top and bottom edges are hard. This is because, since the source plan is a Circle with 16 segments, the default angle between the side polygons is 22.5º, below the default break angle for smoothing of 60º. The angle of the side polygons with the top cap is 90º, so that is a hard edge.

Let’s alter what the break angle should be.


Step 2

Open the Plan input parameter to reveal the controls you have over how this node would like to use the Plan. These controls do not affect the source shape, but rather make changes to the shape just before using it.

For example, you can reverse the Shape, flip it, give it an offset, thicken it. We are going to adjust its break angles.


Step 3

Looking at the Break Geom|Norms control, we see a MinMaxSlider, whose two knobs control the BreakGeomerty and the BreakNormal angles.

Break Geometry Angle

The left knob controls the BreakGeometryAngle, the angle at which the mesh will literally break the vertices so that they are not welded. This not only affects the UVs for texture placement, but it also also us to have separate normals for vertices on the mesh.

Break Normals Angle

The right knob controls the BreakNormalsAngle, the angle at which the normals will break the edge into a hard edge.


Step 4

Slide the left knob to the far left, or 0. This will result break all the vertices in the mesh so that all faces have their own vertices. For this particular mesh, we should not notice any difference in the UV coordinates for texturing. However, the BreakNormalAngle can never be more than the BreakGeometryAngle, so this is a necessary step.


Step 5

Now slide the right know all the way to the left, or to zero. Now every polygon will have its own normals perpendicular to it, leaving hard edges everywhere.








Topics in AX: Creating the Sublime Experience of Order-to-Chaos

Architectural experience (AX) is a subset of user experience (UX), particularly in 3D game environments. AX is generated by a number of elements that are found in real-world architecture, such as surface, enclosure, circulation, materials, light, details, etc. along organizational principles such as axial symmetry, repetition through a rule set, radial and linear arrangements, etc.

When designing game environments, level designers often begin with circulation and zones. The walls, doors and ramps are added to carry players through or hold them back in zones that spawn resources or enemies, signal the location of an exit, provide cover from enemy attackers, etc. While this design process is very important for having the game environment jibe with the central mechanic of the game, it risks missing an opportunity to focus on AX, where the player experiences a joy in the architecture itself. More often than not, the gray box becomes a bit more detailed and textured, with the result  that the architecture becomes minimal back-drop for the action.

Many games have become notable for providing AX above and beyond the basic facilitation of game mechanic. The Assasin’s Creed franchise is a good example, where the game environments are a fantastic blend of historic urban fabric modified to stage the player’s specific questing objectives.

Symmetry and repetition may be bad in many cases for player orientation and rich gameplay, but this does not mean the game AX can’t deliver the  beauty of axial organization, repetition, proportion, etc., since these qualities may always be eroded with further environment editing: deterioration of wall planes, toppled towers, carts that block one getaway, but not another, a blood stain on this column, but not the others, etc. In fact, according to mnemonic practices of the ancient orators, repetition + differentiation are the keys to spatial memory.

Modeling grand architecture can be challenging using polygonal modelers. There is a logic of architecture that one can execute by hand, but for complex systems, such as an ancient basilica with many columns and arches, this can be cumbersome.

One strategy is to use a parametric modeler to build up the complexity of the world procedurally, with certain noise factors in the mix, but then freeze the model and further edit it in a polygonal modeling system to break the logic with autographical gestures, adding uniqueness to the environment that enriches the logically generated forms.

When we see a post-apocalyptic cityscape, it is the sublime effect of order turned to chaos that captures our imagination. Rectilinear buildings with evenly-space floor decks are turned into more organic forms through the destruction of parts of the facade to deterioration at the corners. A regular grid of streets becomes an obstacle course of burnt out vehicles and fallen lampposts.  Pure chaos can also have its sublime quality, but is very different from order-to-chaos frozen in a post-apocalyptic environment.

Order-to-chaos can also be found in ancient ruins on a cliff that has succumbed to natural erosion. The power of ruins is in the eye’s shifting from the perception of the original order and the later organic or randomized form of this order. Perhaps it is the psychological joy of pattern recognition, where when confronted with a noisy tableau, we begin to sense an order or pattern hidden in the noise.

I would argue that, in environment design and construction that is interested in maximizing AX, a logical additive modeling phase with a procedural modeler such as Archimatix, ported into a polygonal modeler such as ProBuilder for an autographic, hand-gestured phase of modification is a powerful workflow to achieve the order-to-chaos feel of the environment.

UVs and BreakAngles

The default UV logic you are seeing is the most architectural in the sense that typically floor materials like tiles or wood planks don’t really get narrower as the go toward the center of a circle. Instead, wooden planks would mitered. Such joints or architectural seams are often articulated with structural pieces like wooden framing pieces:

Parameter Relations

An important aspect of Archimatix is the ability to build relations between parameters. There are two ways to designate relations between parameters: 1 inter-nodal connections, and 2. parameter expressions.

When one parameter is related to another, they can work together, i.e., when one parameter in the relation is modified, another  parameter will be modified as well based on a relation expression that determines the nature of the relationship.

For example, as a designer, you may want to designate the height of a building column to always be equal to the height of the ceiling beam. Once this relation is set up, then you can move beam up and down, and the column height will adjust itself to be identical to have height identical to the vertical displacement of the beam.

In the above GIF, we first translate the beam up and down, observing the height of the column to match it. Then with the beam still selected we modify its length, which is not related to any other parameters at the moment. Finally, we click on the column and adjust its height, observing that the beam is also being translated in the Y-direction to match.


Inter-nodal Parameter Relations

This is an inter-nodal parameter relation that connects the TransY parameter of the beam to with the height parameter of the column Extrude, as show in the figure below.

By simply connecting these two parameters we have related them as equivalent. But what if we want them to be proportional in some way rather than equivalent? For that, we would need to edit the default expressions for this relation.


Relation Expressions

The nature of the relation can be described with a mathematical expression. In the simple equivalent relation above, the default expression is not too intimidating mathematically. We can take a look at it by clicking on the red connection cable between the the two parameters.

While the connection is selected, an expression editing box appears at the bottom of the node graph window. As we can see, the parameters are simply equal. We can modify these to something a little more complex.


Bi-direction Relations

Archimatix allows bi-directional flow in parameter relations. What facilitates this is that each inter-nodal relation provides for two expressions. The top expression, in the figure above, defines what happens to the Beam.Trans_Y when the Column.Height is modified. The bottom expression defines what happens to Column.Height when Beam.Trans_Y is modified.

While these expressions look identical, technically they are reciprocal. The key to bidirectionally is taking the time to author these dual expressions that are often, but not necessarily, reciprocal. The benefit to bi-directionality is that you don’t have to know which object is driving the other. You can simply click on any object of handle in the scene and start modifying, and the logic of the model will take care of everything. Most parametric systems do not feature this, leaving the user of the model to have to find out which object is the driver and which object is the slave.

If you do not want bidirectionally, you can always leave one of the expressions blank.

If we wanted a proportional relation here, we might edit these expressions to define that the beam should always be welded to  4/5 the height of the column.

The expressions were edited to reflect this proportion mathematically and be reciprocal. Now dragging on either the column’s height handle or the beams translate Y will have the same effect.

But what if we want the portion ratio of 7/8 to be a parameter? Currently, an inter-nodal expression only supports using the parameters on either side of the connector. In order to include multiple parameters in an equation, you can use parameter expressions.

Parameter Expressions

One or more parameter expressions can be attached to any parameter. These expressions are executed whenever that parameter is changed.

Grouper: Mesh Combination versus Encapsulation

As you add nodes to your model, your node graphs gets larger. The Grouper node helps you organize your graph and increase modularity for reusability of components.

There are two ways to use Grouper to organize you nodes: 1. Combination and 2. Encapsulation..

Simple Mesh Combination

Perhaps the simplest way to group nodes is to feed there out put into a Grouper’s mesh inputs. For simple graphs, this is a fast and easy way to work with multiple objects as one pieces.

For example, if we make a box with two Extrudes that share the same Rectangle Shape from the Library, we can easily manipulate both the base of the box and the sides by modifying the height and width of the Rectangle.

But what if we now want to repeat this box in a line? We have two separate meshes that make up the box. Before repeating lets combine these meshes with the Grouper Inputs.

Make sure that none of the nodes are currently selected (click anywhere on the node graph background) and then select a Grouper node from the righthand sidebar in the Node Graph Editor and connect the output of the two extrudes to the Grouper.

Now the Grouper Output Mesh can be fed into any other node as a single unit.

For example, click on the Grouper Output and then click on LinearRepeater in the righthand sidebar.

Now the combined meshes are repeated as a unity. If you stamp out the model, the bottom and sides are still separate GameObjects. If you would like to truly combine the meshes (perhaps to reduce draw calls or have them function as a unity as rigidbodies, you can click the Combine Meshes option under the Grouper Output.

The benefits of this form of Grouping is that it is fast and you can see all the nodes at once. However, as your graph gets more complex, seeing all the nodes at once can be too messy. Also, this method does not allow for true encapsulation of logical parts that can improve reusability of subsystems in other models. The next use of Grouper is improves these factors.


Mesh Encapsulation

You can also encapsulate nodes inside the Grouper by dragging them over the Grouper’s thumbnail. Nodes inside the Grouper form a subgraph that can be reused in multiple models.

In this example, we have a section of wall with a window. The main control is the Rectangle of the window opening.


The graph that powers this is looking a little complicated. In this case it would be getting cumbersome to connect all these mesh output to the inputs of the Grouper.

If we drag all the nodes over its thumbnail, then  we have created a subgraph that encapsulates all the nodes. Now we have a single node that hides all of its complexity.

By double-clicking the Grouper thumbnail, we can go inside the Grouper and continue to operate on its parameters, and relations.

To step back out of the Grouper, we can double click its thumbnail again or click else where in the “breadcrumb trail” at the top of the node graph window.

As with the Mesh Combination method, we now have a single mesh output that we can feed into other nodes, such as a RadialRepeater.


To adjust parameters of nodes inside the Grouper, we can open it, but that would break the concept of encapsulation we are trying to achieve. What would be better is to create proxy parameters in the Controls of the Grouper to define its parametric behavior. This essentially creates an interface to the subgraph so that we need not ever go down into the subgraph and be distracted by its details.

In this case, the interface might be the width and height of the wall and the width and height of the window opening.

For the opening, lets create window width and height parameters.


For the wall lets use the default SizeX and SizeY of the Grouper.

Lets open the Grouper (perhaps one last time!) to connect theses parameters:


Now that we have encapsulated the wall section model and provided an interface, we have hidden the complexity of the subgraph to allow us to think at a higher level as we continue to use this parametric wall section in other larger assemblies.

If you do find yourself going back into the Grouper to adjust parameters, then it may be a good idea to make proxy parameters in the Grouper for them. In other words, once you finish rigging up a subnode graph in a Grouper, you should never need to open it again.

Also, keep in mind that you can have Groupers inside Groupers, to further organize and encapsulate.


Also note, that a Material given to a Grouper will be inherited by its Groupers in the subnode graph unless overridden inside.


Archimatix Roadmap

V 1.0.7



Adjustable max-min settings for Parameters


v 1.1.0

Shape Align

FreeCurve points to Parameters Binding

Node graph optimizations (hide relations cables, try bgtexture, etc.)

Lofter (ship hull’s, etc.)


V 1.2.0

3D Splines

3D Spline Sweep Mesh

3D Spline Repeater

Catmull control points

Road networks with intersections


V 1.3.0


Reduce Nodes to Thumbnails when zoomed out.


V 1.4.0

WinWall – 2.5D Booleans for cutting wall openings.


Expressing an AncientRoof

When a form is highly geometric, varying according to well-defined relationships, it often pays to take the time to codify that geometry and those relationships in a reusable parametric object. The effort taken in doing so may, at times,  seem to be taking the long road to a solution, but it often pays off as you begin to use the “tool” you have created many times in multiple situations as you develop various environments.

The parametric form we will look at in this tutorial is a gabled roof, the mainstay of many types of vernacular and monumental architecture from Viking halls to Roman Temples.

The geometry of a gabled roof is simple, being based on an isosceles triangle, and will serve as an excellent example of  how to describe interactive geometries of architectural forms for Archimatix.

Controlling Geometry

The key benefit of parametric modeling is to allow the end user of the model to vary the form of an object using relatively few controls. For example, a roof may have lots of detail and decorative features, but the main interactive handles are simply for width and height. For our gabled roof, we will consider the main controls to be the bounding box of the roof: SizeX, SizeY and SizeZ.

In the GIF to the right, we see that Archimatix has added bounding box handles for us to manipulate in the Scene View. While we are thinking about the Sizes, the model is automatically taking care of the changing length of the wooden raking rafters based on the geometrical smarts we added to the model.

The work we do to make a parametric object, such as a roof, pays off in spades as we feed the output of the object into other nodes, such as Deformers, as depicted in this GIF. As you layer modifications on top of your parametric object, a kind of magic sets in, where the user of your model experiences the joy of non-destructive editing.

A best practice in parametric design is to start with a diagram where you can draw a typical layout and add variables as dimension lines. For example, the gabled roof can be be represented as an isosceles triangle.

In this image, we see the dimensions SizeX and SizeY that will control our basic geometry. SizeZ is the depth of the roof (going into the page). In architectural parlance, this is called an elevation drawing.

We could simply instantiate an Isosceles Triangle from the 2D parametric library and use the ready-made handles, but since we are going to develop this model to be something more than an extruded triangle, it will pay to start with a Grouper node which will become the interface to our parametric gabled roof, relating the SizeX and SizeY of the Grouper to the Isosceles Triangle’s width and height.

Step 1: Create a Grouper

From the right sidebar menu, click on the Grouper Icon. In the new node palette that appears, click on the name of the Grouper and change its Name to GabledRoof.

Double click the thumbnail at the bottom of the Grouper node to open it.



Step 2: Instantiate an Isosceles Triangle and Extrude it

When you click on the Isosceles Triangle in the left sidebar of the NodeGraph Editor, it will appear inside the Grouper. Click on its Output (2.1) and click on the Extrude node in the right sidebar. For Axis orientation in the Extrude node (2.2), choose negative-Z (NZ). Finally, open the Transforms foldout (2.3) and choose Centered for AlignZ.

With the Extrude node selected, you should now be able to use the triangle’s point handles (2.4) and the extrude’s Z-axis handle (2.5) to control the form of the Gabled Roof’s form.

Well that was pretty easy, right? I’m glad you think so, since we are about to up the ante a bit…


Defining Richer Geometrical Relationships

While the building handles for the Triangle shape and the Extrude are already letting you choose just about any form you like, we might need more geometrical controllers and values. For example, what if we would like to control the pitch of the roof or use the diagonal length of the roof to make a rafter the right length?

A best practice in Archimatix is to let the Grouper provide a comprehensive interface for the parametric object. To start, lets relate the Grouper’s default bounding parameters to the Triangle and the Extrude nodes.

Step 3: Relate the Grouper’s default parameters to the Triangle and Extrude

In the Node Graph Editor, make sure the Grouper is still open. Connect the Grouper’s SizeX to the Triangle Shape’s width parameter and the SizeY to the Shape Height. Connect the Grouper’s SizeZ to the Extrude’s Height parameter. Note that you can open the Controls foldouts after you have selected the Output of the Grouper’s Size parameters.

What has this relationship building done for us? For one, we can now close the Grouper (double-clicking on its thumbnail again) and control the form either the Grouper’s Controls sliders in the NodeGraph or its bounding handles in the Scene View.

Using the Grouper’s bounding handles to control the parametric object let’s us edit more as an object without worrying about the internal nodes of how it was constructed. As forms become more complex, the ability to abstract them using Grouper interface is key.

We can make this model richer still by adding more control parameters to the Grouper’s interface.

Step 4: Create New Grouper Parameters

In the Grouper, make sure the Controls foldout is open and click the “+” button to create a new Parameter. Name the Parameter pitchAngle. Add another parameter called rakingLength.

The pitchAngle my in some cases be a more desirable parameter to vary than SizeY. For example, you may want the pitch to be 45% and the the value of the height is not as important.

The rakingLength, which is the hypotenuse of the half triangle, is an important parameter to use in conjunction with the pitchAngle, if you want to add elements to the angled part of the roof, such as the raking rafters. To create a raking rafter, you can extrude a rectangle and relate the Height of the Extrude to the rakingLength and the relate its X-axis rotation, RotX to the pitchAngle. If you add another parameter to the Grouper called eave, you can extend the raking rafter so that it can

Step 5: Inter-relating Parameters with Expressions

So far, you have added three custom parameters to the Grouper. At this point, your list of control parameters should look like the figure to the right.

These parameters are all inter-related geometrically, i.e., they are inter-dependent. For example, if the SizeY changes, either the pitchAngle must change OR the SizeZ must change. It is up to you, as the parametric designer, to decide the behavior of the model. You can decide what happens when the user of the model varies a particular parameter and encode this with the use of mathematical expressions.

Now, if you haven’t used your high school trigonometry in years, here’s your chance to dust it off and make real use of it! The pitchAngle is related to the SizeX and SizeY of the triangle with the expression:

pitchAngle = Atan2(SizeY, (SizeX/2))

Where Atan2 is the inverse tangent of Y over X. All of the Math functions have been mapped to Archimatix expression parsing so that you can simply call out the function name with out the Mathf. Now that we know the expression> where can we use it?

In terms of the model’s behavior, we may decide that when we alter the SizeY, the pitchAngle should recalculate itself so that it is always up to date. As it turns out, we can add this expression to the SizeY parameter.
Open the foldout for the SizeY parameter and add the expression for pitch angle in the available Expressions field.

If you close the foldout and adjust the SizeY, you should see the pitchAngle changing to reflect the new geometry.

When the SizeY changes, the rakingLength is also affected. We should add another expression to reflect this geometrical constraint. The expression is:


If you click the “+” button beneath the first expression, a new expression field will be added. Once you enter this expression and close the foldout, adjusting the SIzeY should now recalculate both the pitchAngle and the rakingLength. Since this Expression is comes after the first, the pitchAngle has already been calculated but the time the rakingLength is being processed.

These expressions will be executed only when the SizeY is changed. In other words, parameter expressions define what will happen when that parameter is changed. This means that the parameter, whose expression this is should be on the right side of the equation. In each expression, only one other parameter should be on the left side. The right side may include as many other parameters as you like within the same Grouper node. If there is some parameter on another node, whose value you would like to include in an expression, you can create a new parameter in the Grouper and relate it to the other node’s parameter.

What if we change the pitchAngle? Either the SizeZ needs to change OR the SizeY. As the parametric designers, we can choose either behavior. Let’s say that the SizeZ remains the same and the SizeY changes. To do define this behavior, let’s add an expression to the pitchAngle parameter. The expression should be:


Once again, the rakingLength will also change, but we don’t need to specifically add the expression for this, since we are changing the SizeY and when the SizeY changes, it will execute its expression for the rakingLength.

Finally, we need to determine what happens when the SizeZ of the Gabled Roof is modified. Let’s leave the pitchAngle fixed and alter the SizeY. As it turns out, it is the same equation we added to the pitchAngle.


As we can see, the decisions we make for how each parameter affects others is a design decision when the geometry we are describing has inter-dependent variables. It is up to us to create the behavior of the model based on our decisions of what should change when we are adhering to the constraints of the geometry.


Now that we have all these great parameters, let’s do something with them!


[To be continue…]






Models Output from Archimatix

If you would like to bring the fruits of your Archimatix (AX) labor to external applications such as Substance Painter or Quixel, you can export your models as OBJ or FBX. It is easy to export models from archimatix as OBJ or FBX using any of the free or paid assets in the Asset Store, once you Stamp your model out.



When you Stamp your Archimatix model, you are creating a clone of the standard Unity GameObject hierarchy that AX and stripping it of any AX metadata. This leaves a GameObject hierarchy that is essentially “frozen,” i.i, no longer parametric.

To Stamp a model, be sure that it is selected in the Hierarchy window and then click at bottom of the Stamp button in the Scene View or the the upper right of the Archimatix  Node Graph Editor window.

At this point, the Stamped model no  longer needs Archimatix to be in the scene. It is also ready tobe further modified  by other assets in the Asset Store, such as ProBuilder for polygonal modeling or Surforge for PBR texture painting.


The only way to create a Unity Prefab from an Archimatix model is to make sure the model  is selected in the Hierarchy window and then click the Prefab button at the upper right of the  Node Graph Editor window. This is similar to Stamping in that it “freezes” the model, but it also saves all of the meshes in the GameObjects to the AssetDatabase in an optimized way.

Note that you can not simply drag a Stamped model to the Project window to create a Prefab, since the meshes will not be in the AssetDatabase.


Archimatix does not have a buit-in exporter yet, but once an Archimatix model as been Stamped or Prefabbed, you will find several free or paid assets for exporting models from Unity as OBJ or FBX.  For example, Scene OBJ Exporter.

Archimatix Runtime For Artists

If you’re artist who is not that into coding (just yet!), but you still want to create Archimatix Pro (AX) runtime behaviors, well, you can in version 1.0.6 and later!

While Archimatix parameters can be exposed to the interface of your model, allowing easy access to them via custom game scripts, you may also use  Unity’s built-in UI system or assets like PlayMaker to control the values of AX parameters with the help of an easy to create runtime controller.

Let’s jump right into a short example to show rather than tell! While you can control any manner of complex and sublime models you have created in AX using runtime parameters, in this example, we will keep it simple and just adjust the height of a Box at runtime using a UI Slider. For this example, we won’t eve use the Node Graph Editor.


Step 1. From the Unity menus, create an Archimatix Box.


Step 2. Select the Box in the Scene.

Step 3. In the Inspector choose to expose the Height parameter as a runtime parameter by clicking the checkbox to the left of the parameter name.

Step 4. Note that the Height parameter has appeared in the list of the model’s runtime parameters.

The exposed runtime variables are easy to use in any game script, but they can also be easily made  available for binding to Unity’s UI system, PlayMaker, or any other system that connects to dynamic variables. All we have to do is create an AXRuntimeController asset. Fortunately, this is done with the click of a button!


Step 5. Make sure the AXModel GameObject is selected.

Step 6. Click on the “Create Runtime Controller” button.

Step 7. Save the new controller file anywhere  in your Asset folder.


You’ve done it!

You now have an Asset that connects to Archimatix’s runtime parameters and serves as a source for for Unity’s UI system, PlayMaker, etc. When choosing a connection, use the runtimeController asset you just created as your source of variables.

You may not have realized it, but by clicking that button, you 1. created a GameObject in the AXModel hierarchy and 2. added a new component to it, the runtimeController asset you created.

If you select other parameters in your AX model to become exposed as runtime parameters, just click the “Create Runtime Controller” button again. This time it will not ask you to locate the file, but just overwrite the one you have already created.


Now let’s take a look at how we can connect your new controller to Unity’s UI.

Step 8. Create a UI Slider. Adjust its Max Value to 10.


Step 9. Add an Action to the Slider.



Step 10. Unfold the Box model, click on the Slider in the Hierarchy and drag the runtimeController to the ObjectField in the Slider Inspector.


Step 11.  For the Function pulldown in the Slider Inspector, choose your controller and the Box_Height variable.


By Jove! You’ve done it again!

You have just empowered your game interface to do runtime modeling! Check it out!


Step 12. Check your UI to make sure the Slider is visible in the Game View. Click Play and manipulate the Slider. The Box height should be adjusting as you move the Slider.




Older posts

© 2018

Theme by Anders NorenUp ↑