Teaser Trailer

Hi all! This week, we’d like to present our teaser trailer. Enjoy!

(Or watch it on YouTube)

The music in our teaser is a result of our collaboration with Berklee College of Music in Massachusetts. We’ve been working with Lisa Jeong and Courtney Clark, and we’re looking forward to implementing more of their wonderful sound design as we keep working.

Everyone else in Turnip Town is still hard at work! We’re all leaving for spring break and GDC in the next couple of weeks, so we’ll be taking a short break from blog posts, but we’ll be back very soon with more updates.

Stay dry!



Making a Texture in Substance Designer

Happy Monday! I’m Evan, and I’ve been working a lot on texturing the 3D models our other artists have been making. Texturing is the process of adding color, material,  and details to what is oftentimes a very flat or simple 3D model. Most of our textures are painted in a program called Substance Painter, but sometimes we need a texture that would be very difficult to make in Substance Painter or a texture that has to tile very well with itself (which means to repeat without any visible seams). Creating these more complicated textures can be accomplished by using another program called Substance Designer!


Substance Designer works by using nodes with different functions that all connect to one another; the graphs that get made in Designer tend to look very complicated, but they can be simpler than they seem. Each node controls an aspect of the texture.

An example of a Substance Designer node tree for a single material

A lot of the nodes go into getting the proper shapes that will be used to make the needed textures.

This graph is a pretty simple one; most of the complexity of the final product comes from getting the simple shape to repeat randomly.

FX map
If it doesn’t repeat randomly, the grass texture won’t feel organic

This was a very complicated part to put together; I had to get some help on it since the setup felt closer to coding (this particular random generator was created by Vincent Gault). Once it was done, I could use it to turn my single grass blade into a field of grass that can tile together with itself, and then other artists can paint the grass texture onto the surfaces of 3D models however they like.

grass process
Even though it’s completely flat, there’s some height information in the texture that makes the grass look 3D

After the texture was made, all was left was color, which was just some additional nodes on the graph.

grass color

And that’s a simple grass texture! Then other artists can take this texture and apply it in-game however they like!

The grass texture painted onto the level

Have a good one,



The Leads of Turnip Town


Happy Umbrella Mondays!

Margaret, Casey, and April here to talk about our lead roles while working together at Turnip Town. We’re a pretty small studio with only ten full-time members, but it still helps to have a few people responsible for keeping everything organized and running smoothly, and that’s where Turnip Town’s three leads come in! Managing and developing a 3D game with a small team has its challenges, but is proving to be a fun learning experience for everyone! 

Programming Lead

As programming lead, Casey attempts to wrangle all of the proactive programmers together and create a working build of the game when needed. The entire programming team functions as a democracy where everyone has an equal say. As a lead, the main goal is to understand the strengths and skills of those who you’re leading. With the programming team, the strengths are very different between each of the team members (Maria, Spencer, Travis, Bob, and Casey, along with the traveling help of Keenan Barber). 

At the start of development, the programming team worked together to set up rules and to define what ‘good programming practices’ were to us. We all grabbed projects we each wanted, and the lead’s role from that point on was to make sure that everyone’s projects accomplish what was needed for the latest game build, and to communicate with the art and design teams about new things that were added or things that need to change.  Lastly, the programming lead helps coordinate frequent check-ins with other programmers see what everyone’s working on and ask if anyone needs any additional support.

Design Lead

April stands on several pillows of wonderment that describes the structure of Umbrella Mondays. However, when it comes to the overall design, everyone at Turnip Town has had an influence on what is essentially the game.

The design lead is responsible for the base game mechanics, as well as the level design, working closely with programmers and artists to ensure the vision of the gameplay. Working alongside Bob Vogt, April used symbols from the fire spirit language to design the base structure of the puzzles. This lead to a dynamic layout that actually spells a word in another language while also serving the puzzle mechanics.

Programmers Travis, Casey, Maria, and Spencer work closely with April to collaborate on the final feel of each in-game mechanic such as player movement, fire spirit behavior, and menu design.

Props conceptualized and modeled by Mary, Jacob, and Evan related to level design and mechanics are approved by the design lead before they’re eventually placed into Unity. The final look of the game is taken care of by the Art Lead, Margaret Clarke.

Art Lead

We have four dedicated artists on the Turnip Town art team (Margaret, Mary, Evan, and Jake), along with April, who is heavily involved with the art team while also directing the overall gameplay design. The art team is incredibly diverse–each artist has brought a unique set of strengths and interests to the table, and the biggest part of being an art lead is figuring out how to best leverage everyone’s individual skillsets while also leaving room for team members to branch out, experiment, and learn new things.

