NORMAL_FEATURE

Normal Map Baking in Blender 2.5

Creating normal maps from a high resolution model is a common task in a game developers work flow. It can add an extra level of detail that otherwise would be impossible within a game environment. Today I will be showing you how to create normal maps in Blender 2.5. The process used to do this is called “baking”, it enables us to project all of the detail from a high resolution model onto a low resolution, or lowpoly game model to create the normal map. This is a relatively painless process that can be done quite quickly once you have the know-how. Let us begin!

Note: Normal map baking requires a recent version of Blender 2.5, which can be downloaded from http://graphicall.org forĀ all operating systems. Baking is broken in the official Blender 2.5 alpha 2 release.

Part 1 – Preparing the models

The first step to creating normal maps, is to prepare the models. This primarily involves UV unwrapping the lowpoly model. Before doing that, though, let’s take a look at the models we will be using today in figure 01-02:
01

Figure 1
02

Figure 2

As you can see, we have a highpoly model of a statue, with a large amount of detail, much more than could feasible be used in a game. Then we have a lowpoly version of the same model. To bake the normal map, we must first unwrap the UVs for the lowpoly (the highpoly has no need for UVs and may be left as is) then we need to assign a blank image to those UVs that will become the normal map.

To unwrap the lowpoly: enter Edit Mode by pressing TAB while the lowpoly model is selected

2. Select the vertices shown in figure 3 then press CONTROL + E > Mark Seam

3. Repeat this step for the vertices in figure 4, ensuring the selection starts at the previous seam and continues all the way down to the bottom of the model.

03
Figure 3

04
Figure 4

You should now have all of the necessary seams placed to cleanly unwrap the model:

Select all of the vertices that make up the model by pressing A (you may need to press it twice if you previously had anything selected) then press U > Unwrap

2. This will unwrap the UVs of the model, to see them switch your viewport window time to the UV/Image Editor as displayed in figure 6

05
Figure 5

06
Figure 6

07
Figure 7

You now need to add a new image to the UVs simply by pressing the “New” button. If you need to adjust the size of the newly created image immediately press F6 and modify as needed.

Part 2 – Baking the normal map

Let us now bake out the normal map by switching back to the 3D View and then going to the Render Properties:

First select the highpoly model with RMB then select the lowpoly model with SHIFT + RMB

2. Toggle down the “Bake” options under the Render Properties

3. Change from “Full Render” to “Normals”

4. Switch from “Camera” space to “Tangent” space

5. Ensure “Selected to Active is checked

6. Press “Bake”

Upon completion of the bake, you should see the normal map displayed in the UV/Image Editor.

08
Figure 8

09
Figure 9

10
Figure 10

11
Figure 11

12
Figure 12

That is all it takes to bake normal maps! It is really quite simple, Blender does most of the work for us. However, in order to really see the fruits of our labor we are going to take it a step further so we may view normal map in real time.

Part 3 – Viewing the normal map in real time

The way we are going to do this is by adding a material to the lowpoly model that will contain the normal map and tell Blender how to use it:

Begin by adding a new material to the lowpoly model, name it if you wish

2.Switch to the Texture panel and add a new Image texture

3. Select the normal map from the buffer as the image source

4. Check the “Normal Map” box and change the space type to “Tangent” from the default “Camera”

5. Change the Image Mapping type to UV

6. Uncheck the “Color” box under the “Diffuse category of Influence

7. And finally check the “Normal” box under the “Geometry” category of Influence

13
Figure 13

image014
Figure 14

15
Figure 15

image016
Figure 16

image017
Figure 17

image018
Figure 18

Now we are almost ready to see the normal map in action. All that is necessary now is to change the viewport rendering method over to GLSL for real time shading.

Press N while hovering your mouse over the Viewport to bring up the Viewport Properties

2. Scroll down to the “Display” category and change the “Shading” method to “GLSL”

3. Select the highpoly model and press H to hide it, allowing us to see the lowpoly model properly

