RoaringTide, Author at

Author: RoaringTide (page 1 of 17)

Porting Archimatix to Unreal Engine!

September 18, 2025 / RoaringTide / 0 Comments

After many requests to port Archimatix to Unreal Engine, we are finally going ahead with the project!

Unreal Engine already offers a powerful suite of tools for procedural modeling and content generation. By bringing Archimatix (AX) to Unreal, we aim to extend that toolkit with the architectural domain expertise and design workflows that AX has been refining for years. This port will leverage Unreal’s robust C++ and Blueprint libraries—along with its mature node-based editing environment—making development more streamlined than ever. In contrast to Unity, where we had to engineer our own graph editor due to the lack of a stable API, Unreal provides the foundation we need to deliver a richer, more integrated parametric modeling experience.

Community Impact

With AX in Unreal, creators across disciplines will be able to design complex, parametric structures directly inside their real-time projects. Game developers can rapidly prototype entire levels or generate unique architecture with a few tweaks to a node graph. Architects and visualization specialists can explore design variations interactively, presenting clients with living, explorable spaces rather than static renders. Educators and students gain an accessible gateway into parametric thinking, bridging the worlds of architecture, mathematics, and interactive media. By opening these workflows to the Unreal community, AX will help democratize procedural modeling and empower creators to build imaginative, dynamic worlds more efficiently than ever.

Goals

Port Core Functionality

Translate the unique nodes of Archimatix’s parametric graph system into Unreal’s C++/Blueprint environment.
Ensure real-time parametric editing and procedural mesh generation are fully optimized for Unreal’s rendering and physics systems.

Integrate with Unreal Workflows

Expose Archimatix graph nodes to Blueprints, enabling seamless integration into game logic and procedural level generation.
Support Nanite meshes and Lumen lighting for next-gen performance and fidelity.
Make assets fully compatible with Unreal’s Asset Browser and Sequencer for virtual production workflows.

Community & Marketplace Release

Provide sample projects showcasing use cases: level design, world-building, and real-time architectural visualization.

For our long-time Unity users, rest assured: this porting effort will not replace or diminish support for the Unity version of Archimatix. On the contrary, the work we’re doing to bring AX into Unreal will strengthen the entire project. Advancements in the core parametric engine, workflow refinements, and new node features developed during the port will flow back into the Unity edition. By expanding AX’s reach, we’re ensuring its continued growth, sustainability, and support across both engines—so whether you build in Unity or Unreal, you’ll benefit from the innovations ahead.

Getting Started with Archimatix2

May 28, 2025 / RoaringTide / 0 Comments

Archimatix2 (AX2) is a node-based parametric modeler for Unity, rewritten from the ground up to emphasize C# scripting and runtime performance. Unlike Archimatix Pro (AX1), which focused on visual editing, AX2 is built as a developer-centric tool—lean, flexible, and optimized for integration into your game’s logic.

As a scripting API, AX2 may feel less intuitive at first, especially if you’re coming from the visual graph editor of AX1. It has a steeper learning curve, but it rewards that investment with greater control, automation potential, and runtime capabilities.

In this brief introduction, you’ll get oriented to the AX2 environment, learn how to script with its parametric nodes, and begin creating procedural models through code.

Whether you’re generating geometry at design time or dynamically at runtime, AX2 gives you the building blocks to think like an architect—and build like a coder.

And so it Begins!

Let’s add your first AX2 parametric model to a new scene. In the top menu in Unity, choose “AX2/Add Model and Node.”

Choose “Stair” from the list that pops up…

You should now see your first AX2 model! There aren’t any editor handles yet, but you can adjust the Stair parameters using the Inspector.

Creating this Stair node is matter of writing a c# class that extends a base class called MultiBlockGenerator. To get a first look at what such a class looks like, open Stair.cs in an editor.

To the uninitiated, this class may look daunting, but everything outside the Generate() function is generated automatically by the NodeClassEditor, which we will discuss later. As the Node developer, your main task is to implement the Generate function.

/// <summary>
        /// The main function of a Generator.
        /// </summary>
		/// The Generate function: Creates one or more RenderBlockInstances.
        public override void Generate()
        {
            base.Generate();

            int stepCount = Mathf.CeilToInt(size.y / riser);

            float   actualRiser = size.y / (float)stepCount;
            int     subber      = topTread ? 0 : 1;
            float   treadX      = size.x /(float) (stepCount- subber);

            tread.size.x         = treadX;
            tread.size.y         = treadThickness;
            tread.size.z         = size.z + treadOverhang;
            tread.bevel         = bevel;
            tread.bevelSegs     = bevelSegs;

            tread.needsRigidbodies = needsRigidbodies;
           
            tread.Generate();

            Matrix4x4 worldM = WorldMatrix() * localMatrix; 

            int steps = topTread ? stepCount+1 : stepCount;
            for (int i=1; i< steps; i++)
            {
                Matrix4x4 m = Matrix4x4.Translate(new Vector3(treadX * i - treadX * .5f, actualRiser * i - treadThickness, 0));
                RBI rbi = tread.InstantiateProduct(m);
                renderBlockInstances.Add(rbi);
            }

            ApplyContextMatrix(contextMatrix * localMatrix);

        }

