How to model procedurally in Unity3D

Unity3D is not a modelling tool. It is usually easier to design artwork in an animation program like Blender or Maya, and then import them into Unity. However, for some things, especially procedurally generated content, you’ll need to dive into the drawing tools Unity provides in its libraries.

Note: This tutorial assumes you have a basic knowledge of the Unity Editor. If you do not, you should first go through Unity’s beginner tutorial.

First, create a new scene in Unity. Go to GameObject > 3D Object > Cube to add a new object to the scene, and position it at the origin. Then, in the Project window, go to Create > C# Script. Name the SimpleMesh, and then double click it to launch Visual Studio. Now we are ready to start coding.

We’ll begin by creating a Mesh object. This is what hold the shape of our object. We make a mesh by creating a bunch of 3D vertices and then connecting these vertices to make triangles. Unity does not have a built-in way of making pyramids, so we’ll make one with our SimpleMesh script. I’ll show the code and then explain:

using UnityEngine;

public class SimpleMesh : MonoBehaviour {

    void Start () {

        Vector3[] verts = new Vector3[16];
        //base
        verts[0] = new Vector3(-1, 0, -1);
        verts[1] = new Vector3(-1, 0, 1);
        verts[2] = new Vector3(1, 0, 1);
        verts[3] = new Vector3(1, 0, -1);

        //front wall
        verts[4] = new Vector3(-1, 0, -1);
        verts[5] = new Vector3(0, 2, 0);
        verts[6] = new Vector3(1, 0, -1);

        //back wall
        verts[7] = new Vector3(1, 0, 1);
        verts[8] = new Vector3(0, 2, 0);
        verts[9] = new Vector3(-1, 0, 1);

        //left wall
        verts[10] = new Vector3(-1, 0, 1);
        verts[11] = new Vector3(0, 2, 0);
        verts[12] = new Vector3(-1, 0, -1);

        //right wall
        verts[13] = new Vector3(1, 0, -1);
        verts[14] = new Vector3(0, 2, 0);
        verts[15] = new Vector3(1, 0, 1);

        //order the indices of verts in patterns
        //to make triangles
        int[] tris = new int[18] { 3,2,0,2,1,0,4,
                     5,6,7,8,9,10,11,12,13,14,15};

        //add the vertices and triangles to a new mesh
        Mesh mesh = new Mesh();
        mesh.vertices = verts;
        mesh.triangles = tris;

        //Assign the mesh to the MeshFilter component
        GetComponent().mesh = mesh;
    }
}

Everything will happen inside the Start() method so it will happen once when we play the game. This is what the script does:

  1. Create an array of 3D vectors to store our vertices. Our pyramid will have five vertices: the top and each of the four corners. Many of these vertices are duplicated in our array. This is because we want hard edges. Shared vertices mean there will be a smooth edge, like the surface of a sphere. Duplicated vertices mean it will draw a hard edge like a corner. We’ll come back to that later.
  2. Create and array to store triangle information. This may seem like a strange list of numbers, but each corresponds to an index in the triangles array. Every three numbers represent one triangle connecting vertices counter-clockwise. So the first triangle connects vertices 3, 2, and zero, the second connects 2, 1, and zero, and so forth.
  3. Create a new Mesh object. This stores both our vertices and triangles.
  4. Assign the new mesh to the MeshFilter. This component should already be on our object, since we are creating it from a Cube. It will also use the material already assigned to the Cube. The material tells Unity how to draw the shape on the screen based on textures and lighting. Materials can also be generated, but that is outside the scope of this tutorial.

Assign the SimpleMesh script to the cube object. If you press play, you should see something like this:

pyramid

You may need to adjust the camera position or pause the game to get a better view. The shape is right, but it still looks kind of strange. There is nothing to distinguish the edge, and the lighting is weird. This is because we have not assigned normals. Normals are direction vectors that are supposed to point away from the object. There is one for each vertex. When light hits an object, it reflects more light if it hits directly than if it hits at an angle. The normals give Unity a reference to decide what is considered direct.

normal_explanation

Normals are why we duplicated vertices. Unity blends between the normals to get smooth curves, like in the top diagram. At a hard edge, though, where would the normal point? With two vertices, we can have two normals, one pointing away from each wall that meets at that corner. There is no blending because we have two separate surfaces.

Fortunately, for a shape as simple as this, the normals can easily be calculated. Add this inside the Start() method after everything else:

mesh.RecalculateNormals();

That’s it!. Press play and you should see a pyramid that looks something like this:

pyramid2

PyGame Detective Game