One of the ways this shakes out for the team’s art lead is in managing the artist pipeline. A single art asset might go through multiple different artists before it finally makes its way into Unity. One artist might draw a concept, another artist might create the 3D model, and a third artist might work on texturing, and a fourth artist might be responsible for making sure the colliders and materials are created properly in-engine, or the same artist may carry a single asset all the way through the pipeline herself. 

There’s a fair bit of logistical work that goes into keeping track of what everyone’s working on and making sure that we’re sticking to our project deadlines while also maintaining a consistent art style, and that involves arranging lots of check-in sessions and informal critiques with each of the artists and with the team as a whole.

The art team collaborates with the design team to make sure that the art style of the game matches up with gameplay. Margaret also works closely with the programming team to collaboratively build lighting systems, particle effects, and any other assets that are natively built in Unity. This way, everyone on the team has a say in what the art aesthetic of Umbrella Mondays is, and we’re all excited to be working together to develop a consistent, beautiful experience!

Behold, the power of friendship and collaboration! (Left to right: April, Casey, Margaret)


Technicalities of Lighting

Hello everyone, prepare to get technical! This is Spencer writing today to share some insight on what it takes to light our levels in Umbrella Mondays! (We wrote a blog post about the art side of lighting last week!)

To utilize the Lighting in Unity, we use the different types of light primitives (point, cone, area, and directional) to send out light data to shaders, which calculate what the player sees at each spot in the game. The shaders control everything from shadows to color highlights. Computationally, lighting takes a lot of processing power, which is why computers have dedicated graphics cards to run calculations for every frame!

The green light bulbs, as well as the yellow cone, are all light primitives

Unity has a standard shader library, which gives us a starting place for creating specular highlights, detailed shadows, and more. These effects are controlled by an object’s texture, but in order for that texture to be visible, we must use lights!

We mentioned that computing light information takes a lot of processing power. If a Unity game has too many lights, it can cause the game to run slowly since the graphics card has to calculate light information for every object in the game. One way that Unity makes lighting less intensive is through “baking,” which allows us to preprocess the lighting on any static (or non-moving) object. 

Lights on non-moving objects can be super accurate in Unity, since Unity can calculate indirect lighting and bounce between objects, creating higher definition shadows. How this works is Unity processes the indirect lighting on all of our static objects, then translates that data into lighting maps that, when the game runs, overlay the objects to show the precomputed (baked) lighting. This way, the game’s frame rate stays higher with good graphical fidelity, as the lighting calculations are already done by play time for a large portion of objects.

Some of our objects move, however, and dynamic lighting must still be computed. As an object moves, the light on the surface changes, so we can’t have pre-calculated lighting data!

Objects that are dynamic, such as Fella, won’t have baked lighting applied to them, but instead only respond to lights we allow to process in real time. However, they can receive our bake data from static points called light probes.

Each yellow sphere is a light probe – they’re invisible when the game runs.

Light probes are a web of data points in the Unity scene that saves the light data that was baked on to them during preprocessing, and then average their results with other nearby light probes to apply an ambient light to dynamic objects to match the scene around them! This way, dynamic moving objects can still have baked lights applied.

Even though Fella moves around, she’s still affected by runtime lights and baked lights.

Another way to have lights enhance our game in Unity is to apply volumetric lighting. Volumetric lighting is a special lighting effect where the area (volume) that the light passes through also has some sort of lighting effect applied, rather than the light just affecting the surfaces that it hits. A common example of volumetric lighting would be fog and dust effects. The results can be dramatic!

As always, thanks for reading! See you next week!



Vertical Slice – Art and Lighting

Happy Monday! April and Margaret here to show you the first vertical slice of Umbrella Mondays! The art team has been hard at work for the past two weeks touching up models, texturing, and lighting our set in Unity, and we’re excited to show you the fruits of our labors!

A vertical slice is an important milestone in game design because it’s the first section of a project that is completely done, and this is the first time we’ve had a section of Umbrella Mondays that we consider to be visually complete (or at least very close!). We ironed out a lot of our art pipelines in the past few weeks as we wrapped up all these assets, and we can use this vertical slice moving forward as a template for the rest of the game.

We chose to tackle one of our biggest rooms for this vertical slice, and we’re going to let our most of our images speak for themselves because we’re pretty pleased with how it’s shaping together.


This room is one of the larger puzzle rooms in the game. Fella uses launch rings to access areas she can’t reach on her own.


One of our goals for this vertical slice was to bring in volumetric lighting. We’ll likely be tweaking it as we go, but we were satisfied with this first pass.

SMOL_verticalslicefiresourceIndividual assets like our bonfires and sconces are now fully textured and animated. Most of the texture work was done in Substance Painter or Substance Designer, which most of our artists picked up specifically for this project. 


We hope you enjoy! There’s lots more to come!umbrellaforWeb