Textures and HDRIs

PBR Texture Maps Explained: Albedo, Roughness, Metallic and More

What each PBR texture map does, from albedo, roughness and metallic to normal, height and AO, plus color space, packed maps and where they connect in Blender.

On this page
  1. What PBR means in practice
  2. The core PBR maps
  3. Other maps you’ll see
  4. Metal/roughness vs specular/glossiness workflows
  5. Color space: sRGB vs Non-Color
  6. Packed maps (ARM/ORM, Unity mask maps, glTF)
  7. Where each map connects in Blender
  8. Common PBR mistakes

What PBR means in practice

Physically based rendering (PBR) is an approach to shading that models how light really behaves on surfaces: how much is reflected, how sharply, and how much is absorbed. The practical result for artists is that a material is described by a set of texture maps, each controlling one property. Because those properties are based on physical behavior, a well-made PBR material looks right under very different lighting, from a sunny HDRI to a dim interior.

You’ll meet PBR maps whenever you download a material from a library like Poly Haven or ambientCG, export from a texturing app, or set up a shader in Blender, Unity or Unreal. Here’s what each one does.

The core PBR maps

Albedo / Base Color

The albedo map (also called base color, diffuse or color) holds the surface’s color, without lighting. That means no baked shadows, no highlights, and no ambient occlusion painted in. Lighting is the renderer’s job.

A few guidelines:

  • Real-world materials rarely reach pure black or pure white. Very dark charcoal and fresh snow are near the extremes, so avoid fully black or fully white albedo values for non-metals.
  • For metals, the base color represents the color of the reflection. Gold is yellow-orange, copper is reddish, and most other metals are fairly bright and neutral.
  • An older “diffuse” texture with shadows painted into it can look dirty or doubled-up in a PBR renderer.

Roughness

The roughness map is grayscale and controls how sharp or blurry reflections are:

  • Black (0) = perfectly smooth, like a mirror or polished lacquer. Reflections are sharp.
  • White (1) = very rough, like chalk or unfinished concrete. Reflections are spread out until the surface looks matte.

Roughness is often the map that adds the most realism, because real surfaces vary: fingerprints on glass, worn paths on a floor, wet patches on stone. A flat single roughness value tends to look artificial.

Some engines use smoothness or gloss instead, which is simply the inverse: white is smooth, black is rough. Unity’s standard Lit shaders use smoothness, so roughness maps need to be inverted for them.

Metallic

The metallic (or metalness) map tells the shader whether a surface is a metal:

  • White (1) = metal. The surface has colored reflections and no diffuse color.
  • Black (0) = non-metal (dielectric): wood, plastic, stone, skin, fabric, paint.

In most cases, metallic should be close to pure black or pure white. In-between values are mainly useful for transitions, like where paint is chipping off a metal surface, or for anti-aliased edges between the two. Painted metal counts as non-metal where the paint is, because light hits the paint, not the metal underneath.

Normal

A normal map is the purple-blue image in most material sets. Its red, green and blue channels encode the direction each pixel’s surface faces, which lets the renderer fake small bumps, grooves and scratches without extra geometry. The silhouette stays the same, but light and shadow behave as if the detail were there.

Normal maps come in two common conventions: OpenGL (used by Blender, Unity and Godot) and DirectX (used by Unreal Engine). They differ in the direction of the green channel. Using the wrong one makes bumps look like dents. Our comparison of normal maps, bump maps and displacement maps covers this in more depth.

Height / Displacement

The height map (often labeled displacement) is grayscale, where white is high and black is low. It can be used in two ways:

  • As a bump map, to fake detail in the shading, similar to a normal map.
  • As true displacement, where the renderer actually moves the mesh’s vertices, changing the silhouette. This requires enough geometry, usually through subdivision.

Height maps are also used in game engines for parallax effects and for blending between materials, such as letting sand fill the gaps between stones.

Ambient Occlusion

The ambient occlusion (AO) map is grayscale and darkens crevices and corners where ambient light has a harder time reaching. White means fully exposed; dark means occluded.

How you use it depends on the renderer:

  • Game engines such as Unity and Unreal have dedicated occlusion inputs, and AO maps add useful contact shading that real-time lighting, even with screen space ambient occlusion, can miss.
  • Path tracers like Blender’s Cycles calculate occlusion naturally, and the Principled BSDF has no AO input. Some artists lightly multiply the AO into the base color for extra definition, but it’s an artistic choice rather than a physical one, and it’s easy to overdo.

