- Home /

# How do i access the MeshExtrusion.cs from Unity's PE?

Hello i have been trying to find out how to use the *MeshExtrusion.cs* (from the Unity Procedural examples)with another C# Script so i can extrude objects like the one in the picture below. i have been looking at triangles for a couple of days now, and i saw the triangulation code for Mesh in *MeshExtrusion.cs* and its exactly what i need, but i don't know how to access the script with another script(C#) so i can Extrude Mesh, would anyone know how to do this?

(The reason i say *"int segment = 3 or 4"*(In the Picture) because i dont know if the base mesh counts as an extra number)

Here is the MeshExtrusion.cs

```
using UnityEngine;
using System.Collections;
/*
* An algorithm to extrude an arbitrary mesh along a number of sections.
The mesh extrusion has 2 steps:
1. Extracting an edge representation from an arbitrary mesh
- A general edge extraction algorithm is employed. (Same algorithm as traditionally used for stencil shadows) Once all unique edges are found, all edges that connect to only one triangle are extracted.
Thus we end up with the outline of the mesh.
2. extruding the mesh from the edge representation.
We simply generate a segments joining the edges
*/
public class MeshExtrusion
{
public class Edge
{
// The indiex to each vertex
public int[] vertexIndex = new int[2];
// The index into the face.
// (faceindex[0] == faceindex[1] means the edge connects to only one triangle)
public int[] faceIndex = new int[2];
}
public static void ExtrudeMesh (Mesh srcMesh, Mesh extrudedMesh, Matrix4x4[] extrusion, bool invertFaces)
{
Edge[] edges = BuildManifoldEdges(srcMesh);
ExtrudeMesh(srcMesh, extrudedMesh, extrusion, edges, invertFaces);
}
public static void ExtrudeMesh (Mesh srcMesh, Mesh extrudedMesh, Matrix4x4[] extrusion, Edge[] edges, bool invertFaces)
{
int extrudedVertexCount = edges.Length * 2 * extrusion.Length;
int triIndicesPerStep = edges.Length * 6;
int extrudedTriIndexCount = triIndicesPerStep * (extrusion.Length -1);
Vector3[] inputVertices = srcMesh.vertices;
Vector2[] inputUV = srcMesh.uv;
int[] inputTriangles = srcMesh.triangles;
Vector3[] vertices = new Vector3[extrudedVertexCount + srcMesh.vertexCount * 2];
Vector2[] uvs = new Vector2[vertices.Length];
int[] triangles = new int[extrudedTriIndexCount + inputTriangles.Length * 2];
// Build extruded vertices
int v = 0;
for (int i=0;i<extrusion.Length;i++)
{
Matrix4x4 matrix = extrusion[i];
float vcoord = (float)i / (extrusion.Length -1);
foreach (Edge e in edges)
{
vertices[v+0] = matrix.MultiplyPoint(inputVertices[e.vertexIndex[0]]);
vertices[v+1] = matrix.MultiplyPoint(inputVertices[e.vertexIndex[1]]);
uvs[v+0] = new Vector2 (inputUV[e.vertexIndex[0]].x, vcoord);
uvs[v+1] = new Vector2 (inputUV[e.vertexIndex[1]].x, vcoord);
v += 2;
}
}
// Build cap vertices
// * The bottom mesh we scale along it's negative extrusion direction. This way extruding a half sphere results in a capsule.
for (int c=0;c<2;c++)
{
Matrix4x4 matrix = extrusion[c == 0 ? 0 : extrusion.Length-1];
int firstCapVertex = c == 0 ? extrudedVertexCount : extrudedVertexCount + inputVertices.Length;
for (int i=0;i<inputVertices.Length;i++)
{
vertices[firstCapVertex + i] = matrix.MultiplyPoint(inputVertices[i]);
uvs[firstCapVertex + i] = inputUV[i];
}
}
// Build extruded triangles
for (int i=0;i<extrusion.Length-1;i++)
{
int baseVertexIndex = (edges.Length * 2) * i;
int nextVertexIndex = (edges.Length * 2) * (i+1);
for (int e=0;e<edges.Length;e++)
{
int triIndex = i * triIndicesPerStep + e * 6;
triangles[triIndex + 0] = baseVertexIndex + e * 2;
triangles[triIndex + 1] = nextVertexIndex + e * 2;
triangles[triIndex + 2] = baseVertexIndex + e * 2 + 1;
triangles[triIndex + 3] = nextVertexIndex + e * 2;
triangles[triIndex + 4] = nextVertexIndex + e * 2 + 1;
triangles[triIndex + 5] = baseVertexIndex + e * 2 + 1;
}
}
// build cap triangles
int triCount = inputTriangles.Length / 3;
// Top
{
int firstCapVertex = extrudedVertexCount;
int firstCapTriIndex = extrudedTriIndexCount;
for (int i=0;i<triCount;i++)
{
triangles[i*3 + firstCapTriIndex + 0] = inputTriangles[i * 3 + 1] + firstCapVertex;
triangles[i*3 + firstCapTriIndex + 1] = inputTriangles[i * 3 + 2] + firstCapVertex;
triangles[i*3 + firstCapTriIndex + 2] = inputTriangles[i * 3 + 0] + firstCapVertex;
}
}
// Bottom
{
int firstCapVertex = extrudedVertexCount + inputVertices.Length;
int firstCapTriIndex = extrudedTriIndexCount + inputTriangles.Length;
for (int i=0;i<triCount;i++)
{
triangles[i*3 + firstCapTriIndex + 0] = inputTriangles[i * 3 + 0] + firstCapVertex;
triangles[i*3 + firstCapTriIndex + 1] = inputTriangles[i * 3 + 2] + firstCapVertex;
triangles[i*3 + firstCapTriIndex + 2] = inputTriangles[i * 3 + 1] + firstCapVertex;
}
}
if (invertFaces)
{
for (int i=0;i<triangles.Length/3;i++)
{
int temp = triangles[i*3 + 0];
triangles[i*3 + 0] = triangles[i*3 + 1];
triangles[i*3 + 1] = temp;
}
}
extrudedMesh.Clear();
extrudedMesh.name= "extruded";
extrudedMesh.vertices = vertices;
extrudedMesh.uv = uvs;
extrudedMesh.triangles = triangles;
extrudedMesh.RecalculateNormals();
}
/// Builds an array of edges that connect to only one triangle.
/// In other words, the outline of the mesh
public static Edge[] BuildManifoldEdges (Mesh mesh)
{
// Build a edge list for all unique edges in the mesh
Edge[] edges = BuildEdges(mesh.vertexCount, mesh.triangles);
// We only want edges that connect to a single triangle
ArrayList culledEdges = new ArrayList();
foreach (Edge edge in edges)
{
if (edge.faceIndex[0] == edge.faceIndex[1])
{
culledEdges.Add(edge);
}
}
return culledEdges.ToArray(typeof(Edge)) as Edge[];
}
/// Builds an array of unique edges
/// This requires that your mesh has all vertices welded. However on import, Unity has to split
/// vertices at uv seams and normal seams. Thus for a mesh with seams in your mesh you
/// will get two edges adjoining one triangle.
/// Often this is not a problem but you can fix it by welding vertices
/// and passing in the triangle array of the welded vertices.
public static Edge[] BuildEdges(int vertexCount, int[] triangleArray)
{
int maxEdgeCount = triangleArray.Length;
int[] firstEdge = new int[vertexCount + maxEdgeCount];
int nextEdge = vertexCount;
int triangleCount = triangleArray.Length / 3;
for (int a = 0; a < vertexCount; a++)
firstEdge[a] = -1;
// First pass over all triangles. This finds all the edges satisfying the
// condition that the first vertex index is less than the second vertex index
// when the direction from the first vertex to the second vertex represents
// a counterclockwise winding around the triangle to which the edge belongs.
// For each edge found, the edge index is stored in a linked list of edges
// belonging to the lower-numbered vertex index i. This allows us to quickly
// find an edge in the second pass whose higher-numbered vertex index is i.
Edge[] edgeArray = new Edge[maxEdgeCount];
int edgeCount = 0;
for (int a = 0; a < triangleCount; a++)
{
int i1 = triangleArray[a*3 + 2];
for (int b = 0; b < 3; b++)
{
int i2 = triangleArray[a*3 + b];
if (i1 < i2)
{
Edge newEdge = new Edge();
newEdge.vertexIndex[0] = i1;
newEdge.vertexIndex[1] = i2;
newEdge.faceIndex[0] = a;
newEdge.faceIndex[1] = a;
edgeArray[edgeCount] = newEdge;
int edgeIndex = firstEdge[i1];
if (edgeIndex == -1)
{
firstEdge[i1] = edgeCount;
}
else
{
while (true)
{
int index = firstEdge[nextEdge + edgeIndex];
if (index == -1)
{
firstEdge[nextEdge + edgeIndex] = edgeCount;
break;
}
edgeIndex = index;
}
}
firstEdge[nextEdge + edgeCount] = -1;
edgeCount++;
}
i1 = i2;
}
}
// Second pass over all triangles. This finds all the edges satisfying the
// condition that the first vertex index is greater than the second vertex index
// when the direction from the first vertex to the second vertex represents
// a counterclockwise winding around the triangle to which the edge belongs.
// For each of these edges, the same edge should have already been found in
// the first pass for a different triangle. Of course we might have edges with only one triangle
// in that case we just add the edge here
// So we search the list of edges
// for the higher-numbered vertex index for the matching edge and fill in the
// second triangle index. The maximum number of comparisons in this search for
// any vertex is the number of edges having that vertex as an endpoint.
for (int a = 0; a < triangleCount; a++)
{
int i1 = triangleArray[a*3+2];
for (int b = 0; b < 3; b++)
{
int i2 = triangleArray[a*3+b];
if (i1 > i2)
{
bool foundEdge = false;
for (int edgeIndex = firstEdge[i2]; edgeIndex != -1;edgeIndex = firstEdge[nextEdge + edgeIndex])
{
Edge edge = edgeArray[edgeIndex];
if ((edge.vertexIndex[1] == i1) && (edge.faceIndex[0] == edge.faceIndex[1]))
{
edgeArray[edgeIndex].faceIndex[1] = a;
foundEdge = true;
break;
}
}
if (!foundEdge)
{
Edge newEdge = new Edge();
newEdge.vertexIndex[0] = i1;
newEdge.vertexIndex[1] = i2;
newEdge.faceIndex[0] = a;
newEdge.faceIndex[1] = a;
edgeArray[edgeCount] = newEdge;
edgeCount++;
}
}
i1 = i2;
}
}
Edge[] compactedEdges = new Edge[edgeCount];
for (int e=0;e<edgeCount;e++)
compactedEdges[e] = edgeArray[e];
return compactedEdges;
}
}
```

