BAKING THEORY

Baking is the process of transferring high-poly details onto a low-poly mesh's textures by generating texture maps like normal maps, ambient occlusion, and curvature. This lets us simulate all the high-res details while making sure that assets remain optimized without heavy geometry.

To bake, we use software such as Substance Painter or Marmoset that does all the heavy lifting and number crunching. The process works by casting rays from the low-poly model towards the high-poly. When these rays hit the high-poly surface, they capture details from the highpoly and store them in a texture map using the low-poly’s UVs. We can use different options to control how a baking software searches for details. Learn all about different types of texture maps here!

‍

IMPORTANT TERMINOLOGY

Prior to embarking on your baking journey inside your software of choice, there are some important general terms and techniques to go over. We’ll be breaking down important concepts as we go.

‍

Lowpoly Model & Highpoly Model

A lowpoly model is a simplified version of a high-poly mesh, optimized for performance while still maintaining the visual integrity (shape) of the original. By relying on baked textures rather than excessive geometry, it keeps the detail while staying efficient. If you need a refresh, we covered lowpoly modelling in this lesson.

A highpoly model is a detailed and dense mesh that provides all the detail for baked maps, with the goal of translating the details onto a more efficient lowpoly (reduced geometry) model’s textures. In essence, despite having less geometry, the lowpoly model should aesthetically resemble the high-poly after the baking process, solely through the textures. For a deeper dive, check out our lesson on highpoly modelling.

‍

Hard & Soft Edges

There are two types of edges for models: hard and soft. Hard edges create sharp transitions (like 90º angles), while soft edges make smooth ones (like a cylinder’s sides). You control this in your modelling software to get the right look, ensuring your low-poly has good shading before baking adds extra detail. See this lesson for more info!

‍

Normals

What Are Normals?

Normals are vectors (a quantity that has both a direction and a length) that tell your software or game engine which way a surface is “facing.” They are essential for shading, lighting, and baking because they control how light interacts with a model, giving the illusion of depth and detail even on low-poly meshes.

There’s a bunch of jargon that specifically relates to normals. We’ll summarize the most important parts to keep in mind!

‍

Face Normals & Vertex Normals

‍Face normals and vertex normals are two different ways of representing normal information. In practice, you either use face normals, or vertex normals.

A face normal is a vector perpendicular to a polygon (face) in your mesh. It defines the direction that face is pointing. By controlling the shading, face normals make edges appear hard, even if the geometry itself is smooth. They are simple and useful for flat shading, but as they don’t create smooth transitions between faces, curved surfaces can look faceted.

Vertex normals are averaged directions assigned to each vertex, which are then interpolated across the faces sharing that vertex. They allows for smooth shading across curved surfaces while still using low-poly geometry. Adjusting vertex normals is key for controlling smooth vs. hard transitions without changing the actual mesh.

‍

Average & Split Normals

Average and split normals are two methods used specifically on vertex normals to control shading. They are to lighting what soft and hard edges are to geometry: they control how light interacts with the surface, but they don’t influence or change the actual shape of the model. You can use both average and split normals on the same mesh, but not on the same edge or vertex. Each edge or vertex group is either averaged (smooth) or split (hard) shading.

Average normals smooth out vertex normals by blending their directions, giving cleaner bakes for edges and bevels but sometimes distorting flat details.

Split normals keep the original vertex directions, which helps maintain sharp details but can cause visible seams. Think of it like soft edges (average) vs. hard edges (split), but remember that smoothing in your modelling software and how the baker interprets it aren’t always the same.

‍

Normal Maps

A normal map is a texture that stores the normal information captured during the baking process for use on a low-poly mesh. It allows a low-poly model to simulate high-poly detail like bumps, grooves, and small sculpted features without adding extra geometry. Normal maps are the backbone of baking workflows, translating high-poly surface detail onto a more efficient low-poly model.

Learn more about maps here!

‍

Normal Format & Tangent Space Sync

When baking or using normal maps, the format and tangent space matter because they determine how the map is interpreted by a renderer.

• Normal format refers to how the RGB channels of a normal map texture store the X, Y, and Z directions of the normals. Different software or game engines sometimes expect different channel arrangements, so the map can look wrong if the format doesn’t match.
• Tangent space is a way of aligning the normal map to the surface of the low-poly mesh. It ensures that the normals from the high-poly model match the orientation of the low-poly geometry. Tangent space sync just means the normal map and the low-poly mesh are using the same coordinate system, so lighting behaves correctly.