Last semester, I took a class learning PyGame. Despite the outdated-looking website, it is actually fairly well maintained. It may not have all the bells and whistles that I am used to in other game engines, PyGame can be a good tool for making smaller 2D games. With the help of PyTMX, I was able to make a quick side-scrolling detective game.

In the game, you are thrown into this village where someone is supposedly plotting a murder. People walk around throughout the day, going house to house and interacting with the neighbors. Your goal is to get the information you need at the end of the day in order to stop the murder from happened. The roles and behaviors of the townspeople are randomized at the start of the game. However, if you fail to stop the murder, you can reset it to the start of the day, where people will act exactly as they did on the last try except where your different decisions might have influenced them. The game was mostly a proof of concept to see if I could make a game all about logical deduction.

detective

Abandoned Projects

I’ve been looking through some projects from years ago that I never finished or published. I’ve been experiencing some writer’s block, so I’ve been thinking about revisiting some of these. Below is a list of some of my less awful projects. If any of these sound good, I’m willing to revisit them to either finish or scrap for parts. Please tell me what you think.

Crazy Lander: Abduction

This was a sequel to the very first game I published back in seventh grade. You go back and forth between a mothership and a farm, dodging toxic clouds and angry farmers as you try to steal cows. Different clouds have different negative effects on your ship. After each run, you earn money for upgrades. It is mostly functional, but lacking decent artwork. I made it in Flash, which is sort of dying, so if I fixed it up, I would probably port it to Unity.

cla_screenshot1
The rope snags onto the cow. Then you carry it up to the mothership and drop it off. If the farmers sees you, he will shoot.

Handsome Taco

It is a side-view puzzle game. Try to get to the obstacles using blocks, portals, fans, etc. It even includes a level creator. It is a bit glitchy, and also in Flash, but it could be redesigned.

ht_screetnshot1
One of the first levels. The blue spots are teleporters. Yellow is a locked door. The red box moves clockwise when you are atop it. The crate can be pushed.

Energized

This turn-based multiplayer economic strategy game was showcased a few year ago at the annual showcase for the Center for Advanced Research and Technology. We set up multiplayer LAN games where people could try it for themselves. The hexagon tiles are rated for certain natural resources used to build alternative energy sources. Each player is a competing energy company that must buy land,  collect resources, but energy sources, and deliver the power to cities. Players are also able to buy and sell land and resources to other players. Whoever has the most money at the end wins.

energized_screeenshot1
The color tells you who owns the tile. This one has a wind turbine with power lines connecting it to a third city for extra money.

Earth Defense Whirl

Ported for Android, this game features two game modes. In the main Earth Defense mode, you fly around earth, zapping alien spacecraft before they reach our home planet. The goal is to hold off the aliens as long as you can. In training mode, you fly forward in a never-ending tunnel, avoid obstacles and not letting any targets get past you. If you fall behind too much, the game ends. The goal is to get as far forward as you can.

screenshot3
The arrows point to alien spaceships. You zap them when in range.

Super Rainbow Racers

As an end-of-the-year class project, our game design class recreated our classroom and made it into a shrunken cart racing game. They chose the name, not me. The physics were a little glitchy, but it did prove itself fun. Perhaps the framework is still salvageable for another cart racing game.

super_rainbow_racers_screenshot1
We only got this track working. I thank my classmates for the artwork.

Haunt

You enter a haunted mansion with nothing but a crossbow. Your job is to hunt and shoot all the monsters hiding throughout the building. There are paintings that change each time you look at them, man-slug-things that pop out of closets, and masked ghost patrols. This was my only attempt at a first-person shooter.

haunt_screenshot1
Two masked ghosts hovering toward the player.

Sphere Distort

Next time you want to make a game with small planets, save some time and effort from modeling scenery around a sphere. Sphere Distort takes regular Cartesian meshes and wraps them around the surface of a sphere. Now you can recycle some models from your non-spherical projects.

Check it out on the Unity Asset Store.

Radar Arrows

Radar Arrows make it easier for players to find things (enemies, destinations, other players, etc.). If the object is on-screen, you can have an arrow of a constant size hover above that object, making it easier to spot. If the object is off-screen, the arrow will appear on the edge of the screen, pointing to where the object appears off-screen.

Check it out at the Unity Asset Store.

Or try out the web demo.

Maze Creator

This script uses either depth-first search or Prim’s algorithm to generate complex mazes either in the editor or at run-time. It can also scatter obstacles or enemies throughout the maze. Its clean interface and flexibility allows you to use complex artwork and avoid a blocky look. You can generate mazes from scratch or define certain paths your maze must follow and let Maze Creator fill in the rest.

Check it out at the Unity Asset Store.

You can also download the demo for Windows.