**Answer** by tomekkie2
·
Aug 28, 2016 at 05:09 AM

You have just to use the ExtrudeMesh static function of the MeshExtrusion script.

The procedural examples asset contains the Extrusion scene and the ExtrudeMeshTrail.js script. It should just be your starting point and you can remake it to what you need.

For example I have remade the ExtrudeMeshTrail.js to ExtrudeOnClick.cs script:

```
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
public class ExtrudeOnClick : MonoBehaviour
{
public int segments = 1;
public bool invertFaces = false;
public float extrusionLength = 1.0f;
public bool autoCalculateOrientation = true;
private Mesh srcMesh;
private MeshExtrusion.Edge[] precomputedEdges;
private class ExtrudedSection
{
public Vector3 point;
public Matrix4x4 matrix;
}
void Start()
{
srcMesh = GetComponent<MeshFilter>().sharedMesh;
precomputedEdges = MeshExtrusion.BuildManifoldEdges(srcMesh);
}
void OnMouseDown()
{
Extrude();
}
void Extrude()
{
Vector3 extrusionNormal = transform.forward;
List<ExtrudedSection> sections = new List<ExtrudedSection>();
ExtrudedSection section = new ExtrudedSection();
section.point = transform.position;
section.matrix = transform.localToWorldMatrix;
sections.Insert(0,section);
for(int i = 0; i<segments; i++)
{
transform.position = transform.position + extrusionNormal * 1.0f / segments;
section = new ExtrudedSection();
section.point = transform.position;
section.matrix = transform.localToWorldMatrix;
sections.Insert(0, section);
}
Matrix4x4 worldToLocal = transform.worldToLocalMatrix;
Quaternion rotation = Quaternion.LookRotation(-extrusionNormal, Vector3.up);
Matrix4x4[] finalSections = new Matrix4x4[sections.Count];
for (int i = 0; i < sections.Count; i++)
{
finalSections[i] = worldToLocal * Matrix4x4.TRS(sections[i].point, rotation, Vector3.one);
}
MeshExtrusion.ExtrudeMesh(srcMesh, GetComponent<MeshFilter>().mesh, finalSections, precomputedEdges, invertFaces);
}
}
```

