Introduction

The Modular Control Rig system in Unreal Engine makes it easy to build animation controls for a skeletal character without creating an entire control rig from scratch

In this tutorial, you'll learn how to create a Modular Control Rig and quickly configure it for your own character

Step 1: Create a Modular Control Rig

In the Content Browser, navigate to the folder where you'd like to store your control rig

1. Right-click inside the Content Browser
2. Select Animation → Control Rig
3. Choose Modular Rig
4. Click Create
5. Give the asset a descriptive name 
6. Double-click the new asset to open the Control Rig Editor

At this point, you'll see an empty Modular Control Rig waiting to be assigned to a character 

Step 2: Assign Your Character

Before you can build the rig, you need to select the skeletal mesh that the control rig will use

1. Open the Preview panel
2. Locate the Preview Mesh setting
3. Choose your skeletal mesh

For this example, I will be using the Mixamo character I rigged in a previous tutorial, but any compatible skeletal mesh can be selected

Once the mesh loads, you'll notice a small socket located around the pelvis area

This is the starting point for assembling the Modular Control Rig 

Step 3: Add the Spine Module

The sockets indicate where different rig modules should be placed

Hovering over a socket displays the type of module it expects

Open the Module Assets panel

To avoid confusion, click on Biped so you only see the controls for a humanoid

Locate the Spine module and drag it onto the Spine socket

Once the module is added, Unreal Engine generates new sockets for the hips, shoulders, and neck, allowing you to continue constructing the character rig 

Step 4: Add the Leg Modules

Each thigh socket requires its own Leg module

Simply drag the Leg module onto each thigh

Both legs are now equipped with their own animation controls 

Step 5: Add the Neck Module

Locate the Neck socket at the top of the spine

Drag the Neck module onto the socket

This creates controls for the neck and head 

Step 6: Add the Shoulder Modules

Next, locate the shoulder sockets

Drag a Shoulder module onto each shoulder

The shoulder modules prepare the skeleton for the arm controls 

Step 7: Add the Arm Modules

Each shoulder now exposes an Arm socket

Drag an Arm module onto each arm separately

The arm controls are automatically connected to the rest of the modular rig 

Step 8: Add Finger Modules

After adding the arms, sockets appear for each finger

Instead of assigning them individually, you can add multiple finger modules at once

1. Hold Shift
2. Select every finger socket on one hand
3. Drag the Finger module onto the selected sockets

Unreal Engine automatically creates a Finger module for every selected finger

Repeat the process for the opposite hand

This is much faster than assigning each finger individually 

Step 9: Review the Completed Rig

Once every required module has been assigned, your Modular Control Rig is complete

The character should now include controls for:

• Spine
• Neck
• Head
• Shoulders
• Arms
• Legs
• Fingers

Because each section is modular, the rig is assembled automatically without requiring manual setup of constraints or control hierarchies 

Step 10: Test the Control Rig

To begin posing the character, hide the placement sockets

Press the Y-key to hide the module sockets and display only the animation controls

With the sockets hidden, you can:

• Select any control
• Move, rotate, or pose the character
• Test the full range of motion
• Verify that each module behaves correctly

This provides a clean workspace for animating and adjusting poses

Conclusion

Using the Modular Control Rig workflow in Unreal Engine, you can build a fully functional character rig in just a few minutes. By assembling pre-built modules for the spine, limbs, neck, shoulders, and fingers, you avoid the complexity of creating a traditional Control Rig from scratch while still gaining a powerful set of animation controls for posing, keyframing, and gameplay animation.

Introduction

This tutorial walks you through creating a simple squash-and-stretch rig for a ball in Blender 5. You'll build a two-bone stretch system, add a master control, and create custom controller shapes to make animation easier.

Step 1: Add an Armature

1. Make sure you have the Rigify addon active
2. Press Shift + A → Armature → Single Bone
3. The bone may be hidden inside the mesh
4. Select the armature
5. Open Object Properties [running man]
6. Under Viewport Display, enable In Front so the bones remain visible through the mesh

Position the bone roughly in the center of the ball

• Press G, then Z, to move it vertically to the bottom of the ball

Step 2: Create the Stretch Bones

1. Use TAB to enter Edit Mode
2. Select the tip of the bone
3. Press G, then Z, to move the top of the bone to the top of the ball
4. Make adjustments as necessary to make sure the bone spans the ball
5. Use E, the Z, to extrude a second bone at the top of the ball

The bones should form a vertical chain running through the center of the ball

Step 3: Separate the Bones

The stretch setup works best when the two bones are not parented together

1. Select the top bone
2. Press Alt + P
3. Choose Clear Parent

The two bones are now independent

Step 4: Rename the Bones

Clear naming makes rigging much easier

Select each bone and rename it in the Bone Properties panel

• Lower bone → Root
• Upper bone → Squash

Step 5: Add the Stretch Constraint

The lower bone will stretch toward the upper bone

1. Select both bones
2. Use CTRL TAB to switch to Pose Mode
3. Select the Root bone
4. Open the Bone Constraints tab
5. Click Add Bone Constraint → Stretch To

Configure the constraint:

• Target: your armature
• Bone: Squash

Now test it

Select the Squash bone and press G and move your mouse

The lower bone should automatically stretch toward it

