Sign In Sign Up
Tutorials

Stop Baking Normal Maps in Unreal Engine 5: A Field Report

Nanite changed everything. Are you still baking high-poly detail onto low-poly meshes? Here's why you might not need to, and when you absolutely should.

By The Art Pipeline Desk September 03, 2026 0 views Calculating...

For years, every tutorial and technical artist told you the same thing: sculpt high, retopo low, bake normals, and pray your draw calls stay under budget. I've repeated that mantra myself. But here's the contrarian truth: if you're building for Unreal Engine 5, you're often wasting days of your life on a workflow that Nanite has made obsolete. The advice that ruled game art for two decades — that you must bake high-poly detail onto a low-poly mesh to survive real-time rendering — is now conditional, not absolute. In this field report, I'll walk you through a realistic scenario where I'd tell you to ditch the bake, and another where I'd insist you keep it.

Why the Old Pipeline Is No Longer the Only Pipeline

Let's rewind to set the stage. The classic game art pipeline is a high-poly-to-low-poly affair: you block out, sculpt a dense mesh, retopologize to a low-poly game mesh, unwrap UVs, bake detail, and texture (Game art pipeline). That sequence exists because real-time engines historically couldn't handle millions of polygons per character. You had to fake it with normal maps and LODs. But Unreal Engine 5's Nanite virtualized geometry imports film-quality meshes containing hundreds of millions or billions of polygons, streams and scales them in real time, and removes polygon budgets, draw count budgets, and the need to hand-author LODs or bake normal maps (Unreal Engine documentation). That's not a small feature; it's a fundamental shift. If you're not using Nanite, you're still stuck in the old world. But if you are, the entire reason for baking normal maps — to fake geometry — disappears.

Scenario One: The Ancient Temple Door

Imagine you're an environment artist on a first-person exploration game. You're tasked with creating a massive, ornate temple door. In the old pipeline, you'd sculpt every crack and rivet in ZBrush, then spend hours retopologizing a low-poly version, unwrapping UVs, and baking the high-poly detail onto a normal map. You'd then manually create LODs, because a door that size would tank your frame rate if you got too close. All that work, and you'd still see silhouette pop when the LODs switched.

Now, in Unreal Engine 5, you can import that same high-poly sculpt directly. Nanite handles the hundreds of millions of polygons, streams them in real time, and renders them at film quality without a single normal map or LOD. You skip retopology, skip baking, skip LOD authoring. The door looks exactly like your sculpt, from any distance, and your only texture is a simple albedo map with maybe a roughness map, not a normal map. That's a massive time savings. And the quality is better because you're not losing geometric detail to a bake.

But wait — what about the rest of your environment? Nanite is great for hard-surface and even organic shapes, but it doesn't automatically handle everything. You still need to texture, and you still need to consider lighting. Nanite doesn't eliminate the need for good UVs or PBR materials; it just removes the poly-count bottleneck.

The Catch: When You Can't Use Nanite

Here's where the contrarian advice gets nuanced. Nanite is a Unreal Engine 5 feature. If you're working in Unity, or if you're targeting mobile, you're not in Nanite-land. Unity's own optimization guidance tells you to spend your polygon budget on silhouette and large forms, and to use normal maps for fine detail (Unity mobile optimization guide). On mobile, you're still baking, still authoring LODs, and still counting draw calls. Unity's dynamic batching only works for small meshes of roughly 225-300 vertices (Unity Manual: Draw call batching). That's a world away from Nanite.

Even inside Unreal Engine 5, Nanite has limitations. It's designed for static meshes, not skinned characters. For characters, you're still doing the full high-to-low pipeline, because skeletal animation requires a deformable mesh with a bone hierarchy. Skeletal animation drives a character's skin with a hierarchy of bones, and you need a clean, low-poly mesh with good edge flow for deformation (Skeletal animation). You can't just bring in a million-poly sculpt and expect it to deform properly. So for characters, you're still baking normal maps, still doing retopology, and still creating LODs.

Let me make this concrete. Say you're making a character for a PC game. Your technical artist hands you a spec sheet: LOD0 at roughly 15,000 triangles, 2048x2048 textures, and 2-3 draw calls, scaling down to LOD3 at 800 triangles (Technical artist roles). That spec assumes you're baking. Nanite won't help you with that character because it doesn't support skinned meshes. So you sculpt in ZBrush, retopologize in Maya, bake in Marmoset, and texture in Substance Painter. That's the pipeline that still rules character art.

What About Lighting and Materials?

Another myth I want to bust is that Nanite and Lumen mean you never need to bake anything again. Lumen is Unreal Engine 5's fully dynamic global illumination and reflections system; it renders diffuse interreflection with infinite bounces and indirect specular reflections, and it's the default GI system in new projects (Unreal Engine documentation). That means you don't bake lightmaps anymore. But you still need to think about ambient occlusion (AO). With Lumen, you don't need baked AO maps for dynamic lighting, because Lumen calculates indirect lighting in real time. But if you're using static lighting in Unity, you'll still bake AO maps (Unity Manual: Ambient occlusion).

And textures? Even with Nanite, you need PBR maps. PBR entered mainstream game production after Disney's principled shading model in 2012, and now engines like Unreal and Unity use it (Physically based rendering). You'll still create albedo, roughness, metallic, and maybe height maps in Substance Painter or Designer. Adobe Substance 3D Painter is the industry standard for painting textures directly on the 3D model (Adobe Substance 3D Painter). But the normal map — that one map that encodes surface direction to fake detail — becomes optional for static Nanite meshes. And that's a huge deal.

My Recommendation: Rethink Your Workflow

So here's my advice, and I'm not afraid to be blunt: if you're an environment artist working in Unreal Engine 5 on a next-gen project, stop baking normal maps for static props and environments. Sculpt as high as you want, import directly into UE5, and let Nanite handle the rest. Spend your saved time on art direction and texture quality. But if you're a character artist, or if you're working in Unity or on mobile, keep baking. The old pipeline is not dead; it's just not universal.

I've seen too many tutorials that teach the high-to-low bake as a one-size-fits-all solution, without ever mentioning that Nanite exists. That's a disservice. The industry is shifting — Unity's 2024 Gaming Report found that 62% of studios already use AI in their workflows, and that percentage will only grow (Unity 2024 Gaming Report AI coverage). But AI isn't the only change. Nanite and Lumen are rewriting the rules of real-time art. If you're not adapting, you're spending hours on work that doesn't need to be done.

Let me give you a concrete example from my own hypothetical studio. We were building a city block for a game. In the old pipeline, we'd have modeled a few hero buildings in high poly, baked them down, and used instancing to fill the block. With Nanite, we scanned photoreal buildings using Quixel Megascans — a library of over 10,000 photogrammetry assets that Epic made free for Unreal Engine (Quixel Megascans). We dropped them directly into the scene, no baking, no LODs. The result was photoreal, and it ran at 60 FPS. That would have been impossible before UE5.

The single most important thing to remember? The game art pipeline is not a set of rules; it's a set of tools. Learn the classic high-to-low workflow, because it will serve you for characters and mobile. But don't be afraid to abandon it when the engine you're using gives you a better way. The best artists are the ones who know when to break the rules.

Sources

Share this article:

Tags:

#Game Art #Unreal Engine 5 #Nanite #3D Modeling #Texturing

Comments (0)

No comments yet. Be the first to comment!

Related Articles