Interview with a Tech Artist: The Real Job Behind the Asset Spec Sheet

Who This Is For

If you think a technical artist is just a 3D artist who can script, you're wrong. We're the ones who turn a concept artist's dream and a programmer's constraints into a playable reality. We're the bridge, and we're not just about making things look good; we make them run. This guide is for the artist who's tired of being told "that's too heavy" and wants to be the one setting the limits. It's for the modeler who wants to understand why your 15,000-triangle character is a problem, and the texture artist who wonders why their 4K albedo is overkill. It's for anyone who wants to speak both art and code.

Start with the Budget, Not the Art

The first thing I do on any project is sit down with the leads and hammer out the asset budget spec sheets. This is the contract between art and engineering. A typical LOD0 character might be around 15,000 triangles with a 2048x2048 texture set and 2-3 draw calls, scaling down through LOD3 to 800 triangles (gamesindustry.biz). But those numbers are just a starting point. You need to know your target platform's limits before you even open ZBrush. For mobile, Unity's own guidance is to spend your polygon budget on the silhouette and large forms, not tiny details that'll be lost anyway (Unity mobile optimization guide). So my first step is always to define the limits: triangle counts, texture resolutions, draw calls, and the compression formats like BC7 for PC, ASTC for mobile, and BC5 for normal maps (gamesindustry.biz). This isn't bureaucracy; it's the only way to keep the game from chugging.

Don't Skip the High-Poly to Low-Poly Dance

The heart of modern game art is still the high-poly to low-poly pipeline (Game art pipeline). You sculpt a dense high-poly mesh, then retopologize a low-poly version that the engine can actually afford. The high-poly is where you put all the detail, and the low-poly is what the player sees. If you're new to this, you might think you can just decimate the high-poly and call it a day. That works for a rock, but for a character, you need clean edge flow for animation. That's where manual retopology shines. Tools like Maya's Quad Draw give you the control to place loops around joints and eyes, which is crucial for deformation (Game art pipeline). Automatic tools like ZRemesher are great for props and hard-surface, but for organic characters, you'll want to guide it with curves or do it by hand (ZBrush). Don't rush this step; a bad retopology will haunt you in the animation phase.

UVs Are a Battleground, Not an Afterthought

Once you've got a clean low-poly, you have to unwrap it. UV unwrapping is the art of flattening a 3D surface into 2D shells so you can paint textures (Game art pipeline). It's a constant battle between texel density and texture distortion. You want to maximize the use of your 2048x2048 texture, which means you need to pack those shells efficiently. And here's a tip: always keep in mind what the asset is. A hero character needs more UV space than a background prop. I've seen artists spend hours on a beautiful unwrap, only to realize they've wasted half the texture space on a flat surface that could have been a single quad. Plan your seams based on where the camera will look and where the geometry bends, not just what's easiest.

Bake Everything, Trust Nothing

Baking is where the high-poly detail gets transferred to the low-poly mesh via normal maps and ambient occlusion (Texture baking). It's a process that can make or break your asset. You need to make sure the low-poly is UV-unwrapped and the high-poly is properly positioned. Then you bake, and you check. And you check again. A common mistake is to bake with the high-poly intersecting the low-poly, which causes ugly artifacts. I always do a test bake early on, even before I've finished the high-poly, to make sure the cage is working. And remember, normal maps are a lie—they fake relief by storing per-texel surface directions (Normal mapping). They're great, but they're not geometry. Use them wisely, and don't rely on them for sharp, hard edges that need to catch light correctly.

PBR Is the Law, But It's Not Simple

When it comes to texturing, we're all in the PBR world now. Physically Based Rendering became mainstream after Disney's principled shading model in 2012, and by 2014, Unreal and Unity had adopted it (Physically based rendering). That means we use maps like albedo, normal, roughness, metallic, and ambient occlusion (Game art pipeline). Substance Painter is the industry standard for painting these directly on the 3D model (Adobe Substance 3D Painter). But PBR isn't just about slapping on a few maps. You need to understand the physical properties of the material you're simulating. A red plastic and a red metal might have the same albedo, but their roughness and metallic values are completely different. And don't forget about Substance Designer for procedural materials—it's a node-based tool that lets you create parametric graphs for base color, normal, roughness, and more (Adobe Substance 3D Designer). It's a huge time-saver for tiling textures and variations.

The Engine Is Your Final Judge

You can have the most beautiful asset in the world, but if it doesn't run in the engine, it's worthless. So, you bring it into Unreal or Unity and you test. This is where you see the real cost of your art. Unity has a few tricks to optimize draw calls: static batching, dynamic batching, GPU instancing, and the SRP Batcher (Unity Manual: Draw call batching). But dynamic batching only works for small meshes of roughly 225-300 vertices (Unity Manual: Draw call batching). So, if you have a prop with 500 vertices, it's not going to batch dynamically. That's when you need to think about combining meshes or using LODs. Unreal 5's Nanite is a game-changer—it lets you import film-quality meshes with billions of polygons and streams them in real time, removing the need for LODs and normal maps (Unreal Engine documentation). But Nanite isn't for everything; it's heavy on memory, and it's not ideal for deformable characters. So you still need to know the old-school LOD techniques.

What Can Go Wrong: The Spec Sheet Is a Living Document

Here's the warning: the asset budget is not set in stone. It's a starting point, and you'll need to adjust it as you go. A character that looked great at 15,000 triangles might need to be 12,000 when you realize you have 10 of them on screen. The worst thing you can do is treat the spec sheet like a law and refuse to budge. Instead, you need to be a negotiator. You need to understand the performance impact of every triangle and every draw call, and you need to communicate that to the art director and the lead programmer. And sometimes, you'll have to make the call to sacrifice a bit of visual fidelity to keep the frame rate stable. That's the job.

Sources

• Game art pipeline (Wikipedia) - https://en.wikipedia.org/wiki/Video_game_art_design
• Technical artist roles (gamesindustry.biz) - https://www.gamesindustry.biz/technical-art-roles-what-they-are-and-how-to-get-one
• Unity mobile optimization guide - https://unity.com/how-to/mobile-game-optimization-tips-part-1
• ZBrush (Maxon official) - https://www.maxon.net/en/zbrush-for-ipad-key-features
• Unity Manual: Draw call batching - https://docs.unity3d.com/6000.3/Documentation/Manual/optimizing-draw-calls.html
• Unreal Engine documentation (Epic Games) - https://dev.epicgames.com/documentation/en-us/unreal-engine/nanite-virtualized-geometry-in-unreal-engine