Curvature maps are one of the most useful texture maps in game development, yet Blender has no built-in bake pass for them. If you have used Substance Painter, you know curvature maps are generated automatically and used as the foundation for edge wear, cavity dirt, and procedural material effects. When you move to a Blender-only workflow, getting equivalent curvature data requires either manual workarounds or dedicated tools.

This tutorial covers what curvature maps actually represent, why they matter for game art, how Substance Painter generates them, and three methods for achieving the same results in Blender — from fully manual to fully automated.

What Curvature Maps Actually Are

A curvature map encodes how sharply a surface bends at each point. It typically stores two types of information:

• Convex curvature (edges): Where the surface bends outward — external edges, ridges, raised details. These areas appear bright in a curvature map.
• Concave curvature (cavities): Where the surface bends inward — internal corners, crevices, grooves, recessed areas. These areas appear dark in a curvature map.
• Flat areas: Surfaces with no significant curvature appear as neutral gray (typically 0.5 or 128 in 8-bit).

The result is a grayscale texture where bright pixels represent edges, dark pixels represent cavities, and gray pixels represent flat surfaces.

Why Curvature Maps Matter for Game Art

Curvature data drives some of the most common procedural texturing effects:

• Edge wear and scratches: Real objects wear most on their edges and raised surfaces. A convex curvature mask applied to a roughness or color layer produces realistic edge highlighting with zero hand painting.
• Cavity dirt and ambient occlusion: Dust, grime, and wear accumulate in crevices. Concave curvature drives cavity darkening that adds depth to materials.
• Edge highlighting: Many stylized art styles use edge brightening for readability. Curvature maps provide the exact mask you need.
• Procedural damage: If you want scratches that naturally follow edges and corners, curvature data tells your shader where those features are.
• Material layering: When combining materials (like paint over metal), curvature maps help define where the top layer chips away first — always on edges, matching real-world wear patterns.

Without curvature data, achieving these effects requires hand-painting masks for every asset. With curvature data, you paint once (procedurally) and it works on every mesh.

How Substance Painter Does It

Substance Painter generates curvature maps by analyzing the mesh geometry (or the baked normal map) during the baking step. Its process is roughly:

1. Compute the surface normal at each texel
2. Compare adjacent normals to measure how quickly the surface direction changes
3. Map the rate of change to a grayscale value — fast change (sharp edge) maps to white, slow change (flat) maps to gray, inward change (cavity) maps to black

The computation happens on the baked normal map rather than directly on the geometry, which means it captures both the high-poly details baked into the normal map and the actual mesh topology. This is why Substance Painter's curvature maps look so good — they include detail that a geometry-only analysis would miss.

Method 1: Geometry Nodes Approach (Manual)

Blender's Geometry Nodes can compute curvature-like data by comparing face normals between adjacent faces. This method works in the viewport and does not require baking, but producing a bakeable result takes extra steps.

Step-by-Step Setup

1. Select your mesh and add a Geometry Nodes modifier
2. Build the following node tree:

Mesh input
  → Edge Angle node (gets the angle between adjacent faces at each edge)
  → Map Range node (remap angles from 0-π to 0-1)
  → Store Named Attribute (store as vertex color)

The Edge Angle node outputs the unsigned angle between faces sharing each edge. Sharp edges (convex features) produce large angles. Smooth surfaces produce angles near zero.

3. To separate convex and concave curvature, you need a signed measurement. Compare the edge angle direction against the face normals:

Edge Angle → Compare with face normal dot product
  → Positive = convex (edges)
  → Negative = concave (cavities)

4. Store the result as a Color Attribute, then bake it using Blender's standard bake system (set bake type to "Emit" with the attribute connected to the emission shader).

Limitations

• Resolution depends on mesh density — low-poly meshes produce blocky curvature data
• Does not capture normal map details, only actual geometry
• Requires manual node setup per asset
• Baking the attribute to a texture requires additional shader setup

This method is educational and good for understanding what curvature maps represent, but it is not practical for production use on multiple assets.

Method 2: Shader-Based Curvature Detection

You can approximate curvature in Blender's shader editor using the Geometry node and some math. This approach works at render resolution and captures visual curvature regardless of mesh density.

The Node Setup

Geometry node (Pointiness output)
  → ColorRamp (adjust contrast)
  → Separate into convex/concave with threshold

