# 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;
//base
verts = new Vector3(-1, 0, -1);
verts = new Vector3(-1, 0, 1);
verts = new Vector3(1, 0, 1);
verts = new Vector3(1, 0, -1);

//front wall
verts = new Vector3(-1, 0, -1);
verts = new Vector3(0, 2, 0);
verts = new Vector3(1, 0, -1);

//back wall
verts = new Vector3(1, 0, 1);
verts = new Vector3(0, 2, 0);
verts = new Vector3(-1, 0, 1);

//left wall
verts = new Vector3(-1, 0, 1);
verts = new Vector3(0, 2, 0);
verts = new Vector3(-1, 0, -1);

//right wall
verts = new Vector3(1, 0, -1);
verts = new Vector3(0, 2, 0);
verts = new Vector3(1, 0, 1);

//order the indices of verts in patterns
//to make triangles
int[] tris = new int { 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: 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. 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: 