This tutorial will be about creating a curved brick wall using a ‘stretcher bond’ brick pattern that consists of bricks of the same size laid from the mid of each brick above and below. In this tutorial you will use mathematical functions to generate the wall and will use the dispatch function to achieve the ‘stretcher bond’ pattern.

Brick Wall 1/6

Design link copied

As said before, the task of this tutorial is to make a curve brick will with a ‘stretcher bond’ brick pattern. The variables of the definition will be:

• the wall length = 15 meters
• the wall height = 5 meters
• the brick length = 0.4 meters
• the brick height = 0.2 meters
• the horizontal distances between the bricks = 0.2 meters = 50%
• the vertical distances between the bricks = 0.4 meters

Brick Wall 2/6

Creating a cosine curve link copied

The first step we’ll do is generate the basic curve shape of the wall with a cosine function is to define the range for the cosine curve. We can do that be create inputs for a domain range using Construct Domain and Range components. In this example, the wall length will be 15 meters, and a precision of 10.  

Next, we make a list of points with the cosine function. These points will be used to construct the curve.  

The created point will be translated in an interpolated curve. This results in the basic curve that will be used to define the shape of the wall. Play around with the input values of wall length and precision and see how the curve changes. 

Brick Wall 3/6

Defining the location and rotation planes for the bricks link copied

We will use the cosine curve from the previous step and divide this with a preset distance between each division point. This distance will be related to the distance between the center of each brick. The first thing we do this step is creating a series of vertical lines. The height of these lines will be our height of the wall. The cosine curve will be divided with the ‘Divide distance’ component.

Before we divide the curve, let’s set a bound constraint for the brick size by constructing a domain. The distance between the bricks depends on the length of the brick, as to stack a wall the bricks should be able to be placed on top of each other. Therefore, the domain will be set on a minimum of the brick length, meaning no space between the bricks, and to twice the brick length, meaning that exactly one brick can be placed in between the bricks. To control the distance between the bricks a remap of the values is used together with a slider from 0 to 1. In this example, a brick length of 0.4 meter and a distance of 50% is used, meaning that the space between the bricks is half a brick length (0.2 meters). 

• Make a slider for ‘Brick Length [m]’ 
  Params

  Input

  Number Slider
• Multiply by 2
   
  Maths

  Operators

  Multiplication
• Using construct domain add the inputs from the brick length and the multiplied value. 
  Maths

  Domain

  Construct Domain
• Create a slider ‘X Distance [%]’ from 0.00 to 1.00
  Params

  Input

  Number Slider
• Control the brick spacing by remapping the values using the number slider input and the Domain as target.
  Maths

  Domains

  Remap Numbers

Now that the distance between the bricks can be set parametrically correct, the next step is to divide the curve accordingly. The cosine curve can be divided into smaller distances with divide distance by inputting the remapped value of spacing.  

In the next few steps, we will use the tangents of the curve to define the directions of the bricks. You can visualize them using the Vector Display component. If the Vector arrows are not visible, you can make them larger by right-clicking on the Vector Display icon and setting a default size in the arrow tab.

Now we will create vertical lines to define the wall height using the divided points as Start. In this example, a wall height of 5 meters is used. 

We can now divide the curve with points to get the center point for each brick along the vertical axis. To do so, we divide the individual lines again using the Divide Distance component. The vertical division parameter will define the vertical distance between the center of each brick. To create a correct parametric wall, the vertical distance will be twice the brick height. In this example, the brick height is 0.2 meters, therefore the vertical distance between the bricks is 0.4 meters. 

Now that all the placement point for the pricks are created, the next thing is to find the direction of the planes. The pricks will be placed based on the direction of the planes, and these direction needs to be adjusted so the bricks follow the direction of the curve. First, a horizontal plane for each point will be created. 

Before continuing, we first need to flip the data. By flipping the data, the structure changes. Now the data is not structured per origin point of the original curve we created but based on the height. Therefore, we can use the ‘Flip Matrix’ component. Feel free to connect some panels to find out how it works!

If you want to know more about flip matrix and the basics of data trees, you can follow the ‘Basic tree actions’ tutorial. 

The current planes don’t follow the direction of the curve. To align the directions of the planes with the direction of the curve, we connect the flipped data to the input of an Align Plane component. The direction is based on the Tangents we found in the first Divide Distance outputs.

• Add an Align Plane component to the canvas
  Vector

  Plane

  Align Plane
• Connect the Data output to the Plane input
• Connect the first Tangents output to the Direction input

Brick Wall 4/6

Populating the bricks link copied

Last step is populating the bricks according to the planes. We use a ‘Center Box’ component that will use the aligned planes as a basis to generate the bricks. But before we do this, we have to achieve the ‘stretcher bond’ brick pattern. We will use a ‘Dispatch’ to get this result.

The ‘Dispatch’ component tests a list of data according to a true or false pattern. The true values will be listed in the A output and the false values in the B output. Before we use the dispatch function, we have to flip the matrix of the Plane output of the ‘Align Plane’ component from step two. By flipping the matrix we will be able to select alternating horizontal lines, instead of alternating vertical lines. Connect the output of this flipped matrix to the List input of a dispatch function. Since the internalized pattern of the dispatch already is correct and set on 0, 1, we don’t have to add any input. You see that you can now select each alternating horizontal line separately. 

Next, we want to select horizontally alternating planes. To do so, first the output A and B from the dispatch need to be flipped. By flipping the matrix you can start selecting horizontal planes alternating with dispatch. For list A, select the list A again of the second dispatch. For list B, select the list B again of the second dispatch. This will give the alternating pattern of the ‘stretcher bond’ pattern.