The Pointiness output of the Geometry node in Blender approximates curvature by analyzing the angle between a vertex normal and its neighbors. Values above 0.5 represent convex areas (edges), and values below 0.5 represent concave areas (cavities).

Refining the Output

The raw Pointiness output is usually very subtle. To get usable curvature data:

1. Add a Math node set to Subtract with value 0.5 (centers the data around zero)
2. Add a Math node set to Multiply with value 5-20 (increases contrast)
3. Add a Math node set to Clamp (prevents values from exceeding 0-1 range)
4. Use a ColorRamp for final contrast adjustment

For separate convex and concave outputs:

Pointiness → Subtract 0.5 → Separate:
  Convex:  Clamp(value * 10, 0, 1)
  Concave: Clamp(-value * 10, 0, 1)

Baking the Shader Output

To bake this to a texture:

1. Create a new image texture node in the material (do not connect it — just select it)
2. Set the material output to an Emission shader connected to your curvature output
3. Bake type: Emit
4. Bake

This produces a curvature map, but quality depends heavily on mesh density and the Pointiness algorithm's limitations. It works reasonably well on high-poly meshes but produces artifacts on low-poly game meshes.

Limitations

• Pointiness requires well-distributed vertex density
• Low-poly meshes produce patchy, inconsistent results
• No capture of normal map detail
• Manual setup and bake configuration per asset

Method 3: Automated Curvature Baking with One-Click PBR Bake

For production work, manually setting up curvature detection and baking for every asset is not sustainable. One-Click PBR Bake and Export includes curvature map baking as one of its supported map types, handling the detection algorithm and bake configuration automatically.

The advantage of a dedicated baking tool for curvature is that it can use more sophisticated detection than the basic Pointiness approach:

• Analysis of the baked normal map (similar to how Substance Painter works) for higher-quality edge and cavity detection
• Consistent output quality regardless of mesh density
• Proper separation of convex and concave channels
• Automatic channel packing with your other PBR maps

The workflow is straightforward: select your mesh, enable the curvature map output in the bake settings, and bake. The curvature map is generated alongside your other PBR textures (diffuse, roughness, metallic, normal, AO, height) in a single operation.

Using Curvature Maps in Your Shader Setup

Once you have a curvature map — regardless of which method you used to generate it — here is how to use it effectively in Blender's shader editor.

Edge Wear Effect

Curvature Map (convex channel)
  → ColorRamp (adjust threshold for wear amount)
  → Mix Shader factor
    → Shader A: Base material (painted metal, wood, etc.)
    → Shader B: Worn material (raw metal, exposed wood grain)

Cavity Dirt

Curvature Map (concave channel)
  → Invert
  → Multiply with base color
  → Slight roughness increase in cavities

Edge Highlighting (Stylized)

Curvature Map (convex channel)
  → ColorRamp (sharp falloff)
  → Add to emission or base color

Combined Wear System

For a complete procedural wear setup, combine curvature with other data:

Curvature (edges) + AO (cavities) + Height (top surfaces)
  → Layer: Edge wear (bright metal showing through paint)
  → Layer: Cavity grime (dark accumulation in crevices)
  → Layer: Top-surface dust (lighter color on upward-facing areas)

This layered approach — curvature plus ambient occlusion plus height — approximates the kind of smart material system that Substance Painter provides. The Procedural Damage and Wear System builds on this principle, combining curvature data with additional wear algorithms to create non-destructive damage effects directly in Blender's viewport.

Curvature Map Quality Comparison

How do these methods compare to Substance Painter's output?

The Geometry Nodes approach gives you the most control but the slowest iteration. The Pointiness shader approach is quick to set up but lowest quality. Automated baking tools close the gap with Substance Painter while keeping you inside Blender.

When to Stay in Blender vs. Use Substance Painter

Be pragmatic about this. Substance Painter remains the better tool for hand-painted texturing, complex multi-layer material work, and projects where you need to paint unique detail on every asset. Its curvature-driven smart materials are still industry-leading.

But if your workflow is primarily procedural — using curvature maps to drive automated wear rather than hand-painting detail — Blender can handle the full pipeline. The curvature data quality from dedicated baking tools is close enough to Substance Painter's output that the procedural effects built on top of it look equivalent in the final game.

For indie developers weighing the cost of a Substance Painter subscription against a Blender-native workflow, curvature map generation is no longer the blocker it used to be.