In short, format is “how the data is stored,” and tangent space sync is “making sure the map lines up with the mesh.”

‍

Phew! That was a lot about normals.

While normals are hefty to understand, tinkering with them visually on your own will give you a better understanding of what exactly they are, how they behave, and how they can influence your pieces.

‍

Floating Geometry

‍Floating geometry are detached pieces that may be placed on top of a highpoly mesh to allow for additional detailing without actually connecting the geometry to the main surface mesh. Since these details won’t exist in the lowpoly, all that matters is that they transfer cleanly to your baked normal map. This technique saves a ton of time, makes complex shapes way easier to manage, and gives you way more flexibility when tweaking designs.

‍

Cages

A cage is basically a duplicate of your low-poly mesh, slightly expanded to fully enclose the high-poly which may have floating geometry — additional parts sticking out! It's used in baking to control how details are projected from a highpoly model onto a lowpoly mesh. It helps the baker cast rays properly, making sure all the high-poly details are captured accurately. Ideally, the cage should extend just enough to grab those details, however if it’s too big, it can cause issues, especially in tight spaces or corners, depending on the complexity of your mesh.

Both industry standard baking software like Substance Painter and Marmoset generate the cage automatically and give you control over its size, smoothing, and even allow manual adjustments (like painting specific areas in Marmoset). They also provide visualization tools to highlight problem areas, making it easier to troubleshoot baking issues.

Cages can be either smoothed or hardened, similar to how smoothing groups and hard edges work in 3D models.

You can also create cages manually by duplicating your low-poly, slightly expanding it, and tweaking problem areas to avoid intersections or errors. However, manual cages are rarely needed these days as baking tools have come a long way, and there are plenty of built-in fixes in both Substance Painter and Marmoset. Unless you’re dealing with an extremely complex object or using an uncommon baking tool, auto-generated cages will usually do the job just fine.

‍

ID Maps

An ID map is a texture that helps you quickly assign materials or masks to different parts of your model. It works by using solid colors to mark different areas, making it easy to select them when texturing. This is super useful for speeding up workflows in software like Substance Painter, where instead of manually selecting parts of your model, you can just click on the colors in your ID map and instantly apply materials. It’s especially handy when working with complex assets that have multiple materials.

‍

Seams

‍Seams represent the cuts in our model and boundaries of our UV islands. They define the edges of UV islands in a model's unwrap, and when baking, every hard edge must also have a UV seam, otherwise, you’ll get errors. However, this relationship only works in one direction: while every hard edge should have a UV seam, not every UV seam needs to be a hard edge. You can use this to your advantage when optimizing your UV layout. For example, when modelling a hexagonal nut, you can represent the sharp transitions in the highpoly while keeping all six sides of the lowpoly smooth and connected with only a single UV seam. Most modelling software includes tools that allow you to quickly assign UV seams to hard edges.

‍

Overlapping UVs

When unwrapping your low-poly, you may have mirrored or overlapping UVs to optimize texturing. For baking, make sure any overlapping parts are moved outside the packing box (offset by 1 in any direction) to prevent errors.

‍

Exploding a Mesh

This is less common nowadays thanks to the Match by mesh name option mentioned before, allowing you to control how AO affect other parts, but sometimes you’d want some parts affecting each other, and some others that don’t get affected at all. You can then explode those parts of your mesh that you want to bake separately to allow for this extra control.

Exploding a mesh is a technique to physically separate each part of your mesh, offsetting them from their original position so they are not close to each other, in order to control how AO and intersections are baked. This is usually done when you don’t want pieces of your mesh casting AO to others, for example in meshes that need to animate and therefore you can’t have baked AO in the moving parts.

‍

‍

MOST COMMON BAKING SOFTWARE

There are several popular tools used for baking texture maps in real-time workflows. While they all rely on the same core principle (projecting detail from a high-poly model onto a low-poly model) each has its own strengths, weaknesses, and ideal use cases.

Substance Painter

Substance Painter is one of the most widely used texturing tools in the game and film industries. It includes a robust baking system tightly integrated into its texturing workflow, and is ideal if you want an all-in-one solution where baking and texturing happen in the same environment.