Other maps you’ll see

  • Emission: areas that glow, such as screens, LEDs or lava. Usually plugged into an emission color input with a separate strength value.
  • Opacity / Alpha: controls transparency for cut-out effects like leaves, fences, or decals. Black is transparent, white is opaque.
  • Specular: in the metal/roughness workflow, a specular input (or “specular level”) can fine-tune reflection intensity on non-metals. Most of the time the default is fine.
  • Extra layer maps: some materials include maps for subsurface scattering (skin, wax), sheen (velvet, cloth), clearcoat (car paint), or anisotropy (brushed metal). These are less common in free libraries.

Metal/roughness vs specular/glossiness workflows

There are two main PBR workflows:

  • Metal/roughness uses base color, metallic and roughness maps. It’s the most common workflow today and is used by Blender’s Principled BSDF, Unreal, Unity’s Lit shaders (with smoothness), and the glTF format.
  • Specular/glossiness uses a diffuse map, a colored specular map (reflection color and strength), and a glossiness map. It offers a bit more control over reflections but is easier to get physically wrong. You’ll still meet it in older assets and some pipelines.

Most free libraries provide metal/roughness maps. If you have a specular/glossiness set, you can usually convert it with a texturing tool, or approximate it: the diffuse becomes base color for non-metals, glossiness is inverted to roughness, and metal areas get identified from the specular map.

Color space: sRGB vs Non-Color

This is where many beginners’ materials go wrong.

  • Color maps (albedo, emission) store colors meant for display, encoded in sRGB.
  • Data maps (roughness, metallic, normal, height, AO, opacity) store numbers, not colors. They must be read linearly, without sRGB conversion.

In Blender, set every data map’s Image Texture node to Non-Color. In Unity, turn off sRGB (Color Texture) in the texture’s import settings, and set normal maps to the Normal map texture type. If you skip this, roughness values shift, materials look too glossy or too matte, and normal maps produce odd shading.

Packed maps (ARM/ORM, Unity mask maps, glTF)

Since roughness, metallic and AO are each grayscale, many pipelines pack them into one RGB image to save memory and texture lookups. Common layouts:

  • ARM / ORM: red = ambient occlusion, green = roughness, blue = metallic. This is common for Unreal Engine and offered by libraries such as Poly Haven.
  • glTF: the metallic-roughness texture stores roughness in green and metallic in blue. Occlusion is a separate texture slot that reads the red channel, so many exporters pack AO into the red channel of the same image.
  • Unity HDRP mask map: red = metallic, green = AO, blue = detail mask, alpha = smoothness.
  • Unity URP Lit: smoothness is read from the alpha channel of the metallic map (or of the base map).

To use packed maps in Blender, run the Image Texture (set to Non-Color) through a Separate Color node (in RGB mode) and connect each channel to the matching input.

Where each map connects in Blender

With the Principled BSDF shader:

Map Connect to Color space
Albedo / Base Color Base Color sRGB
Roughness Roughness Non-Color
Metallic Metallic Non-Color
Normal Normal Map node → Normal Non-Color
Height Bump node → Normal, or Displacement node → Material Output Displacement Non-Color
Opacity Alpha Non-Color
Emission Emission Color sRGB

The Node Wrangler add-on’s Principled Texture Setup (Ctrl+Shift+T in the Shader Editor) will load a whole folder of maps and wire most of this up for you. For a step-by-step walkthrough, see how to apply an image texture to a model in Blender.

Common PBR mistakes

  • Lighting baked into the albedo. Shadows and highlights in the color map look wrong under new light. Use a clean albedo.
  • Data maps left in sRGB. Set them to Non-Color (Blender) or turn off sRGB (Unity).
  • Gray metallic values everywhere. Keep metallic close to 0 or 1 except at transitions.
  • Uniform roughness. Add subtle variation; real surfaces are rarely evenly glossy.
  • Wrong normal map format. Use OpenGL normals in Blender and Unity, DirectX in Unreal, or flip the green channel.
  • Judging materials under poor lighting. Test under a neutral HDRI. Our list of free HDRIs for Blender includes studio options that work well for look development.

To build a library of materials to practice with, see where to get free textures for Blender and Unity.

The complete guide to textures and hdris

Where to Get Free Textures for Blender and Unity
Read the guide

Keep exploring

Guides from other topics

All topics →