I have tried this and it seems to work.

Thank you so much, i have gone through the code and now its starting to make sense :D

I have simply used transform.forward as the extrusion normal. You could also cast a ray on Update and then use hit.normal as the extrusion normal. You could use an average normal of all the triangles in the starting mesh - depending on your needs.

Hello @tomekkie2 i am having some trouble trying to do this in Picture1 but what i get is in Picture2 i dont know why it loops in Picture2, anyway what i have done is set `Quaternion rotation = Quaternion.LookRotation(-extrusionNormal, Vector3.up);`

to `Quaternion rotation = Quaternion.LookRotation(point[n].transform.forward);`

so it creates each segment looking in the point's forward rotation so i can make a road like in Picture1, do you have any idea on how to fix this?

-Picture1 -Picture2 Oh yeah and i should also add The code so you know what i have done.

```
void Extrude()
{
Vector3 extrusionNormal = transform.forward;
List<ExtrudedSection> sections = new List<ExtrudedSection>();
ExtrudedSection section = new ExtrudedSection();
for (int i = 0; i < segments; i++)
{
for (int n = 0; n < point.Length; n++)
{
transform.position = point[n].transform.position;
section = new ExtrudedSection();
section.point = transform.position;
section.matrix = transform.localToWorldMatrix;
sections.Insert(0, section);
}
}
for (int n = 0; n < point.Length; n++)
{
Matrix4x4 worldToLocal = transform.worldToLocalMatrix;
Quaternion rotation = Quaternion.LookRotation(point[n].transform.forward);
Matrix4x4[] finalSections = new Matrix4x4[sections.Count];
for (int i = 0; i < sections.Count; i++)
{
finalSections[i] = worldToLocal * Matrix4x4.TRS(sections[i].point, rotation, Vector3.one);
}
MeshExtrusion.ExtrudeMesh(srcMesh, GetComponent<MeshFilter>().mesh, finalSections, precomputedEdges, invertFaces);
}
}
```

I fixed that looping thing and instead of having basemesh to point 5 i now have it to point 1 to point 5, the only thing left is the segment looking in the point's forward direction.

You have to take a look at the ExtrudeMeshTrail.js more closely, because what you want to do is exactly what this script does, except you want the trail not to be animated, but to stay permanent

```
var direction = sections[0].point - sections[1].point;
var rotation = Quaternion.LookRotation(direction, Vector3.up);
previousRotation = rotation;
```

Note that in your case the extrusionNormal changes over the steps - like in ExtrusionTrail.

Thanks @tomekkie2 i forgot about the direction :P, I don't want to be a pain in your ass, but the method you mentioned works but not as my Picture1 Depicts, here is a pic between the difference from mine and the ExtrudeMeshTrail.js, so instead of using a point to point calculation how do i position the segments as the same rotation as the point[] objects?

### Your answer

### Welcome to Unity Answers

The best place to ask and answer questions about development with Unity.

To help users navigate the site we have posted a site navigation guide.

If you are a new user to Unity Answers, check out our FAQ for more information.

Make sure to check out our Knowledge Base for commonly asked Unity questions.

If you are a moderator, see our Moderator Guidelines page.

We are making improvements to UA, see the list of changes.