Dev Log: Moonlight Peaks' 3D Character Pipeline

Moonlight Peaks features a wide range of characters, and we iterated on the development process extensively—undergoing a significant style shift along the way. In this dev log, we’ll walk through that process, our 3D pipeline, the PBR (Physically Based Rendering) workflow, and the various lessons we learned throughout development. It’s already been two full years, and during that time, the characters have gone through many iterations.

In the early stages of development, we used the "lazy unwrap" method. This involves using a collection of gradients on a single texture sheet. The way this works is by planar mapping your UVs and stretching them over the gradient you want to use as a color. This is a fast method for coloring assets and worked well with the visual style we had in mind at the time.

We also set up the characters with modular body parts, allowing us to hide certain areas of the clothed model. This approach mainly helps prevent intersecting meshes when layers of clothing are placed on top of the base model.

At a certain point during prototyping, we felt that the fidelity of the art we were creating with the Lazy Unwrap method had reached its ceiling. We weren’t too far along in the project yet, and since we were still pitching the game to publishers at that stage, we decided to overhaul the game using the PBR pipeline. We needed more “oomph” in our visuals if we wanted to stand out.

That shift also brought a redesign of the main character—something that, in hindsight, became a major learning experience. We hadn’t fully realized that the people already following the project had grown attached to the old, chibi-style design.

As you can see below, the new character design became more adult and doll-like in appearance, which somewhat removed the cute and exaggerated charm of the original.

At Little Chicken Game Company, we tend to be very open about our development process on social media. So, we posted the new character design, hoping people would love it. Unfortunately, the response wasn’t quite what we expected.

The main takeaway was that the character had lost much of the “cuteness” that fans loved about the original design. In the end, we felt both an obligation—and a new opportunity—to listen to the community. We decided to redo the character, bringing it closer in spirit to the original design while still working within the PBR pipeline. It was time to go back to the drawing board.

The final iteration is what we’ll be looking at in more detail. Still wondering what “PBR” (Physically Based Rendering) actually means? Don’t worry—walking through each step should give you a good idea of how this approach is used in video game development.

The Process

The main 3D program we use for character work is ZBrush. It’s a fantastic tool for creating organic shapes quickly, and it's the industry standard for sculpting high-detail models. Every one of our 3D assets goes through a detail pass in this program.

A fast way to set up a base mesh for a new character is by starting with ZSpheres in ZBrush. Think of them as a quick, rough skeleton—spheres connected to each other that you can manipulate into a general shape. To give you an idea:

On the left side of the image, you can see the final ZSpheres setup. On the right is the resulting base mesh, which has been sculpted and refined into a final high-poly version. This time around, we made sure that all the proportions align with the original character design.

In Moonlight Peaks, we’re working with a genderless body type, meaning any clothing set, hairstyle, or other character attachments must be compatible with the same base mesh. This makes the modeling process highly efficient, as we can reuse the same character template across all designs.

From here, we begin blocking out clothing and hair, which is relatively straightforward. We mask out the base shapes we need, based on concept art—often for NPCs, for example. The result looks something like this:

The hair in the image above has already been sculpted, but to illustrate what I meant by masking, take a look at the image on the left. In the right image, those black masked areas have been extracted to form the clothing.

From there, we continue refining the model—sculpting in additional detail and shaping the forms—until we eventually arrive at something like this:

These two characters are Mina and Saga, two NPCs who are part of the townsfolk in Moonlight Peaks.

At this stage, we've completed all the detail work for this particular set of NPCs. However, we still need to implement their hair, clothing, and base body into the game! To do that, we first need to create lower-resolution versions of all these components—a process called retopologizing. Game engines can’t handle the millions of polygons used to sculpt the detailed, soft shapes of the high-poly models.

Retopology can be done in a variety of ways, and our 3D artists are free to use whichever software they’re most comfortable with. In the end, it doesn’t matter much—as long as the result is the same: an optimized mesh suitable for real-time rendering.

That said, there’s something to be said for not having to constantly switch between programs. In this example, the retopology was also done directly in ZBrush, and the process is fairly straightforward.

The basic idea is to once again make use of a ZSphere. You can append (or insert) a ZSphere and use it to edit the topology, allowing you to draw new polygons directly over the surface of the high-poly mesh.

While doing this, we keep a target polygon count in mind, as well as the fact that these meshes will need to be animated later on. With those factors guiding us, we carefully retopologize the entire mesh.

At this point, we basically have everything ready to start exporting the models from ZBrush to Blender. We usually make sure the parts are correctly named before exporting, using a convention like MinaPants_high for the high-poly version and MinaPants_low for the corresponding low-poly. It’s important to double-check for typos, as these names are later used during the baking process to transfer high-poly detail onto usable texture maps.

I won’t go into detail about the UV unwrapping process for the low-poly meshes, but in short: this is where you “unwrap” the 3D model onto a flat plane to allow for proper texturing. There’s plenty of information available on UV unwrapping, and generally speaking, the process is quite similar across most 3D applications. At this point, we switch to Substance Painter. This is the program we use to bake maps from the high-poly meshes.

There are a lot of settings involved in the baking process. One technique we often use is called “exploding” the mesh—this tells Substance Painter to bake each part individually, without accounting for nearby geometry. In simple terms, we want to avoid unwanted ambient occlusion (think of it as shadow) or intersecting details on parts that might be reused in other assets.

The resulting baked normal maps look like this:

Normal maps essentially tell the game engine how light should interact with your mesh, allowing it to mimic the high-poly details on a low-poly model using image data. The only real giveaway that the mesh is low in polygon count is when you look closely at its silhouette.

In addition to the normal map, we also generate several other maps: world space normals, ambient occlusion, curvature, position, thickness, and height maps. Using these, we create a first pass of the diffuse texture.

It’s a good idea to do a quick check of your initial values in grayscale—this helps ensure the basic forms and lighting information read well before diving into full texturing.

After that, we usually color-pick directly from the concept art to apply the character’s base colors.

We’re a small team, so to keep the pipeline manageable, we don’t go all-out with hand-painted assets— as much as we’d love to! Instead, we keep things relatively simple by using gradients, adding a few color splotches, applying colored ambient occlusion, and hand-painting some highlights to bring out the details.

In this image, you can see a few variations based on the same base body we started with. The end result is something that stays true to our original character iteration—while fully leveraging the power of the PBR pipeline.

Once we export everything to the game engine and layer in some animations, we end up with something like this:

It’s nearly impossible to condense the entire process into just a few pages, but we hope this offers some insight into what goes on behind the scenes when creating characters for Moonlight Peaks.

Bringing so many characters to life with a small team—while maintaining a high level of quality—is no small feat. We hope our current lineup meets our audience’s expectations and helps immerse them in the world and story of Moonlight Peaks when they finally get to experience it for themselves. Fortunately, the feedback on the new character this time around has been overwhelmingly positive!