The NexBake Baking Tutorial

Step by step

The MP7, from install to exported maps.

Install

Drag the NexBake .zip into Blender. Keep Enable Add-on ticked and press OK. A NexStudio button appears at the right of the top bar.

Activate

In the Account card press Redeem licence key, paste your key and press Redeem, then Link and activate. The card says Licence active.

Open NexBake

Click NexStudio › NexBake. The NexBake workspace opens.

Add the low poly

In the NexBake Outliner, drag your low poly collection from Scene onto Low. It needs a UV map. For one mesh, + Add Low Poly › From Scene… works too.

Add the high poly

Drag the high poly collection onto High. Pieces pair by name, Muzzle_low with Muzzle_high, and Bake turns blue.

Bake settings

Tick the maps in Mesh Map Bakers. In Common Settings set Output size (here 4096) and Antialiasing (Subsampling 4×4).

Bake

Press Bake at the bottom of the 3D view. Baking Process lists each map as it finishes. The MP7, 40 maps at 4K: about 4 minutes on an RTX 3080 (the clip is sped up).

Check the result

Turn off 3D Overlays to see the maps on the model, then press 2D to see them flat.

Export Textures

Open Export Textures, check Folder, File name and Format, then press Export.

NexBake Settings

What the settings in the steps do.

Output settings

Size, antialiasing and dilation are in Common Settings › Output:

Output Size: 256 to 8192 px per texture set.
Antialiasing: None, 2×2, 4×4 or 8×8: 1, 4, 16 or 64 samples per texel.
Dilation Width: How far each UV island grows outward.
Compute: Auto: GPU ray tracing when the card supports it, else every CPU core.

NexBake Common Settings: Output and High poly — **Common Settings** for the MP7: 2048 px, Subsampling 4×4, Dilation width 32 px, Match by mesh name.

Geometry: the cage

Rays start on a cage just outside the low poly. Max Frontal Distance and Max Rear Distance (default 0.01) set how far out and in they search. With Relative to Bounding Box on, 0.01 is 1% of the bounding box diagonal, so one value fits a small part and a large one.

Average Normals keeps the cage closed over hard edges.

Muzzle baked with a cage of 0.0005 — **Muzzle, lit with its normal map.** At 0.0005 NexBake warned that 50.6% of the texels found no high poly; the rings and slots are lost.

Muzzle baked with a cage of 0.01 — **Muzzle, lit with its normal map.** At 0.0005 NexBake warned that 50.6% of the texels found no high poly; the rings and slots are lost.

Texture sets and matching

Each material on the low poly is a texture set with its own maps and size; the MP7 has 10. A texture set can span UDIM tiles.

With Match: By Mesh Name, grip_low bakes only from grip_high. Set the suffixes in Low Suffix and High Suffix. High Poly Matching shows every pair; all 95 MP7 parts paired in place.

High Poly Matching: 11 of 11 groups matched by name — **High Poly Matching** on the MP7: by name, 11 / 11 groups matched.

Export

Maps stay in the .blend until you export them. Export Textures writes PNG or TIFF at 8 or 16 bit, EXR at 16 or 32-bit float, TGA and JPG.

File Name is a pattern such as $textureSet_$mapName; UDIM tiles add their number. Auto Export writes each map the moment it finishes.

NexBake Export Textures panel with 40 maps — **Export Textures** after the MP7 bake: 40 files, PNG 16-bit.

Map Types

Ten mesh maps, all from one job. Below, the MP7's laser module as each map stores it.

Laser module, tangent-space normal map — Normal
Which way the high poly faces, against the low poly's own surface. Light reacts to detail the low poly does not have.
*Normal Map FormatTangent Space*

Laser module, world space normal map — World Space Normal
The same directions against the world's axes. For dust from above or snow from one side.
*Up Axis*

Laser module, ID map — ID
Flat colours per object, piece, polygroup, material or vertex colour. A one-click selection for texturing.
*ID FromColor Generator*

Laser module, ambient occlusion map — Ambient Occlusion
Where ambient light is blocked. Contact shadows and a base for grime masks.
*Secondary RaysSpread AngleGround Plane*

Laser module, curvature map — Curvature
Convex edges light, cavities dark. Drives edge wear.
*MethodSampling Radius*

Laser module, position map — Position
Where each point lies in the bounding box. For gradients across the whole object.
*ModeNormalization*

Laser module, thickness map — Thickness
How much mesh lies behind each point. For subsurface and thin-edge masks.
*Max Occluder DistanceSecondary Rays*

Laser module, height map — Height
How far the high poly sits above or below the low poly. For parallax and raised-detail masks.
*Normalization*

Laser module, bent normals map — Bent Normals
The most open direction at each point. Gives occluded lighting that follows the light.
*Secondary Rays*

Laser module, lit with the baked maps — All together
The low poly lit with its baked normal, AO and curvature.
*One job*

Opacity, the tenth map, is white where the high poly covers the low poly and black where a ray found nothing. For cards that carry hair, leaves or fences. On a solid model like this it is plain white, so it is not shown.

Baking Basics

What happens when you press Bake.

What is baking?

Baking moves the surface of a high poly onto the UVs of a low poly. The low poly stays light enough for a game; the maps make it look like the high poly.

On this red dot sight, 483,928 triangles become 4,798.

Red dot sight, high poly — **Red dot sight.** Low poly + NexBake normal, AO and curvature.