4. Press ALT + Z to turn on GLSL shading

image019
Figure 19

image020
Figure 20

You should immediately see a result. If everything is correct, you should see the normal map applied to your lowpoly model in real time. Be sure that you have at least one light in your scene or you will not see anything. Speaking of which, if you move the light around in your scene you will see the lighting change on your model. The normal map is being displayed in the viewport just as if it were in a game.

That is it! You have now baked a normal map in Blender 2.5. Once you have become accustom to the process, it can be done in under five minutes. This is a very useful feature and works remarkably well. If you find your normal map are receiving artifacts then it may be necessary to tweak some of the settings under the Bake panel. I will not get into that today. For the time being, enjoy and happy baking!

image021

Figure 21

image022

Figure 22

image023

Figure 23

Leave Comment

Discussion

59 Responses to “Normal Map Baking in Blender 2.5”
  1. Posts: 1
    Paul says:

    Thanks Jonathan. Two things that weren’t clear in your tutorial that had me pulling my hair out before I finally had a successful bake:

    1. Select the high poly version then shift-select the low-poly ‘target’ before baking. (You did answer this in the comments) – this solved my repeated “no image or object selected errors” that many folks have had.

    2. IMPORTANT – nobody else has mentioned this but once I solved the above error my bakes were blank until I placed both my high poly and low poly models at exactly the same world coordinates, e.g. 0,0,0 and 0,0,0 so that they are visibly overlapping/merging in the viewpoint. This makes sense once you realize that the baking process is determining the difference in normal positioning, direction between the two models. When they were coming out blank, I had my two models side by side.

    • Posts: 3784

      Hey Paul,

      My apologies for not making those points clear in the video. As you’ve discovered they’re absolutely vital to getting Blender to bake. It’s good to hear you were able to get them resolved, though :)

  2. Posts: 2
    apm designs says:

    Nice tutorial with a good use of image illustrations. Been trying to improve my texture map baking for gaming.

    Thank you

  3. Posts: 3
    Dan Han says:

    Can I still have suburf on my low poly model when I bake?
    Do I need to apply all modifiers (mirror, subsurf,edge split) then I bake either of them?
    Thanks

  4. Posts: 5

    That’s a great explanation.

    I think it’s important to note that, ideally (and I really mean ‘ideally’ – it rarely works this way in practice), your low-poly mesh should be entirely outside your high-poly mesh. The way baking a normal map works is that rays are cast from the inside of your target mesh to the outside of your source mesh, and then the normal of that point on the source mesh is written to the normal map. If your source mesh is outside your target mesh at any point, it won’t write any normal data for that point and will fall back on the normals of the target mesh.

    Usually when you’re retopologising, you set your low-poly mesh to snap to the surface of your high-poly mesh, which is good because you obviously want the same shape (that’s the whole point, after all), and because normal maps work best on two objects of similar shapes, but it does often cause your low-poly mesh to clip through the high-poly at places, which isn’t good for baking a normal map. I’ve found that the bias setting alone doesn’t take care of that satisfactorily. Maybe I just don’t have the patience for finding a good bias level, but if it’s too low you get jaggies from your low-poly mesh, and if it’s too high you get a flat normal map that loses the detail. A good way to get around this is to use a shrinkwrap modifier on your low-poly mesh to make sure that most of it is above your high-poly (using the “keep above” checkbox) and then just use a little bit of bias to handle the rest.

    I can’t wait for 2.71 when Cycles can bake, too (up to 2.70 it’s only available with Blender Render). Well, obviously I can wait, otherwise I’d be using the testbuild right now, but I’m looking forward to it. Looking at the documentation, it seems that the actual act of baking a normal map will work pretty much the same in Cycles as it does in BR. Obviously then applying the normal map to your model is a little different, but if you’re familiar with how Cycles materials work, it’s fairly self-explanatory.

Leave a Comment

You must be logged in to post a comment.