The first thing the code is doing is to set the size values for the Tread, which is really another Node called BeveledBox. By the time the Generate function is called, the local variables have the Parameter values already, so you can use tread.size.x and stepCount, etc. These Parameters were defined using the NodeClassEditor.

Once the Tread has been sized and it has been generated, then it can be instanced in a loop, with each instance being translated to its location in the Stair using Matrix operations.

In general, creating a new Node is a matter of defining the Node’s parameters using the NodeClassEditor and then crafting the implementation of the Generate function in c# – the AX2 system will take care the rest.

As an exercise, duplicate the Stair.cs file and call it SpiralStair (also, rename the class inside the new file). Already you should have a new node in the Node list when you choose AX2/Add ModelAndNode. Now edit the Generate function to rotate each step by some degrees. Don’t add any Parameters to your model just yet and instead hardcode a value for the Y-rotation. The rotation can be defined by adding a call to the Matrix4x4.Rotate command.

Good luck!

Making a Mesh from an Image

May 7, 2021 / RoaringTide / 0 Comments

In this tutorial, we highlight the ImageShaper node and its uncanny ability to trace the alpha channel of an image to create a 2D Shape (a. k. a. Vectorization).

The output of a TextureTool can be fed into an ImageShaper. The moment the connection is made, the ImageShaper generates a 2D Shape.

Feeding the output from the ImageShaper into an Extrude creates the Mesh. Click on the Material button in the Extrude’s inputs and on the MaterialTool that pops up, select a material using the same texture as the TextureTool.

Feed the output of the Extrude node into a UVProjector and voila – you have essentially extruded an image, turning it into an object.

ContourExtruder

January 16, 2021 / RoaringTide / 0 Comments

The ContourExtruder extrudes a Plan using a Section Shape. It uses the x-value of each point in the Section Shape to create a contour by offsetting the Plan and then it lifts that contour up to the y-value of the same point. Each contour bridges to the next to create the resulting mesh. The effect is similar to a topographic landscape model.

The ContourExtruder differs from PlanSweep in that the latter creates sectional ribs at each point in the Plan Shape. While the PlanSweep mesh is great at generating UVs that run around the mesh in the horizontal direction (e.g. a brick texture), if the Plan pinches in, the mesh could have errors at the corners, as is the case with the background mesh in the image below. A benefit of of the ContourExtruder is that the resulting form will never have pinching errors found when a Section is simply extruded around a Plan.

ContourExtrude vs PlanSweep — The ContourExtrude (foreground) can handle pinching Plans.

The ContourExtruded mesh will only use the parts of the Section Shape that it can given the span of the Plan at that point. Thus we see a stort of terrain instead of a surface of consistent height.

The UVs of the ContourExtruder are projected on to the surface of the mesh in a direction normal to the Plan. This is also different than PlanSweep in that textures will not be wrapped around the sides. In this sense, ContourExtruder is more natural or organic, while PlanSweep is more “architectural.”

Restrictions on the Section Shape

Currently, the Section Shape must be entirely in the negative X and slope continually to the left. While the Shape may dip up and down on the Y-axis, it can not back track horizontally.

Section for ContourExtrude — The Section for the ContourExtrude must be entirely left of the X-axis and be vertical or left sloping.

A good use of ContourExtrude is for Plans that are letters and symbols. For example, in the “A” of the Archimatix logo, the verticals are wider than the horizontal line, so they extrude higher.

In the example above, the Plan Shapes for the logos were created by the ImageShaper node.

ContourExtruder works well with Shapes generated from the ImageShaper node.

Curve3D and Curve3DExtrude

April 4, 2019 / RoaringTide / 0 Comments

To date, the complex 3D forms in Archimatix have been generated by combining two 2D Shapes, such as a Plan Shape and a Section Shape. This is how architects often think about design.

With the introduction of a new datatype, Curve3D, we will be able to create forms that don’t easily fit into architecturally defined plans and sections. Example or Curve3D forms are piping, ramps and complex railings.

I have Curve3D working and editable in a new FreeCruve3D node:

This FreeCurve3D can then be fed into a Curve3DExtrude node:

In this case we see something that looks like a railing. We can add more shapes to the extrude to get this:

There are still some things that need to be worked out before releasing these nodes:

UV control
Scaling of the section shape around turns to maintain parallel lines
Shapes with multiple subshapes, such as the product of a ShapeMerger
Ability to adjust the Up-vector for the orientation of the edge loops.
Curve3D points need to be able to link to parameters in the node.

After the Extrude is finished, the work can begin on a Repeater to add items along the curve.

There can be a great variety of Curve3D generators such as serial, loop-the-loop, gabled-roof trim, etc.

Curve3D will also pave the way for platforms that automatically connect with self-adjusting ramps and stairs.

Molding02_Shape

January 1, 2018 / RoaringTide / 0 Comments

Molding02_Shap

Molding02_Shape is a basic chamfer sitting atop a vertical line.

Parameters

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

December 21, 2017 / RoaringTide / 0 Comments

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

December 5, 2017 / RoaringTide / 0 Comments

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

October 21, 2017 / RoaringTide / 0 Comments

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

September 27, 2017 / RoaringTide / 0 Comments

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.