Red dot sight, low poly wireframe — **Red dot sight.** Low poly + NexBake normal, AO and curvature.

Normal maps

A tangent-space normal map stores, per texel, which way the high poly faces compared with the low poly. Light then reacts to grooves and bevels the low poly does not have.

The sight's lid has no rings in the low poly. They come only from the map.

Sight lid, high poly with rings — **Sight lid, close up.** The same low poly, before and after the normal map.

Sight lid, smooth low poly — **Sight lid, close up.** The same low poly, before and after the normal map.

Projection and the cage

For every texel NexBake casts a ray from the cage, back through the low poly, and keeps the first high poly hit. Too small a cage misses detail further out; too large lets rays reach a neighbouring part.

Show Cage draws the cage over the model; orange marks where the high poly leaves it.

Muzzle. The cage grows out of the low poly, the rays go in, the bake sweeps on.

Tangent space: OpenGL or DirectX

Normal maps come in two conventions. The only difference is the green channel: OpenGL reads green up (Blender, Maya, Unity), DirectX reads green down (Unreal, 3ds Max).

Read with the wrong one, every bevel lights from the wrong side. Set Normal Map Format to match your engine.

Laser normal map, DirectX — **Laser normal map, the same UV area.** Both baked by NexBake; DirectX flips the green channel.

Laser normal map, OpenGL — **Laser normal map, the same UV area.** Both baked by NexBake; DirectX flips the green channel.

Match by name

With Match: Always every low poly sees every high poly, so parts that sit close together project onto each other. Here the cable is baked into the body under it as a black shadow.

By Mesh Name keeps each part to its own high poly, with nothing exploded apart.

Laser AO baked by mesh name — **Laser module, ambient occlusion.** Where the cable lies on the body.

Laser AO baked with Match Always — **Laser module, ambient occlusion.** Where the cable lies on the body.

Best Results

The settings that matter most, and what they change.

Antialiasing

Several samples per texel, averaged. It matters where a sharp edge crosses the texel grid: without it a groove turns into a hard, broken stripe.

Subsampling 4×4 is a good default; 8×8 for final bakes.

Scope normal map texels, antialiasing 4x4 — **Scope normal map, 2048 px.** The same few texels of one groove, enlarged.

Scope normal map texels, no antialiasing — **Scope normal map, 2048 px.** The same few texels of one groove, enlarged.

Resolution and detail size

A detail needs a few texels to show. If it is thinner than a texel, it blurs away; raise Output Size or give the part more UV space.

Scope normal map at 1K — **Scope normal map, AA 4×4.** The same UV area at 1K, 2K, 4K and 8K, enlarged.

Scope normal map at 2K — **Scope normal map, AA 4×4.** The same UV area at 1K, 2K, 4K and 8K, enlarged.

Padding

Mipmaps blend neighbouring texels. If the space around a UV island is empty, its edge turns dark from far away. Dilation Width grows every island outward to stop that.

At export, Padding decides what fills the rest: Average (default), Infinite, Diffusion, Flat Color, Transparent or None.

MainBody normal map with 32 px dilation — **MainBody normal map, one UV corner.** Dilation Width 0 vs 32 px.

MainBody normal map with no dilation — **MainBody normal map, one UV corner.** Dilation Width 0 vs 32 px.

Ambient occlusion rays

More Secondary Rays, less noise. 64 is the default; past that the map changes little.

Scope lens AO with 8 rays — **Scope lens, ambient occlusion map.** 8, 64 and 256 rays, texel for texel.

Scope lens AO with 64 rays — **Scope lens, ambient occlusion map.** 8, 64 and 256 rays, texel for texel.

Check the coverage

After a bake, NexBake counts the texels whose rays found no high poly, and warns you with the number. Most of the time the cage is too small: raise Max Frontal Distance and Max Rear Distance and look for orange with Show Cage.

Muzzle normal map with a cage of 0.0005 — **Muzzle normal map.** Max Frontal / Rear 0.01 vs 0.0005 (relative).

Muzzle normal map with a cage of 0.01 — **Muzzle normal map.** Max Frontal / Rear 0.01 vs 0.0005 (relative).

Hard edges and UV splits

Make edges sharper than about 90° hard, and cut the UVs along every hard edge so each side gets its own pixels. Keep round shapes smooth.

Export the low poly with the same normals you baked with. If your engine splits quads its own way, triangulate the low poly before you bake.

NexBake vs Blender's own bake

The same part, the same 4096 px, the same cage, the same GPU (RTX 3080). Blender's baker (Cycles, Selected to Active) has no match by name, so neighbouring parts project into each other: the yellow and green patches.

Laser normal map baked by NexBake — **Laser module, close up.** The normal map on the model.

Laser normal map baked by Blender Cycles — **Laser module, close up.** The normal map on the model.

4096 px · normal + AO	Normal	Ambient occlusion	Total
Laser · 26 parts
Blender Cycles (16 / 128 samples, OptiX)	130.43 s	143.22 s	273.65 s
NexBake (AA 4×4, 64 AO rays)	one job: both maps		5.70 s
MainBody · 25 parts
Blender Cycles (16 / 128 samples, OptiX)	78.60 s	88.21 s	166.81 s
NexBake (AA 4×4, 64 AO rays)	one job: both maps		4.27 s

Wall-clock times from the logs, run one after the other on an idle GPU.

Bake it yourself.

NexBake for Blender. Every map on this page, in one job.

Back to NexBake