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.

Introduction

In Unreal Engine 5.7, materials aren’t just static visuals. They can be fully dynamic and controlled in real time using Blueprints. Building upon the adjustable material we’ve already created, this tutorial walks you through creating surface imperfections to further enhance your materials.

Step 1: Surface Imperfection setup 

1. This is a continuation of a previous tutorial showing you how to control textures via blueprints 

2. Find a grunge texture or other texture you want to use for the surface imperfections

3. Make sure the image is black and white

4. Drag-and-drop the texture image into your textures folder

5. Double-click on the master material to open it

6. Drag-and-drop your texture into the material graph

7. Connect the texture to the roughness input to get a look at the texture on your material

8. Right-click on the texture and convert it to a parameter – renaming it to Surface Imperfection – this will allow you to change textures easily

9. With the Texture selected, in the Details Panel, type Surface Imperfection in the Group field

10. If you apply and save the material and then open the Material Instance, you will now notice a Surface Imperfection group

11. Add a Multiply node by holding down the M-key and left-clicking

12. Connect the Texture map to the A-input of the Multiply node and connect the Multiply node to the Roughness

13. Add a Scalar parameter by holding down the S-key and left-clicking

13. Rename the Scalar parameter to Imperfection Brightness

15. Connect the Scalar parameter to the B-input of the Multiply node

16. Change the Value to 1

17. Add the Scalar parameter to the Surface Imperfection group

18. Apply and save the material

19. If you open the material instance, you will now see the Surface Imperfection Brightness parameter which can be adjusted

20. Add a Power node by holding down the E-key

21. Connect the Multiply node to the Base-input of the Power node

22. Connect the Power node to the Roughness

23. Add a Scalar parameter by holding down the S-key and left-clicking

24. Rename the Scalar parameter to Imperfection Contrast

25. Connect the Scalar parameter to the Exponent-input of the Power node

26. Set the Value to 1

27. Add the Scalar parameter to the Surface Imperfection group

28. Apply and save the material

29. If you open the material instance, you will now see the Surface Imperfection Contrast parameter which can be adjusted

Step 2: Surface Imperfection Min/Max

1. Add a Lerp node by holding down the L-key and left-clicking – this is similar to a mix RGB node in Blender

2. Connect the Power node to the Alpha input of the Lerp

3. Add a Scalar Parameter by holding down the S-key and left-clicking

4. Rename this Scalar Parameter to Imperfection Min

5. Add a second Scalar Parameter and name it Imperfection Max – changing the Value to 1

6. Connect the Minimum to the A-input and the Maximum to the B-input of the Lerp

7. Connect the Lerp to Roughness

8. Add the Scalar parameters to the Surface Imperfection group

9. Apply and save the material

10. If you open the material instance, you will now see the Surface Imperfection Min and Max parameters which can be adjusted

Step 3: Blending Surface Imperfections and Roughness

1. To blend the surface imperfections and the roughness, right-click and search for a Static Switch Parameter

2. Rename the Parameter to Blend

3. Connect the Surface Imperfections Lerp to the True input

4. Connect the Power node of the Roughness into the False input

5. Add the Static Switch Parameter to the Surface Imperfection group

6. Connect the Static Switch Parameter into the Roughness

7. To control the value of the Surface Imperfections and the Roughness, hold down the L-key and add a second Lerp node

8. Connect the first Lerp node into the A-input of the second Lerp node

9. Connect the Roughness into the B-input of the second Lerp node

10. Connect the second Lerp node to the True input of the Blend parameter

11. Right-click on the Alpha input of the second Lerp node and promote it to a parameter so we can use it to control the value

12. Change the name to Alpha Blend and add it to the Surface Imperfection group and change the Value to 0.5

13. Apply and save the material

14. If you open the material instance, you will now see the Surface Imperfection Alpha Mix which can be adjusted

15. Box-select all the Surface Imperfection nodes and use the C-key to add a Comment Box

16. Rename the Comment Box to Surface Imperfection

17. Apply and save the material

18. Select the last 3 nodes and use the C-key to add a Comment Box

19. Rename the Comment Box to Surface Imperfection Blend

20. Apply and save the material

Conclusion

You’ve now built a fully dynamic material control system including surface imperfections in Unreal Engine 5. Instead of just swapping textures, you can fine-tune nearly every visual aspect of a surface in real time.

In this tutorial, we'll be diving into the process of creating a realistic wood material using Blender’s powerful node system. By the end of this guide, you'll be able to replicate the complex texture of wood with natural grains, imperfections, and subtle scratches.

Step 1: Grain Texture

1. Make sure you have the node wrangler addon activated and you are in material preview

2. Make a new material and name it appropriately

3. Press Shift + A and add a noise texture and uncheck normalize – this will be used for the large grain pattern (NOTE: In previous Blender versions, this will be the Musgrave texture)

4. Right-click on the noise texture and rename it to Musgrave