You can also move the Root bone to see how the setup behaves

Step 6: Parent the Ball to the Armature

Now bind the mesh to the rig

1. Return to Object Mode by using CTRL TAB
2. Select the ball
3. Hold Shift and select the armature
4. Press Ctrl + P
5. Choose Armature Deform → With Automatic Weights

Switch back to Pose Mode using CTRL TAB and move either bone

The ball should squash and stretch automatically

Step 7: Create a Master Control Bone

A master control lets you move the entire rig without affecting the squash-and-stretch behavior

Add the Control Bone

1. Use TAB to go into Edit Mode
2. Press Shift + A to add a new bone
3. Select the top of the Bone and use G, then Z, to scale the Bone down
4. Rename this bone: Control

Step 8: Parent the Stretch Bones to the Control

Still in Edit Mode:

1. Select Squash
2. Hold CTRL and select Root
3. Finally select Control so it is the active bone
4. Press Ctrl + P
5. Choose Keep Offset

Now test the rig

• Use CTRL TAB to go back into Pose Mode
• Moving the Squash bone affects stretching
• Moving Root bone affects stretching
• Moving Control bone moves the entire rig together

Step 9: Create a Custom Controller Shape

Controller shapes are easier to animate than bones

1. Use CTRL TAB to return to Object Mode
2. Press Shift + A → Mesh → Circle
3. Scale it larger with S key
4. Move it slightly below the ball

This circle will become the custom control shape

Select the bones and use CTRL TAB to enter Pose Mode

Squash Bone

1. Select Squash bone
2. Open Bone Properties
3. Under Viewport Display, find Custom Shape
4. Use the eyedropper to select the circle

Adjust the display:

• Rotation: 90° (X Axis)
• Scale: approximately 2.5
• Raise it slightly using Translation Y

Root Bone Suggested values:

• Select the Root bone
• Use the eyedropper to select the circle
• Rotation: 90° (X Axis)
• Scale: about 1.5
• Lower it slightly with Translation Y

Control Bone Suggested settings:

• Select the Control bone
• Use the eyedropper to select the circle
• Rotation: 90° (X Axis)
• Scale: around 6

Make this controller larger than the ball so it's easy to grab

 The circle object is now only used as a controller shape

Return to Object Mode using CTRL TAB and delete the mesh circle

The custom controller shapes remain assigned to the bones

Step 10: Test the Rig

In Pose Mode:

• Select the Controllers and use CTRL TAB to go into Pose Mode
• Move the Squash controller to squash and stretch the ball
• Move the Root controller to squash and stretch the ball
• Move the Control controller to reposition the entire rig
• Rotate the Control to rotate the whole ball

Everything should move together while preserving the squash-and-stretch behavior

Step 11: Color-Code the Controllers (Optional)

To make the rig easier to read:

1. Select a controller
2. Open Bone Properties → Viewport Display
3. Select a Bone Color

Suggested colors:

• Squash → Red
• Root → Yellow
• Control → Purple

Color coding becomes especially useful on larger character rigs

You can also use the Wire Width to make the Controllers easier to see

Conclusion

You now have a fully functional squash-and-stretch ball rig featuring:

• Automatic squash and stretch using a Stretch To constraint
• Automatic mesh deformation with armature weights
• Independent top and bottom stretch controls
• A master control for moving and rotating the entire rig
• Custom controller shapes for easier animation
• Optional color-coded controls for better organization

This simple rig demonstrates several fundamental rigging techniques that can be expanded into more advanced animation rigs

Introduction

Creating believable fabric materials is an important part of building realistic characters, clothing, furniture, and environmental props in Unreal Engine 5.

In this tutorial, you’ll learn how to:

• Build a basic cloth material
• Add a woven fabric normal map
• Tile the texture for extra detail
• Remove the plastic appearance
• Use the Cloth shading model
• Add realistic fabric fuzz lighting

Step 1: New Material

1. You will need a normal map for the cloth you want to make

A normal map is a texture mapping technique in 3D computer graphics that simulates the illusion of surface depth, bumps, and dents without altering the actual geometry of a 3D model.

2. In the content browser, right-click and make a new folder for your material

3. In the folder, drag-and-drop your normal map for the cloth (and mesh if you have one)

4. Right-click and choose “material” – naming it appropriately

5. Double-click on the material to open it

Step 2: Base Color

1. Hold down the 3-key and left-click to add a constant 3 vector

In Unreal Engine 5, the Constant3Vector is a material expression that outputs a three-channel vector value, consisting of three constant numbers. It is primarily used to define a solid RGB color, where each channel corresponds to Red, Green, and Blue.

2. Connect the constant 3 vector to the base color

Shading Models in Unreal Engine 5 define how a material interacts with incoming light, determining the specific lighting calculations and visual properties applied to a surface.

3. In the details panel, choose the color you want to make the cloth

4. Right-click on the constant 3 vector and convert it to a parameter – renaming it “cloth color”

In Unreal Engine 5, a parameter is a customizable variable within a material or system that allows for dynamic changes without altering the base asset.

Step 3: Roughness

1. In general, real cloth is not highly reflective

2. Hold down the 1-key to add a constant vector

