Skip to content
Tutorials Center
My learning

Topics

Lesson 17 of 37 ยท Materials and Shading

Image Textures and PBR Maps

Use image textures in Blender: Image Texture node, colour spaces, PBR maps (albedo, roughness, metallic, normal, height, AO), bump versus normal and file organisation.

Procedural nodes are flexible, but most realistic surfaces use image textures: photographs or painted maps that supply detail like wood grain, scratches and dirt. Modern workflows use a set of maps, called PBR (physically based rendering) maps, each driving one input of the Principled BSDF. This lesson explains the maps, how to connect them and the colour-space rule that trips up almost everyone.

The Image Texture node

  1. In the Shader Editor add an Image Texture node (Shift+A > Texture > Image Texture).
  2. Click Open and choose a file (PNG, JPEG, EXR, TIFF, or others).
  3. Connect its Color output to the Principled BSDF Base Color.

By default the node reads the object's UV map. If the object has no UVs, the texture will not appear correctly; unwrap it first (previous lesson). The node also has Interpolation (Linear, Closest for pixel art) and Extension (Repeat, Extend, Clip, Mirror) options that decide what happens outside 0 to 1.

The PBR maps

Map Drives Colour space Notes
Base Color / Albedo Base Color sRGB The pure colour with no lighting baked in
Roughness Roughness Non-Color White = rough, black = glossy
Metallic Metallic Non-Color Mostly black and white
Normal Normal (via Normal Map node) Non-Color Purple-blue image encoding fine surface direction
Height / Displacement Displacement or Bump Non-Color Grey-scale: white high, black low
Ambient Occlusion Multiply with colour Non-Color Optional: baked shadows in crevices
Emission Emission Color sRGB Glowing parts
Alpha / Opacity Alpha Non-Color Cut-outs, leaves

The colour-space rule

Colour images (albedo, emission) are stored in sRGB, which is how monitors expect them. Data images (roughness, metallic, normal, height) contain numbers, not colours, and must be read without any colour transform. In the Image Texture node set Color Space to Non-Color for those. If you leave them as sRGB, normals look wrong, roughness values shift and the surface becomes too shiny or too dull.

Python Stand-in: why sRGB must not be used for data maps

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Normal maps

A normal map is an image in which red, green and blue encode a surface direction (X, Y, Z). It makes flat geometry look bumpy without adding polygons. Connect through a Normal Map node (Shift+A > Vector > Normal Map) between the Image Texture (Non-Color) and the BSDF Normal input. Check the Strength.

Two conventions exist, OpenGL (Y up, used by Blender) and DirectX (Y flipped). If bumps look inverted, flip the green channel (an inversion node or the texture's DirectX/OpenGL version).

A Bump node does a similar job from a greyscale height map. Normal maps are more precise, bump maps are easier to make.

Python Stand-in: decode a normal-map pixel

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

The flat pixel decodes to (0, 0, 1): straight out of the surface. That is why normal maps look mostly lavender blue.

Mapping and scale

Insert Texture Coordinate > UV and a Mapping node (Location, Rotation, Scale) before the Image Texture to tile or move it. A Scale of 4, 4, 4 repeats the texture four times. Repeating textures can look obviously tiled; break the pattern by mixing a large-scale noise or using an additional, different-scale instance.

flowchart LR
  UV["UV"] --> M["Mapping"]
  M --> A["Albedo (sRGB)"]
  M --> R["Roughness (Non-Color)"]
  M --> N["Normal (Non-Color)"] --> NM["Normal Map node"]
  A --> P["Principled BSDF"]
  R --> P
  NM --> P

One mapping node can drive all maps so they stay aligned.

Where to get textures

Use only textures you have the right to use. Free CC0 libraries exist (for example Poly Haven and ambientCG; check each licence), or you can paint your own in Blender's Texture Paint mode, or bake from procedural nodes. Packed PBR sets usually include several maps in one folder; Node Wrangler's Ctrl+Shift+T can load and wire a whole set automatically.

Organising files

  • Keep textures in a folder next to the .blend file and use File > External Data > Make Paths Relative.
  • Or Pack Resources to embed them (bigger file).
  • Name maps consistently: wood_albedo.png, wood_roughness.png, wood_normal.png.
  • 2K (2048 px) is usually plenty; 4K only for hero close-ups; keep textures square and power-of-two for games.

Troubleshooting

Problem Likely cause
Texture appears stretched Bad UVs; unwrap and check
Everything looks too shiny or too dull Roughness map set to sRGB instead of Non-Color
Bumps look inverted DirectX normal map used in Blender; flip green
Pink or missing texture File path broken; re-link or use relative paths
Visible tiling Add variation with noise or mix two scales

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Which colour space should a roughness map use?

    Data maps hold numbers, so no colour transform should be applied.
  2. 2. Which node must a normal map image pass through?

    The Normal Map node converts the image to normals for the BSDF Normal input.
  3. 3. What does a flat pixel in a normal map look like?

    That colour decodes to a normal pointing straight out.
  4. 4. What does an albedo map contain?

    Albedo is the pure colour of the material.

Summary

  • Image Texture nodes read files through UVs and feed Principled BSDF inputs.
  • PBR sets include albedo, roughness, metallic, normal, height and more.
  • Colour maps use sRGB; data maps must be Non-Color.
  • Normal maps need a Normal Map node and the correct OpenGL/DirectX convention.
  • Keep textures organised and use relative paths.

Next: Procedural Textures and Colour