Now that the planes are in the right direction and pattern we can generate the bricks with the center box component. First, create a centre box component and input the full brick planes in base. Then, define the depth of the bricks and connect the brick length and height as defined in earlier steps. You will see brick shaped boxes populated according to the planes and you finished your ‘Stretcher bond’ cosine wall.

This creates a brick wall in ‘Stretcher bond’. However, as you see, on the edge of the wall the wall is missing bricks which create a nice, finished wall. One final step in the script should be added to add the end condition bricks which will be half the brick size to make this into a complete wall. 

Brick Wall 5/6

Adding Edge Half Bricks link copied

To complete the edges of the bricks with ‘corner bricks’, we must create the planes necessary and add a brick size that will fit in the end condition. This process starts by defining the brick size by taking the ‘brick length’ and dividing it by 2 which is the correct size to fill in the end gaps created by the brick plane offsets. Before we get started, let’s select the planes that we will be using to work with our script by creating a data component for each plane from the Dispatch components outputs.

Selecting the ‘Left’ Edge Planes

We will start by generating the edge bricks on the left side first. The process starts by defining the brick size that will be placed in the edge condition and the planes where those bricks will be generated. 

Moving the ‘Left’ Edge Brick Planes

Once you have your planes, we then need to move the planes by a half-brick size distance away from the wall. 

• To create the motion vector, first use the deconstruct plane component to extract the ‘X’ direction of the plane. This gives us the X direction with respect to the plane.
  Vector

  Plane

  Deconstruct Plane
• Next, take the X-Axis output and plug it into the ‘Vector’ input of Amplitude component which takes the X vector of the plane.
  Vector

  Vector

  Amplitude
• The amount of movement will be the half-brick size but first convert it to a negative value by using the Negative component. This will ensure it is moving away from the brick wall.
  Maths

  Operators

  Negative
• Use a Move component where the input is the actual plane we want to move and the motion is the Amplitude output which already contains the amount of units it needs to move by and the vector direction of movement. 
  Transform

  Euclidean

  Move
• To check the direction vector is correct, use a Vector component where the origin of Deconstruct Plane is the ‘Anchor’ and the Amplitude is the ‘Vector’. 
  Display

  Vector

  Vector

Selecting the ‘Right’ Edge Planes

We now work on the corner bricks on the right side. The process will start by isolating the planes needed to generate the edge bricks, similar to the previous step. We take the inputs of ‘Plane A-B’ and ‘Plane B-A’, then we deconstruct the plane like and move it along a vector direction.

Next, you will select the first item from the list to deconstruct its plane and retrieve the origin point of the planes. 

Now that we have the X-coordinate of the plane origin point for both planes, we proceed to the following step. The reason we select both planes is because sometimes the edge plane is on the bottom plane and sometimes it is on the plane above. In other words, we need to make sure we select the planes that is on the most outer edge of the brick wall. If we compare the X coordinate values for both planes, we can then determine which plane exists on the most outer plane of the wall’s edge. To do this, we need to compare the values of X-coordinates of both planes and allowing the planes positioned at the most outer edge to be selected. 

• Using the Larger than component, plug the two X Component outputs for the origin points of the planes. This will tell us which when ‘Plane B-A’ is larger than Plane ‘A-B. The output will be either Ture or False.
  Maths

  Operators

  Larger Than
• Next, we use the Stream Filter component where the index of the gate stream corresponds to the True or False statement. Meaning, if the statement is True, it allows ‘Plane A-B’. Otherwise, it goes to ‘Plane B-A’.
  Sets

  Tree

  Stream Filter
• You can now see in this selection that the gate 0 (True) was outputted as the planes on the right side. 

Moving the ‘Right’ Edge Planes

Now we move the outer-most planes by the half-brick amount similar to the opposite side. We 

• Extract the X-axis of the planes’ vector direction using the component using the Deconstruct plane component. This gives us the X direction with respect to the plane. 
  Vector

  Plane

  Deconstruct Plane
• Next, take the X-Axis output and plug it into the ‘Vector’ input of Amplitude component which takes the X vector of the plane. This time instead of taking the negative value, we take the positive value of the distance which will move the plane in the opposite direction of the planes on the opposite side of the brick wall. 
  Vector

  Vector

  Amplitude
• Use a Move component where the input is the actual plane we want to move and the motion is the Amplitude output which already contains the amount of units it needs to move by and the vector direction of movement.
  Transform

  Euclidean

  Move
• To check the direction vector is correct, use a Vector component where the origin of Deconstruct Plane is the ‘Anchor’ and the Amplitude is the ‘Vector’.
  Display

  Vector

  Vector

Combining the Bricks

Now we generate the half bricks at the edge condition of the wall using the moved planes we have created. The base of the bricks will be the planes, and the half-brick length will be an input, as well as the normal brick height and depth.  

Visualize and render wall design

Finally, visualize the brick by selecting a color and a custom preview component.

• Using the Merge component, combine the outputs for the ‘brick full size’ and the two edge bricks we just created. 
  Set

  Tree

  Merge
• Create a Custom Preview component and add a color using the Color Swatch component which then you can click on the color to adjust the hue, brightness, and saturation.
  Display

  Preview

  Custom Preview
  Params

  Inputs

  Color Swatch

Brick Wall 6/6

Conclusion link copied

Now you can utilize this script to make curved brick wall. Feel free to experiment with the curve and see what results you get.

Complete exercise file