Easy Wall Tile Material Maker

by Blender Insight in Surfacing

Easy Wall Tile Material Maker.


Easy Wall Tile Material Maker is a 100% procedural set of node groups made to make your life easier when it comes to create realistic looking tiles. If you have tried building tiles procedurally before using the "Brick" node, you know that what you get is straight lines, all tiles in the same height and none of them has the slightest uneven offset... in short...it's too perfect to be realistic!

With "JT Brick", which is the main node group in this product you get all those imperfections you'll need to make the tiling look more human. It includes stuff like:

* Rounded corners and soft edges.

* Some random rotation.

* Uneven offset on the tiles.

* The tiles also differ in height a bit and are leaning in different directions.

As an output pin, you also get an unique ID per tile, which then can be used to sort out specific tiles to perhaps color them differently, take away a few tiles or mix colors and patterns in a specific way.

This would be enough for most easy tasks like making bath room tiles... but I have included a little more in to this product.

* You get 7 classical tile patterns to use. All 100% procedural and open to you so that you can peek, change or add things to it.

* You also get a damage and scratches node group that you easily can attach your tiles to make them age in a good way.

* Finally there is also a five material examples that will make you understand how you can combine and play with these node groups in a good way.


This is the main node group and it looks like this:

It expects to be used on a plane with a simple UV. All node groups are based on the UV, so you will not have an input vector.

This is the inputs:

Name Description Comment
Tiles X Amount of Tiles in X direction If you don't use an integer, this will be rounded to the lowest integer.
Tiles Y Amount of Tiles in Y direction Same as above. Different numbers on X and Y will of course create non squared tiles.
Corner Roundness How round corners do you want? Small values to be used. Also it will change a bit depending on "Edge Roundness" and "Mortar Width"
Edge Roundness Here you have the possibility to soften the edges a bit.
MortarWidth The distance between the tiles.
Irregular X The offset (max Random) to use for X on tiles.
Irregular Y The offset (max Random) to use for Y on tiles.
Irregular height. Height and direction/leaning of the tiles.
Irregular rotation A random rotation value on each tile. All Irregular values are limited to what I believe is realistic. You can manually add bigger numbers, but then you can get overlapping and unpredictable results.
Seed Random seed.  To get different variations of above numbers.
Color Mortar The color between the tiles.
Color Bricks The color of the tiles/Bricks

Then there is a a set of outputs that is good to know as well.

Name Description Comment
Vector The vector output for the result to be used as input in the next step.  All things like amount of tiles, rotation and offset is included in that vector, so if you plug in an image (whatever photo texture you want), procedural texture or tile pattern... the input on that node should use the output from this vector.
ID_Tile The Unique ID for each tile Each tile generated will get it's own ID, starting from 0 in the lower left corner. That means that the first tile is 0, next is 1 and so on. If you have a total of 25 tiles... then there will be ID from 0 to 24. If you want to use this in a colorramp that only goes from 0 to 1 then you have to divide with amount of tiles or use the node "Map Range" to convert it to a range of 0 to 1.
Fac B & W value output that is meant to be used as input for things like a Mix RGB node. The Fac value is in the range of 0 to 1 and perfect to use as input in Fac for a Mix RGB/Color node if you want to do more with the colors. Then 0 will be the mortar and 1 will be tile/brick.
Height B & W values that include values between 0 and 1 to describe the leaning and height on the tiles as well. This is typically used as an input on the height for the "Bump" node.
Color The mixed Mortar and tile color.

...a simple example.

To get a good result you should include things like roughness and in some cases even metallic or/and clearcoat since that makes the tiles look better in some occasions. 


Here you have a good use of the "Fac" output of the node. The Mortar is 0 (black) and the Tile is 1 (white). That means that you can use that together with roughness to get less roughness on the tile. Since a low roughness is a low number, you would first like to invert the node and then add some value to multiply or decrease the contrast between white and black.