In Unreal Engine 5, Constant Vector nodes are material expressions that output fixed, multi-channel values (scalars or vectors) which do not change once set in the editor.

3. Change the value to around 0.3

4. Connect the constant vector to the roughness input

5. This reduces excessive shine while still allowing some light response

6. Right-click on the constant vector and convert it to a parameter – renaming it “roughness”

Step 4: Normal Map

1. To create the illusion of woven fibers, you’ll use a normal map

2. Drag-and-drop your downloaded normal map into the material editor

3. Connect the normal map to the normal input

4. To add more density, right-click and search for “texture coordinate”

In Unreal Engine 5, the Texture Coordinate node is a material expression that outputs UV texture coordinates as a two-channel vector, allowing materials to operate on the mesh's UVs.

5. Hold down the M-key to add a multiply node and increase the value [5]

In Unreal Engine 5, the Multiply node is a mathematical function that takes two inputs and outputs their product.

6. Connect the texture coordinate to the A-input of the multiply node

7. Connect the multiply node to the UVs input of the normal map

8. This tiles the normal map multiple times across the surface, creating a finer cloth pattern

9. Right-click on the texture sample and convert it to a parameter – renaming it “cloth normal” [FROM B]

10. Apply and Save the material

Step 5: Shading Model

1. Drag the material onto your mesh to preview it

2. The cloth will look shiny and like plastic

3. This is due to the lighting being set to the default shading model

4. Back on the material graph, in the detail panel, look for the “shading model”

5. Change the shading model from “default lit” to “cloth”

The Cloth Shading Model in Unreal Engine 5 is a specialized material property designed to accurately mimic the physical properties of fabric by simulating light scattering through a thin "fuzz" layer on the surface.

6. The cloth will lose its plastic look and looks more like realistic cloth

7. Two new inputs now appear – “cloth” and “fuzz color”

8. The cloth input acts like a mask

In Unreal Engine 5, the Cloth input within the Cloth Shading Model serves as a mask that controls the strength of the Fuzz Color.

9. Hold down the 1-key and left-click to add a constant vector

10. Set the value to 1

11. Connect the constant vector to the cloth input

12. A value of zero means “not cloth” and a value of 1 means “full cloth shading”

13. Right-click on the constant vector and convert it to a parameter – renaming it “cloth control”

14. Real cloth will contain tiny fibers (fuzz) that catches and scatters light

15. Hold down the 1-key and add a constant vector

16. Change the value to around 0.1

17. Connect the constant vector to the fuzz color input

The Fuzz Color input in the Unreal Engine Cloth Shading Model is used to simulate shifts in color when light passes through or grazes the surface of a material, effectively adding a thin layer of fuzz to mimic fibrous fabrics like velvet or wool.

18. Right-click on the constant vector and convert it to a parameter – renaming it “fuzz color”

Step 6: Material Instance

1. Right-click on the material and make a material instance – naming it appropriately

A Material Instance in Unreal Engine 5 is a reusable, lightweight child asset that inherits the compiled shader logic of a parent Master Material, allowing artists to tweak specific parameters without recompiling the underlying shader code.

2. Double-click on the material instance to open it

3. All of those parameters that we made are now available for you to tweak your shader without needing to change the master material

Conclusion

Using the Cloth shading model in Unreal Engine 5 is one of the easiest ways to dramatically improve the realism of fabric materials. By combining tiled normal maps, controlled roughness, cloth masking, and subtle fuzz lighting, you can create convincing textiles that react naturally to light instead of appearing glossy or plastic-like.

Introduction

Procedural materials are one of the most powerful features in Blender. Instead of relying on image textures, procedural shaders generate surfaces mathematically using nodes, allowing infinite detail, scalability, and customization without visible repetition.

In this tutorial, you’ll learn how to build a realistic procedural snow material entirely inside Blender

Step 1: Base Material

1. Split your viewport and open the Shader Editor

2. Create a new material and name it appropriately

3. Make sure you are in render mode so you can see your material

4. Since we will be using displacement, you will need to use the Cycles render engine

5. Also make sure you have the node wrangler add on activated

Step 2: Surface Breakup

1. The Voronoi texture creates the snowy surface breakup

2. Use SHIFT + A to add a Voronoi texture

The Voronoi Texture node in Blender generates a procedural texture by randomly distributing points, called seeds, which extend outward into regions known as cells.

3. Select the Voronoi texture and use CTRL + T to add a texture coordinate and mapping node and change the texture coordinate to “object”

The Texture Coordinate node in Blender is an input node that outputs various coordinate systems (such as Generated, UV, Object, and Camera) to define the vector space for mapping textures onto a 3D model.

The Mapping Node in Blender is a vector utility node used to transform image or procedural textures by applying translation (location), rotation, and scaling to the input vector coordinates.

4. Use CTRL + SHIFT + left-click to preview the Voronoi texture

5. Increase the scale and detail of the Voronoi texture to make a breakup pattern for the snow [75, 10]

Step 3: Color Variation

1. Now create subtle snow coloration

2. Use SHIFT + A to add a mix color node after the Voronoi texture

The Mix Color node (formerly the Mix RGB node) in Blender mixes two input values—such as colors, vectors, or floats—using a Factor to control the amount of interpolation.

3. Connect the Voronoi texture distance output to the factor of the mix color node

