What is baking? in layman's terms

Hey everyone, I’m reasonably settled into blender but there are some concepts that I want to know more about, one being baking.

I read in a another tutorial that baking can be used to “bake a light into a model”, which supposedly saves processing power in games or something to that description. But what is baking exactly? because I’ve heard that it applies to textures, animations and a lot of other things. can anyone explain this is layman’s terms? :spin:

When you shine a light on a material, it makes it brighter in the areas that the light hits the surface. This normally takes time to calculate and renders are slow because they are processing where the light rays are falling, which parts of the surface fall into shadow etc.

Baking lights… would be painting the shadows directly onto the surface so that when you take the light away, the surface itself still looks as though the light were shining onto it.

Is that a process in blender? Or do you mean drawing the shadows onto the texture

You asked me to explain in laymans terms, but yes, there is a process in Blender to do it. If you are using a UV mapped texture, then you can position the lights in the scene and instead of render, opt to “bake” the lighting. This will perform a render as normal, but then update the texture maps so that the lights / shadows (etc) are printed directly onto the surface. It’s essentially a new texture.

thanks, It’s exactly what I was looking for. That will definitely help. does it save as an image like the rest of the textures, like say a specular map?

There’s a lot of variation of what it can be used for. Normal maps are a prime example of baking; you get two meshes - one low detailed and unwrapped, the other high detail, and then you bake not the lighting, but the “normals” of the high mesh (that is , the direction of the faces) to the low mesh. This results in an illusion of the low poly having detailed textures… it’s a bit to get your head around at first and it’s easier to start of just thinking in terms of mapping light and shadow.

In terms of saving, the baked map tends to replace the UV map you are baking to.

Edit: I thought I’d attach an example of a finished bake. Here, I have baked the normals of one mesh (the Suzanne monkey) to the UV map of another mesh, the cube. The result is that it looks as though I have modeled Suzanne into the surface of the cube. I could have baked the colour of the mesh, or any other rendering property, though I just chose “normals” as these make a bump map for the effect you see here. Normal mapping is a pretty extreme example though. If you are just getting to grips with baking, think of it as the ability to paint the UV map (surface) of a mesh as based on other object. I hope this normal map example doesn’t confuse you… it’s probably not the best example to show straight up.

baked_UVmap.blend (364 KB)

If you have GLSL (most do - can see shadows in 3D view) when you move the lights around, or rotate the cube, the baked normal map will act just like real bumps. (If you do not, just hit [F12] to render). The “baking” is the process I used to create the bump map.

You’ll also run into the term “bake” in regards other processes. In general it means putting into a fixed, recorded form some property of an object or a rendering or a process that is otherwise done dynamically, on the fly so to speak. For example, if you “Bake” a particle system, a cache of data is created for Blender to access rather than having to re-calculate all the particle positions over and over again. Baking certain kinds of lighting effects like AO or normal maps saves the processing time needed to re-calculate these with every rendering. Saves a lot of processor overhead to bake when possible.


I’m thinking that the Normal Maps as an example are likely to be somewhat confusing for Captain Dando who wanted a simple definitions in layman’s terms. Good though it is, if I didn’t know what normal maps are already, I’d have been lost in the video at around 2:30 when he starts explaining surface normals with jagged lines and arrows.

Perhaps a simpler example might be what I mentioned earlier; baking light & shadow onto a surface. Here it is:

bake_shadow.blend (1.02 MB)

In this example, the shadows on the floor are completely fake. They are painted onto the floor surface (I baked them there) and I then turned shading off for the floor material so that real shadows no longer affect it and you only see the painted on shadows; notice that if you move the objects around, their real shadow position does not affect the floor. In fact, I have completely moved the lighting away from the scene (the original lights have been hidden out of the way on layer 2). Therefore, the non-baked objects have no lighting and currently show up completely dark in the F12 render… I could simply move the lights back to layer 1 if I wanted to manually light them but of course the point to me doing this is to eliminate lighting and thereby reduce render time.

But yes - as you can see, this is an example of a baked on shadow (baked on to the ground surface as if painted there.)

Perfect. Thanks lancer, I appreciate the effort you’ve put into teaching me this.

Say i was to use a simple cube,then color it read under the materials tab theb shine a light on it then bake…would it do that for a non textured/ non uved objects

It’s a good question. Like chipmasque said, the term is used for all sorts of stuff.
And I don’t know if I’ve ever heard a good comparison to actually baking a cake or pie. Even if the choice of word does make sense.

When it comes to animation, you can bake results from complex rigs into simple twists of the basic bones. Mostly so you can translate animation based on software-specific rigs into data that can be used in games, or is supported by standardized file formats.

npm1 - the object needs to have a UV map, but the target-image of the bake doesn’t need to be assigned to any texture. But the image has to be active in the UV editor - which can be annoyingly challenging.
Baking (textures) in Blender is very close to being trivially simple, but kinda stumbles on the finishing line:P

It could be explained simply as Rasterization: going from model/vector-> raster.