Pros

• Industry-standard and widely supported in professional pipelines
• Very user-friendly baking interface with clear options
• Seamless integration between baking and texture painting
• Excellent preview of baked results directly on the model

Cons

• Requires a paid license
• Baking controls are powerful but slightly abstracted, offering less manual control than some dedicated bakers
• Can be heavier on system resources

‍

Marmoset

Marmoset Toolbag is a dedicated real-time rendering and baking tool known for its speed, accuracy, and visual feedback. Marmoset is often favored by artists who want maximum control and precision during the baking stage.

Pros

• Extremely fast and high-quality bakes
• Real-time visual feedback makes troubleshooting very intuitive
• Excellent control over cages, ray distances, and skew correction
• Great for complex or hard-surface assets

Cons

• Paid software
• Focused primarily on baking and rendering, not texturing
• Less suitable as a “one-stop” solution compared to Substance Painter

‍

Blender

Blender is a free, open-source 3D package that includes baking tools as part of its broader modeling and rendering toolset. Blender is a solid choice for learning, indie projects, or fully open-source pipelines, but it requires a stronger understanding of baking fundamentals.

Pros

• Completely free and widely accessible
• Integrated directly into the modeling workflow
• Capable of producing high-quality bakes with proper setup

Cons

• Baking interface can feel technical or unintuitive for beginners
• Fewer visual debugging tools compared to specialized bakers
• Setup can be more manual and time-consuming

‍

Other

Many other 3D applications such as 3ds Max, Maya, and Cinema 4D have built-in baking features enabling normal and ambient occlusion map baking without external tools.Other non-standard options you can look into include xNormal, Handplane Baker, and Knald, all of which have their own use cases. As always, research and use what works best for you and your projects!

CONCEPTS TO KNOW BEFORE YOU GET STARTED WITH BAKING

There are some good practices to keep your workflow as solid as possible, error-free and as combinient as possible for you to have an easier time with baking your meshes.

‍

Correct naming

Correctly naming pieces of a mesh is necessary for baking. Not only does it keep your scene organized and easier to understand, but it also allows the baker to match corresponding lowpoly and highpoly components when using baking features such as Match by Mesh Name. This helps prevent issues such as unwanted intersections and ambient occlusion artifacts by baking each mesh component individually.

To use this workflow, corresponding highpoly and lowpoly meshes should share the same base name, with the suffixes _high and _low respectively. For example:

• frame_high → frame_low
• door_high → door_low
• handle_high → handle_low

Consistent naming gives you greater control over the baking process and helps produce cleaner, more predictable results.

‍

Triangulating your mesh

Before exporting your lowpoly mesh for baking, it's recommended to triangulate it. Different software triangulates meshes in different ways, and these differences can sometimes lead to shading issues. A mesh that appears correct in one application may display artifacts in another due to changes in triangulation.

While good topology helps minimize these problems, triangulating before export ensures that the mesh used for baking matches the mesh used later in your pipeline, reducing the risk of unexpected shading errors.

Keep this process non-destructive by using a triangulation modifier or by saving a copy of the non-triangulated mesh, allowing you to make changes later if needed.

‍

FBX vs OBJ

A common question is which file format to use when exporting meshes for baking. As with many aspects of a 3D workflow, the answer depends on the project's requirements. However, for game assets, FBX is typically used for the final mesh, so exporting the lowpoly for baking as an FBX is generally recommended—or even using the exact same mesh that will be exported to the engine.

For highpoly meshes, the choice is more flexible since they are only used to generate baked information and are not part of the final asset. FBX works perfectly well and helps maintain consistency across files, while OBJ can also be a good option depending on the workflow. For example, OBJ is often preferred when exporting directly from ZBrush, and some baking tools, such as Marmoset Toolbag, can handle extremely dense meshes more efficiently when they are imported as OBJs.

‍

‍

CONCLUSION

Texture baking is a detailed and sometimes finicky process, and it often takes practice to get consistent, clean results. Small issues in topology, naming, UVs, or shading can have a big impact on the final bake, so understanding how all of these elements work together is key. With experience, these steps become more intuitive, and you’ll develop an eye for spotting and solving problems quickly. Follow along with our applied baking lessons to apply the concepts you've learned here to practical examples!