5. To preview it, connect the noise texture to the principled shader base color input

6. Set the following values for the Musgrave texture:

Scale: 4.6

Detail: 15

Lacunarity: 0 (NOTE: Dimension for previous Blender versions)

7. Press Shift + A and add a noise texture – leaving the normalize option checked

8. Add a mix color node and use SHIFT + D to duplicate it

9. Use CTRL + T to add a mapping and texture coordinate node to the first mix color node

10. Delete the texture image node and connect the mapping node to the A-input of the mix color node

11. Change the texture coordinate to object

12. Connect the result of the first mix color node into the vector of the noise texture

13. Connect the factor of the noise texture into the vector of the Musgrave texture and the B-input of the second mix color node

14. Connect the factor of the Musgrave texture into the A-input of the second mix color node

15. Connect the second mix color node to the base color of the principled shader

16. Change the noise texture values to the following:

            Scale: 27.8

            Detail: 11

            Distortion: 1.12

17. Change the mapping scale values to the following:

            X: 1.08

            Y: 0.15

            Z: 0.15

18. Change the factor of the first mix color node to 0.2 and the B-input color to #BFBFBF

19. Change the factor of the second mix color node to 0.85

20. Select all the nodes except the principled and output node and use SHIFT + P to add a frame

21. Use F2 to rename the frame to “grain”

Step 2: Color

1. Press Shift + A and add a ColorRamp to control the color transitions of the wood texture

2. Connect the second mix color node into the factor of the color ramp

3. Connect the color ramp to the base color of the principled shader

4. Change the black color stop to a dark brown (#331e12)

5. Add a new color stop and change the color to a light brown (#4b2d1b)

6. Add a new color stop and change the color to a golden brown (#7f562e)

7. Change the white color stop to a light beige (##a68e77)

8. Adjust the color stops to get the look you want

9. Select the color ramp and use SHIFT + P to add a frame

10. Use F2 to rename the frame to “color”

Step 3: Knots and Imperfections

1. Use SHIFT + A to add a noise texture and uncheck normalize

2. Right-click on the noise texture and rename it to Musgrave

3. Use SHIFT + A to add a wave texture

4. Connect the Musgrave texture to the base color of the principled shader

5. Change the following values:

Detail: 15

Lacunarity: 6.2

Distortion: 0.16

6. Connect the color of the wave texture to the scale of the Musgrave texture

7. Change the following values of the wave texture:

            Scale: 0.7

            Distortion: 4.5

            Detail: 0.14

            Detail Scale: 5

8. Select the wave texture and use CTRL + T to add a mapping and texture coordinate node

9. Change the texture coordinate to object

10. Use SHIFT + A to add a color ramp between the Musgrave texture and principled shader

11. Swap the black and white color stops on the color ramp

12. Change the black color stop to a midtone gray

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

14. Drag the mix color node onto the noodle between the color ramp and the principled shader

15. Connect the second mix color node from the grain to the B-input of the new mix color node

16. Connect the new mix color node to the COLOR color ramp

17. Connect the COLOR color ramp to the base color of the mix shader

18. Make any adjustments to the nodes as needed

19. Select the new nodes and use SHIFT + P to add a frame

20. Use F2 to rename the frame to “knots”

Step 4: Scratches and Finer Details

1. Use SHIFT + A to add a noise texture and uncheck normalize

2. Right-click on the noise texture and rename it to Musgrave

3. Connect the Musgrave texture to the base color of the principled shader

4. Change the following values:

Scale: 15

Detail: 15

Lacunarity: 2.5

5. Select the Musgrave texture and use CTRL + T to add a mapping and texture coordinate node

6. Change the texture coordinate node to object

7. Change the X-Scale to 120 and Y-Scale to 0.8

8. Add a color ramp between the Musgrave texture and the principled shader

9. Swap the black and white color stops on the color ramp

10. Changing the position of the color stops allows you to refine the scratches

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

12. Connect the new color ramp into the B-input of the new mix color node

13. Connect the COLOR color ramp into the A-input of the new mix color node

15. Connect the new mix color node from the scratches to the base color of the principled shader

16. Make any adjustments to the nodes as needed

17. Select the new nodes and use SHIFT + P to add a frame

18. Use F2 to rename the frame to “scratches”

Step 5: Bump Map

1. Use SHIFT + A to add a bump node

2. Use SHIFT + D to duplicate the bump node

3. Connect the COLOR color ramp into the height input of the first bump node

4. Connect the color ramp from the scratches into the height input of the second bump node

5. Connect the normal output of the first bump node into the normal input of the second bump

6. Connect the normal output of the second bump node into normal input of the principled shader

Conclusion

With that, you now have a realistic procedural wood material that can be easily customized in Blender! By using Musgrave, Noise, and Wave textures combined with color ramps and bump mapping, you've created a detailed and customizable wood material with main grain patterns, imperfections, and fine scratches.