Creating a Game Character

Game Development

Today we are going to review the process of creating a game character for the game engine. The article is mainly addressed to those being interested in the process of the NextGen models development. But it will be also interesting for those wanting to have a look at the backstage of the modern game development. I created the character for a portfolio. I guess this character is the first one I brought into shape. Since this is my own project, I have set a 20 000 limit for triangles and a 2048*2048 limit for the texture. This project has been planned for PBR.


To begin with, let’s take a look at the approximate pipeline. A pipeline, or a production sequence of creating graphic content, can differ from company to company and from actor to actor. We are going to take a look at the pipeline I used, except for the first two points, as I took a ready concept as the basis, and the last two ones.

  1. Description
  2. The Concept
  3. Modeling/Sculpting of basic forms of a High Polygonal model (HiPoly)
  4. HiPoly model Retopology (creating finishing HiPoly geometry for detailing)
  5. Detailing the HiPoly model
  6. HiPoly model Retopology (creating a game LowPoly that will be used in the engine)
  7. Unwrapping LowPoly (creating texture coordinates)
  8. Baking Maps: normal maps, ambient occlusion, color map (transferring information from HiPoly to LowPoly)
  9. Creating textures: Diffuse, Specular, Gloss, Normal
  10. Rendering in the engine
  11. Character’s rig and skin (rigging the skeleton and attaching to bones of the mesh)
  12. The Animation

The Concept

Enough of boring lists. Let’s take a look at the creation process in details.

I found the concept on the Internet and wanted to make it in 3D. But I discovered later that this character had been created in 3D more than once.


I did not give up the idea anyway. I just decided to change some things and not repeat the concept in all details. First of all, I decided to sculpt a model entirely in ZBrush. It’s a great tool allowing to “sculpt a model”. It differs greatly from other 3D tools that allow affecting a model via vertices, edges and polygons. ZBrush provides a brush with various attributes. Even using a tablet, we can perform quite precise operations, like a sculptor or a clay artist. At the initial state, the Brush helped me to avoid mistakes regarding basic masses and proportions. Even having a simple model, I could change proportions and look for detailing variants. It turned out that sculpting hard surfaces (non-organic objects in modeling) is not an easy task at all.


Though the model was quite rough, the idea was shaping and overall progress kept moving on.

After several search iterations I found an appropriate shape.

HiPoly Model Retopology

When it seemed that the model was ready for retopology, I used other applications for creating finishing geometry and sculpting: Topogun and 3dsMax. Retopology lies in building a mesh of one model atop of another one.

Most 3D graphics tools, such as ZBrush and 3dsMax, allow applying Retopology. Though some people use it in ZBrush, Retopology is not really handy and functional. TopoGun is a tool created for Retopolgy. It has plenty of advantages over all-in-one editors. But it also has some drawbacks. After using it for hours, I thought about dozens of improvements, but who cares? :) The most important drawback lies in lacking a decent auto backup and that the application crashes pretty often. The new topology main peculiarity was the fact that it was meant for smoothing (Turbosmooth). Therefore, there are almost no triangles. I tried to use quads (quadratic polygons).

Here is an example of the new mesh next to the old one:

I fixed all the bugs with 3dsMax and made geometry pure. Retopology has been long and exhausting. I exported each detail from ZBrush and worked with it in Topogun. Then moved it to 3dsMax, corrected it there and imported it back to Zbrush. Some parts of the model were created right in 3dsMax (for example, knee wraps).

In the end, the model was almost retopolized into a new and clean mesh and uploaded to Zbrush.

That’s how a retopolized mesh in ZBrush looks like.

Final Detailing

Exhausted by the process of Retopolgy, I was happy to turn to the model detailing. It’s quite simple. I increased the number of the model polygons and added new details with brushes. But when there were more than 12 million polygons, the computer started hanging a bit and it was quite irritating.

Finally, the model looked like this:

Retopology. Creating LowPoly

It’s time to make a mesh to use it in real time renders (game engines). And again, I worked in TopoGun and sometimes used Max to fix some geometry bugs. Since the work was for the portfolio, I used plenty of triangles. At this stage, I was trying to bake Normal map to see, whether details are transferred properly. That’s when I realized that TopoGun was not that good. Therefore, I used 3dCoat for the next project. But that is another story…

That’s how the new mesh looks like:

I gathered the LowPoly model in Max. Now, it’s time for Unwrapping UV.

Creating Texture Coordinates

Till now, there was no need in texture coordinates. However, after preparing the LowPoly model, we should create proper UV coordinates to bake maps and make it possible to texture the model. I made the UV in 3dsMax. I think this editor is quite handy. I used to try other tools, but after getting familiar with UV editor in 3dsMax, I realized that it’s quite powerful.

A proper unwrapping guarantees a simple and correct texturing and building normal maps. It can also affect the quality of textures.

That’s how UV pieces layout looks like.

Baking Maps

In the given case, baking maps lies in transferring information from the HiPoly model to the LowPoly texture. I baked with the help of xNormal. It’s a great tool that is baking way much better than all-in-one programs. I baked a normal map (tangent space normal map) (the information about the relief of the surface that adds fake detailing to the model) and ambient occlusion (a self shadowing map). I got the cavity map from the ambient occlusion, as well as object space normal map with the help of xNormal utility from the tangent space normal map.

And that’s how the model looks like with a normal map and ambient occlusion. The engine is Marmoset Toolbag. There are also some baking bugs that have been fixed in Photoshop.

Creating Textures

Now, when the maps are ready, it’s time to prepare diffuse, specular and gloss maps. Diffuse, normal and spec maps used to be enough, but now PBR allows creating glossiness effects, not only the information about the strength of reflection. There is this great plugin for Photoshop. It simplifies all the maps creation and editing. Its name is dDo. It’s a great tool allowing to control several parameters of a map via masks. By the way, it was my first time using it in the pipeline. This plugin allows adding various surface effects parametrically. We can add such effects as shabbiness, stains and mud. The tool has been quite useful for this project. Having generated all the basic texture details, I finished it off manually in Photoshop.

The texture resolution was 4096*4096. The Photoshop file weight was 6Gb. And again, I was extremely grateful to my fast operating PC :)

Finally, I created the textures:


It’s high time for the final render! Actually, it’s a preview of textures. I did not upload the model to a real (UDK, Unity3d, CryEngine) engine. It may be necessary to execute some tuning of textures for each engine, as well as setting, location and an individual color scheme of a game.

Then we would have to make a rig for the model and attach the mesh to the skeleton. After that, we would animate it and pose it in an interesting way. Anyway, I’ll tell you about it some other time.

Actually, that’s pretty much it. Thank you for reading my article. You are most welcome to share your feedback in case you are interested.

P.S. If you have some comments regarding authenticity of the armor, you should not forget that the art component is more important than functional and authenticity. But there’s no doubt that, ideally, all of that should match.



Ropes — Fast Strings

Most of us work with strings one way or another. There’s no way to avoid them — when writing code, you’re doomed to concatinate strings every day, split them into parts and access certain characters by index. We are used to the fact that strings are fixed-length arrays of characters, which leads to certain limitations when working with them. For instance, we cannot quickly concatenate two strings. To do this, we will at first need to allocate the required amount of memory, and then copy there the data from the concatenated strings.