4. Use CTRL + SHIFT + left-click to view the mix color node

5. The Voronoi brightness values now determine where each color appears

6. Change color A to a slightly gray-blue color [#87A8BCFF]

7. Change color B to a bright white [#D4D4D4FF]

8. Change the roughness down to around 0.05

9. These slight color differences help the snow feel colder and more natural

Step 4: Snow Details

1. Connect the mix color node to the principled shader and the principled shader to the material output

The Principled BSDF (Bidirectional Scattering Distribution Function) node is the default, all-in-one surface shader in Blender 3D, designed to simplify the creation of realistic materials by combining multiple shading layers into a single interface.

2. To simulate subsurface scattering, change the subsurface weight to 0.5

3. Select the Voronoi and mix color nodes

4. Use the F-key to add a frame and rename it to base

Step 5: Snow Bump

1. Currently the snow is too smooth, so we need to add some bumpiness to the material

2. Use SHIFT + A to add a bump node

The Bump node in Blender generates a perturbed normal from a height texture to simulate surface detail via bump mapping, without altering the actual geometry.

3. Connect the Voronoi distance output to the height input of the bump node

4. Connect the bump node to the normal input of the principled shader

5. This converts grayscale texture information into surface detail

6. Change the distance of the bump node to about 0.1

7. Move the bump node into the base frame

8. For smaller details, use SHIFT + A to add a noise texture

The Noise Texture node in Blender evaluates fractal Perlin noise at specified input texture coordinates, functioning as a procedural generator for organic patterns.

9. Connect the mapping node to the vector input of the noise texture

10. Use CTRL + SHIFT + left-click to view the noise texture

11. Increase the scale and detail of the noise texture [6, 10]

12. Use SHIFT + A to add a second bump node

13. Place the second bump node between the first bump node and the principled shader

14. Connect the factor of the noise texture into the height of the second bump node

15. This creates layered bump detail

16. Use CTRL + SHIFT + left-click to view the principled shader

17. Select the noise texture and second bump node

18. Use the F-key to add a frame and rename it to snow details

Step 6: Crack Details

1. Now add crystalline ice crack patterns

2. Use SHIFT + A to add a second Voronoi texture

3. Connect the mapping node to the vector of the second Voronoi texture

4. Use CTRL + SHIFT + left-click to view the second Voronoi texture

5. Increase the scale of the second Voronoi texture [1400]

6. This creates tiny crystalline breakup patterns resembling icy snow reflections

7. Use SHIFT + A to add a third bump node between the second bump node and the principled shader

8. Connect the second Voronoi color output to the height of the third bump node

9. Decrease the strength to about 0.4

10. This sharper bump creates sparkling icy details

11. Use CTRL + SHIFT + left-click to view the principled shader

12. Select the second Voronoi texture and third bump node

13. Use the F-key to add a frame and rename it to cracks details

Step 7: Displacement

1. Bump only affects shading so we will now add true geometry displacement

2. Use SHIFT + A to add a second noise texture

3. Connect the mapping node to the vector of the second noise texture

4. Use CTRL + SHIFT + left-click to view the second noise texture

5. Increase the scale and detail [10]

6. Use SHIFT + A to add a displacement node

The Displacement node in Blender is a shader node used to physically displace the surface of a mesh along its normal to add geometric detail, supporting both procedural textures and baked displacement maps.

7. Connect the factor of the second noise texture into the height of the displacement node

8. Connect the displacement node to the displacement input of the material output

9. This converts the texture into real displacement data

10. Use CTRL + SHIFT + left-click to view the principled shader

11. To enable true displacement, open the material properties settings

12. Change the displacement surface setting to “displacement and bump”

13. Now the geometry actually pushes outward

14. Change the midlevel and scale on the displacement node as needed [0.6, 0.05]

The Midlevel parameter in Blender’s Displacement node defines the neutral displacement value that results in no change to the surface geometry.

Displacement Scale determines the physical magnitude of geometry deformation along the surface normal, measured in Blender Units (typically meters).

15. Select the second noise texture and displacement node

16. Use the F-key to add a frame and rename it to displacement details

Conclusion

By combining Voronoi textures, layered noise, bump mapping, subsurface scattering, and true displacement inside Blender, you can create a highly realistic procedural snow material that is both flexible and efficient. Because the shader is fully procedural, it can scale infinitely without texture repetition and can easily be customized for different environments and artistic styles.

Introduction

Mixamo is a powerful online tool for quickly rigging and animating 3D characters. However, when you import a Mixamo-rigged character into Unreal Engine, its skeleton may not match Unreal’s default humanoid skeleton. Retargeting allows you to take existing animations (like those from the Unreal Mannequin) and apply them to your custom Mixamo character. In this tutorial, we’ll go step by step to import, rig, and retarget a Mixamo character in Unreal Engine 5.

Step 1: Upload and Rig the Character in Mixamo

1. Go to Mixamo and press Upload Character

2. Drag-and-drop your FBX file into the dialogue box

3. Click on next to begin the rigging process

4. Place the markers on the correct body parts

5. Press next to allow Mixamo to auto-rig your character

6. Download the character by keeping the default settings and using the FBX format

Step 2: Set Up a New Unreal Engine Project

1. Create a new Unreal Engine 5 project using the third person template or open a project

Step 3: Import Your Mixamo Character

1. Right-click and make a new folder to contain your character

2. Drag-and-drop your downloaded FBX from Mixamo into this folder

3. Press Use Pipeline Defaults, leave everything else at default, and press import

4. If textures aren’t applied, you can manually replace them

Step 4: Add a Root Bone to the Mixamo Skeleton

1. Mixamo skeletons often start at the hip bone, but Unreal’s mannequin expects a root bone

2. Double-click on your imported skeletal mesh to open it

3. Click Skeleton → Edit Skeleton

4. Close all bones, right-click → New Bone, name it Root

5. Drag the Hipbone under the new Root bone

6. Press Accept to Accept

7. Change the merge type to merge, then select commit

7. Save the skeletal mesh

Step 5: Retarget Animations

1. Go to Content Browser → Characters → Animations → Unarmed to find the default UE animations

2. Right-click an animation → Retarget Animations

3. Set Target Skeleton to your Mixamo character

4. To export multiple animations at once, select all the animations

5. Click on export animation

6. Right-click on your character folder and add a new animations folder

7. Add a prefix like Character_Animations_

8. Click on export

9. All selected animations are now retargeted to your Mixamo skeleton

Step 6: Replace the Character in the Third Person Blueprint

1. Under the third person folder, open Blueprints → ThirdPersonCharacter

2. In Components, under the mesh section, change Skeletal Mesh to your Mixamo character

3. Under the animation section, change the animation class to the corresponding AnimBP

4. Press Compile and Save

Step 7: Test Your Character

1. Press Play in the viewport

2. Move around; the Mixamo character should now have all default UE animations applied (walk, run, idle, etc.)

3. You can repeat this process with any Mixamo character using the same workflow

Conclusion

Retargeting Mixamo characters in Unreal Engine 5 is a straightforward process once you understand the workflow. This technique allows you to leverage Unreal Engine’s animation library for any custom character, opening up possibilities for prototyping, game development, and animation testing.

By following this method, you can quickly populate your projects with diverse characters without manually creating animations from scratch.

Introduction

In many materials, you may want to combine multiple normal maps to add complexity and detail. For example, you could have a tile pattern as your base and additional scratches or decal details on top. Blender doesn’t have a one-click solution for this, but with some node work, you can seamlessly blend multiple normal maps. In this tutorial, I’ll show you a method that separates, combines, and normalizes normal map channels for a clean, controllable result.

Step 1: Set Up Your Material

1. Open the shader editor

2. Make a new material

3. Go into material preview using the Z-key

3. Drag-and-drop your texture maps into the shader editor

Texture maps are two-dimensional image files applied to the surface of a 3D model to define its visual properties and surface details

4. Connect the base color (or albedo) to the base color input of the principled shader

An albedo map (also known as a base color map) is a 2D texture that defines the pure, intrinsic color of a surface material without any baked-in lighting, shadows, highlights, or reflections.

The Principled BSDF (Bidirectional Scattering Distribution Function) node is the default, all-in-one surface shader in Blender 3D, designed to simplify the creation of realistic materials by combining multiple shading layers into a single interface.

5. Connect the roughness to the roughness input of the principled shader and change the color space to non-color

A roughness map is a grayscale texture used in Physically Based Rendering (PBR) to define the microsurface variations of a material, determining how light scatters or reflects off its surface.

6. Set both normal maps’ color space to Non-Color Data in the image texture node settings

A normal map is a texture mapping technique in 3D computer graphics that simulates the illusion of surface depth, bumps, and dents without altering the actual geometry of a 3D model.

7. Normal maps are made up of an RGB spectrum where red represents the X-axis, green represents the Y-axis, and blue represents the Z-axis

Step 2: Separate RGB Channels

1. We need to separate these values by using SHIFT + A to add a Separate Color node

The Separate Color node in Blender splits an input image or color vector into its composite color channels, with the specific outputs determined by the Mode property.

2. Duplicate this node using SHIFT + D  

3. Connect each normal map to its own Separate RGB node

The Mix Color node (formerly the Mix RGB node) in Blender mixes two input values—such as colors, vectors, or floats—using a Factor to control the amount of interpolation.

4. This separates the red, green, and blue channels of each normal map for independent blending

Step 3: Combine the Channels with Add

1. Use SHIFT + A to add a mix color node and change the blending mode to add

2. Make two duplicates of the mix color node

3. Connect the red output of the separate color nodes to the first mix color node

4. Connect the green output of the separate color nodes to the second mix color node

5. Connect the blue output of the separate color nodes to the third mix color node

Step 4: Recombine the Channels

1. Use SHIFT + A to add a combine color node

The Combine Color Node is a converter node in Blender used to reassemble separate color channels (such as Red, Green, Blue, and Alpha) back into a single combined color value.

2. Connect the first mix color node to the red input of the combine color node

3. Connect the second mix color node to the green input of the combine color node

4. Connect the third mix color node to the blue input of the combine color node

5. This recombines your separated channels into a single RGB output

Step 5: Normalize the Result

1. Use SHIFT + A to add a Vector Math node

The Vector Math node in Blender performs selected mathematical operations on input vectors, with dynamic inputs and outputs that adapt to the chosen operator.

2. Change the operation to normalize

In Blender's Vector Math node, the Normalize operation scales the magnitude (length) of the input vector to exactly 1 while keeping its original direction intact. This process creates a unit vector, which is essential for operations where only direction matters, such as calculating surface normals or determining angles via the dot product.

3. Connect the output of the combine color node to the vector input of the vector math node

4. Normalizing ensures that the combined normal map has proper direction and intensity without one map overpowering the other

Step 6: Apply the Normal Map

1. Use SHIFT + A to add a normal map node

The Normal Map node in Blender generates a perturbed normal vector from an RGB normal map image, which is typically chained with an Image Texture node in the color input.

2. Connect the output of the normalize node to the color input of the normal map node

3. Connect the normal map node to the normal input of the principled shader

4. Adjust the strength parameter of the normal map node to control the overall intensity

Step 7: Node Group

1. Select the 8 nodes that make up the blending of the normal maps

2. Use CTRL + G to group them together

3. Use the N-key to open the side panel and rename the group

4. Using the TAB key will bring you back to your shader editor

Conclusion

By separating, adding, recombining, and normalizing normal map channels, you can combine multiple details without one overriding the other. This method works great for adding scratches, decals, or layered surface detail on top of your base textures. Once you understand this workflow, it opens up endless possibilities for richer, more complex materials in Blender.

Blending multiple normal maps in Unreal Engine is a powerful way to add layered surface detail to your materials.

In this tutorial, you’ll learn how to:

• Blend two normal maps together correctly
• Add base color and roughness textures
• Control the intensity of each normal map independently
• Normalize the result to avoid lighting artifacts
• Expose controls through a Material Instance

Step 1 — Prepare the Textures

Before starting, you will need the following textures:

1. Micro Detail Normal Map - Small surface detail such as concrete grain or fine bumps.

A normal map is a texture mapping technique in 3D computer graphics that simulates the illusion of surface depth, bumps, and dents without altering the actual geometry of a 3D model.

2. Macro Detail Normal Map - Larger forms such as panels, grooves, or broad surface shapes.

3. Base Color (Albedo)

An albedo map (also known as a base color map) is a 2D texture that defines the pure, intrinsic color of a surface material without any baked-in lighting, shadows, highlights, or reflections.

4. Roughness Map

A roughness map is a grayscale texture used in Physically Based Rendering (PBR) to define the microsurface variations of a material, determining how light scatters or reflects off its surface.

Step 2 — Create the Base Material

1. Create a new Unreal Engine project or open a project

2. Right-click in the content browser and add new folders for your textures, materials, and static meshes (if needed)

3. Drag all four of your texture maps into the texture folder

4. Open the material folder and right-click to add a material

In Unreal Engine 5, a Material is an asset that defines the surface properties of objects, determining how they appear visually through attributes like color, texture, transparency, and lighting response.

5. Right-click on the new material and create a material instance – this will be used to control the texture maps

A Material Instance in Unreal Engine 5 is a reusable, lightweight child asset that inherits the compiled shader logic of a parent Master Material, allowing artists to tweak specific parameters without recompiling the underlying shader code.

6. Double-click on the material to open it

7. Drag your four texture maps into the material editor

8. Connect the base color (or albedo) to the base color input

Shading Models in Unreal Engine 5 define how a material interacts with incoming light, determining the specific lighting calculations and visual properties applied to a surface.

9. Connect the roughness to the roughness input

10. Connect the micro normal map to the normal input

11. Apply and save the material

12. At this stage, your material only uses the micro-detail normal map

13. Apply the material instance to a mesh in your level to preview the result

14. You should now see the fine surface detail visible across the object

Step 3 — Blending Normal Maps

1. To combine two normal maps properly in Unreal Engine, right-click in the material editor and search for blend angle corrected normals

BlendAngleCorrectedNormals is a built-in Unreal Engine 5 material node used to combine or blend two normal maps while correcting for angular differences between their tangent spaces.

2. Connect the nodes like this:

• Micro Normal RGB → Base Normal
• Macro Normal RGB → Additional Normal
• Blend Angle Corrected Normals Output → Normal

3. This produces a much richer and more believable material surface

4. Apply and save the material

5. Simply adding normal maps together can create incorrect lighting and shading artifacts

6. The blend angle corrected normals node blends them mathematically correctly while preserving proper normal direction and lighting response

7. This is the recommended method in Unreal Engine for combining normal maps

Step 4 — Add Intensity Controls

1. Next, let’s make each normal map adjustable independently

2. This allows you to:

• Increase or decrease micro surface detail
• Strengthen or soften macro forms
• Fine-tune the overall appearance directly in a Material Instance

3. For the micro normal map right-click in the material editor and search for a component mask

The Component Mask node in Unreal Engine 5 is a utility expression that acts as a channel selector, allowing you to isolate specific components (Red, Green, Blue, or Alpha) from a vector input such as a texture sample or normal map.

4. Use the arrow to make sure red and green only are enabled

5. The blue channel remains untouched – this is the Z-Axis

6. Hold down the S-key to add a scalar parameter

In Unreal Engine 5, a Scalar Parameter is a single floating-point value used to create dynamic, adjustable inputs for shaders, such as controlling roughness, opacity, or emission intensity.

7. Rename the scalar parameter to normal_intensity_micro

8. Set the default value to 1

9. Hold down the M-key to add a multiply node

In Unreal Engine 5, the Multiply node is a mathematical function that takes two inputs and outputs their product.

10. Connect the mask to the A-input of the multiply node

11. Connect the scalar parameter to the B-input of the multiply node

12. This scales the normal intensity

13. Right-click and add an append vector

In Unreal Engine 5, the Append Vector node is a material expression that combines data from two inputs (Input A and Input B) to create a new multi-channel vector, such as a float2, float3, or float4.

14. Hold down the 1-key and add a constant vector

In Unreal Engine 5, Constant Vector nodes are material expressions that output fixed, multi-channel values (scalars or vectors) which do not change once set in the editor.

15. Change the value to 1

16. Connect the multiply node to the A-input of the append node

17. Connect the constant vector to the B-input of the append node

18. Connect the append node to the base normal of the blend angle corrected normals

19. Connect the normal map RGB into a Component Mask node

20. This reconstructs the normal map correctly – adding the blue channel back into the material

21. Duplicate the same setup for the macro normal map

22. Rename the scalar parameter to normal_intensity_macro

23. Connect the macro normal map to the mask

24. Connect the append node to the additional normal of the blend angle corrected normals

25. Apply and save the material

26. Now both normal maps have independent controls

Step 5 — Normalize the Final Result

1. Because the normal intensities are being modified, the final normals may become invalid and produce lighting artifacts

2. To fix this right-click and add a normalize node

In Unreal Engine 5, the Normalize node converts an input vector into a unit vector that retains the original direction but has a fixed length (magnitude) of 1.

3. Connect the blend angle corrected normals to the normalize

4. Connect the normalize to the normal input

5. Apply and save the material

6. This ensures the final normal vector remains properly normalized

Step 6 — Test in a Material Instance

1. Apply your material instance to the static mesh

2. Double-click on the material instance to open it

3. You should now see two exposed controls - Normal_Intensity_Micro and Normal_Intensity_Macro

4. You can use these sliders to change each normal map independently

Conclusion

Blending normal maps in Unreal Engine is an essential technique for creating detailed and believable materials. By combining micro and macro normal detail, you can dramatically improve surface richness while maintaining flexibility and performance.

Introduction

If you’ve ever wanted to create realistic, real-world terrain inside Blender without sculpting everything by hand, MapNG is an incredibly powerful (and free) tool to add to your workflow.

In this tutorial, you’ll learn how to use MapNG to generate terrain data and import it into Blender 5.1, apply textures, and get a clean, usable landscape for rendering, animation, or environment design.

Step 1: Download Terrain

1. Open MapNG in your browser 

2. You’ll see a world map interface where you can click and drag around the map to find the terrain you want to use

3. In the bottom right corner, you can choose satellite to better see what the terrain looks like

4. You can change the resolution for the exported maps

5. The orange square shows you what you will be exporting

6. When you have your selection made, click on generate data

7. Scroll down to the ready to export section

8. You have a few different options to choose from

9. For this tutorial, we will be exporting the Satellite data – this will provide the texture

10. You can then use various options for the mesh – in this tutorial, we will use the GLB model

Step 2: Import into Blender

1. Drag-and-drop the GLB file into Blender

2. You may need to tab into edit mode and do some cleanup on the mesh

3. Add a new material

4. Drag-and-drop the downloaded texture into the shader editor and connect it to the principled shader

Conclusion

Using MapNG with Blender opens up a fast and powerful way to create real-world terrain with minimal effort. You can generate highly detailed elevation data and textures directly from real locations—completely free.

Introduction

Creating a convincing bark material procedurally in Blender is a great way to add realism to trees, logs, or environmental assets – without relying on image textures.

In this tutorial, you’ll build a bark material from scratch using Blender’s Shader Editor. The focus will be on combining noise, distortion, and color variation to mimic the rough, layered structure of real tree bark.

Step 1: Basic Material

1. Select your object and create a new material – naming it appropriately

2. Make sure you have the Node Wrangler add-on activated

3. Make sure you are in material preview so you can see your material

Step 2: Base Texture

1. Use SHIFT + A to add a Voronoi texture and connect the distance output to the base color of the principled shader

2. Change the distance metric to Chebychev to change the texture to squares instead of circles

3. Increase the scale to make the texture smaller [9]

4. Select the Voronoi Texture and use CTRL + T to add mapping and texture coordinate nodes

5. Change the Texture Coordinate to Object

6. To stretch the texture, decrease the Z-Scale on the mapping node [0.25]

7. To add distortion to the Voronoi texture, use SHIFT + A to add a noise texture between the texture coordinate and mapping nodes

8. Increase the scale and detail levels of the noise texture [8, 15]

9. To more easily control the distortion, use SHIFT + A to add a mix color node

10. Connect the object output of the texture coordinate to the A-input of the mix color node and the color output of the noise texture to the B-input of the mix color node

11. Connect the mix color node to the vector input of the mapping node

12. Change the blending mode of the mix color node to linear light to more easily control the distortion using the factor

13. Lower the factor of the mix color node so the texture coordinate is mostly being used with small assistance from the noise texture [0.075]

14. To add some color, use SHIFT + A to add a color ramp between the Voronoi texture and principled shader

15. Change the black color stop to a light brown color [#967759FF]

16. Add a third color stop and move it closer to the black color stop

17. Change the color to a darker brown [0.3] [#593F29FF]

18. Change the white color stop to a very dark brown [#0D0905FF]

19. Moving the white color stop will increase the contrast

20. Select the noise texture, mix color, mapping node, Voronoi texture, and color ramp

21. Use the F-key to add a frame and rename it to base

Step 3: Roughness

1. Use SHIFT + A to add a Color Ramp to control the roughness

2. Connect the Voronoi texture to the new color ramp

3. Connect the new color ramp to the roughness input of the principled shader

4. Change the black color stop to a lighter color in order to make the bark rougher [#C8C8C8FF]

5. Select the color ramp

6. Use the F-key to add a frame and rename it to roughness

Step 4: Moss

1. Use SHIFT + A to add a noise texture

2. Connect the texture coordinate node to the new noise texture

3. To preview the factor of the noise texture, connect it to the base color of the principled shader

4. increase the scale, detail, roughness, and distortion of the noise texture [8, 15, 0.75 0.4]

5. To add more contrast, use SHIFT + A to add a color ramp between the noise texture and the principled shader

6. Move the black and white color stops to increase the contrast [0.55, 0.75]

7. Use SHIFT + A to add a mix color node

8. Connect the color ramp for the moss to the Factor to tell Blender where the moss is to be placed on the texture

9. Connect the color ramp of the base texture to the A-input

9. Connect the mix color node to the principled shader

10. Change the B-input color to a green for the moss [#7AA05CFF]

11. Select the noise texture and color ramp

12. Use the F-key to add a frame and rename it to moss

Step 5: Normals

1. Use SHIFT + A to add a bump node and connect it to the normal input of the principled shader

2. Connect the Voronoi texture to the height input of the bump node

3. Increase the distance of the bump node to see the effect

4. Select the bump node

5. Use the F-key to add a frame and rename it to bump

Conclusion

By combining noise textures, distortion, color ramps, and bump mapping, you can create a fully procedural bark material that looks organic and detailed – without any image textures. This approach is powerful because it’s endlessly adjustable: you can create anything from smooth young bark to deeply cracked old tree trunks just by tweaking parameters.

Introduction

Creating realistic metal materials in Blender doesn’t require image textures – procedural nodes can do all the heavy lifting. In this tutorial, you’ll build a rich, slightly imperfect gold material using Blender 5.1. Instead of a flat metallic look, we’ll introduce subtle variation in color, roughness, and surface detail to mimic how real gold behaves under light.

Step 1: Start with a Basic Material

1. Select your object and create a new material – naming it appropriately

2. Keep the default Principled BSDF

3. Make sure you have the Node Wrangler add-on activated

4. Make sure you are in material preview so you can see your material

Step 2: Create Gold Color Variation

1. Use SHIFT + A to add a Color Ramp node and connect it to the Base Color

2. Use SHIFT + A to add a Noise Texture and connect the Color output to the Color Ramp

3. Select the Noise Texture and use CTRL + T to add Mapping and Texture Coordinate nodes

4. Change the Texture Coordinate to Object

5. Adjust Noise Settings:

Scale: 1

Detail: 8

Roughness: 0.9

Distortion: 3.5

6. Adjust Color Ramp:

Black → Orange [#CD7D24FF]

White → Yellow [##B1964FFF]

7. Move the white color stop closer to the center

Step 3: Control Metallic Properties

1. Use SHIFT + A to add a Color Ramp

2. Connect the Color Ramp to the Metallic input of the Principled Shader

3. This will allow us to use the color stops to control the Metalness of the material

Step 4: Add Roughness Variation

1. Use SHIFT + A to add another Color Ramp

2. Connect the Color Ramp to the Roughness input of the Principled Shader

3. Use SHIFT + A to add a new Noise Texture and connect it to the Color Ramp

4. Select the Noise Texture and use CTRL + T to add Mapping and Texture Coordinate nodes

4. Change the Texture Coordinate to Object

5. Change the Noise Settings:

• Scale: 2
• Detail: 8
• Roughness: 0.9

6. Bring the black color stop closer to the center of the Color Ramp [0.25]

Step 5: Add Surface Bump Detail

1. Use SHIFT + A to add a Bump Node

2. Connect the Bump Node to the Normal of the Principled Shader

3. Use SHIFT + A to add another Color Ramp and connect it to the Height of the Bump Node

4. Use SHIFT + A to add a Noise Texture

5. Select the Noise Texture and use CTRL + T to add Mapping and Texture Coordinate nodes

6. Change the Texture Coordinate to Object

7. Connect the Noise Texture to the Color Ramp

8. Change the Noise Texture settings:

• Scale: 1
• Detail: 8
• Roughness: 0.9
• Distortion: 3.4

9. Change the Bump Node strength to around 0.75

Conclusion

By layering noise textures and controlling how they affect color, roughness, metallic values, and bump, you’ve created a believable procedural gold material. The key isn’t just making something “yellow and shiny” – it’s introducing controlled imperfection.