It can be done in several ways, but here is the easiest:

You just add a Subtract, check "Clamp" and use a value above 1.0!

What will happen is that roughness will be 1 on the mortar and the tiles will have the value that is above 1.0... so if you add 1.2... the tiles will have 0.2 in roughness. The reason you never go over 1 for the mortar is that use clamp.

Of course you can make it more complex and add in things like noise texture or have a separate Subtract and another Add in case that you perhaps not want the mortar to be exactly 1. However, I will not go through that here since it's outside of the scope for this product.

The complete setup is this easy...

So, with the knowledge above, you can quickly put something together in this way:

JT_tiletype1 to JT_TileType13

With the "JT_Brick" alone, you can come rather far, but if you are in need of a pattern as well, then the Tiletype nodes can help. I have created 7 different patterns. You will probably recognize a few of them and with those as a base it's easy to either mix them together or build your own additions to get the library growing. 

Remember that these patterns are procedural, so you also have an opportunity to have a quick study in how to achieve different patterns with only pure math.

All "TileType" nodes have the same setup, so exactly the same input and output on all patterns and you will find them in the "Group" category when you add a node in the node tree.

This is the inputs:

Name Description Comment
Vector UV input that normally uses the output Vector from "JT_Brick"
Fac The Fac input that connects with the Fac output from "JT_Brick" Without this input, you loose the mortar border, so if you see patterns all over the mortar, then this is probably forgotten.
Color The Color Input that connect to the Color Output from the "JT_Brick"

Then you have the two output pins:

Name Description Comment
Fac It's a grey scale version of the pattern. Mostly used if you want to mix and play with colors later on in the node flow.
Color It's the color version of the pattern.

The 7 base tile patterns you have are:

Name Image





(with flexible amount of petals)



Base setup with pattern looks like this:

Combining the tile patterns

With the 7 patterns above, it is very easy to create new by combining a few to get new ones. The setup then look like this:

From the above setup we can easily get these patterns (and more):

If you add more base patterns and start to play with the colors and the Fac input on the MixRGB (the above patterns was just same color and Fac = 1), you can get really advanced patterns without using many nodes at all. One suggestion would be to use one pattern as a Fac to the two other patterns like this:


Age and scratches

There is one node left and that is "JT_TileAge" and it is there, so you can add wear and aging on the tiles. It looks like this:

I think a picture will explain how to use this easier than a lot of words, so this is the total setup:

As you can see of the above setup there are three output nodes. "Fac" is used to control the mix between damage and not damage, "Fac Scratches" is the same thing (but just for scratches) and then we have the Height (Subtract). The reason is says (subtract) like this is because that is what you do with the output. You subtract the height result before the bump node like the shown in the image above and you will get adjusted height with damage as well.

When it comes to the input pins, they are easy to understand. The first three you connect to "JT_Brick" as shown in image and the rest is just to control detail and amount of damage and scratches and are really easy to just play around with to get desired result!

This is almost all there is to know about this product... but I have one extra chapter...to...the....

ID_Tile Pin

The output from the "JT_Brick" that is called ID_Tile is easy to explain, but can be hard to understand. As mentioned before, it's an unique value on each tile, so the first tile (left lower corner) is 0, the next 1 and then 2 and so on.

In practice what it means is that you can control a lot of stuff on each tile, but you also need some knowledge to utilize this power. So, here is a few examples to get you going:

Example 1.. using "Modulo"

Example 2 - using "white noise"

Example 3 - Using "Ping Pong" node to get repetitive patterns.

Example 4 - Using "White Noise" texture node together with "Less Than" to make tiles fall off

Sales 10+
Dev Fund Contributor
Published over 1 year ago
Blender Version 2.8, 2.81, 2.82, 2.83, 2.9, 2.91, 2.92, 2.93, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5
Render Engine Used Cycles, Eevee
License Creative Commons
Have questions before purchasing?

Contact the Creator with your questions right now.

Login to Message