Trouble with Procedural Mesh Normals (normals are inverted)

Hello everyone, I'm working on making a script that is used to create a Field of View / Area of Interest for an object. I could never quite get the triangle order correct on my own, so I used integrated a procedural cube script from the Unity Wiki (see it here), which does work, so I known that I am causing the problem (the normals are inverted).

I've posted the code below (which just replaces the way the vertices are assigned), the only lines I'm directly touching are from #region Vertices tag until Vector3 p7 is assigned, so presumably the error is in the way I'm making the assignments inside the MeshBuilder() method. I've also left the original code in so you can more easily see what it was.

Any ideas are appreciated, thank you for reading.

 using UnityEngine;
 using System.Collections;
 
 public class ZtestGunFOVBuilder3 : MonoBehaviour {
     //responisble for creating the mesh the gun will use to determine what targets it cares about
     //placed on some EMPTY??? base hierarchy object
     //10 16 2014, this script has been combined with another scipt found on Unity Wiki for making procedural cubes...
     public zTestGunGroups testGunGroups; //need to take some values for each gun from the gun group
     public Material mat1; //used to render object.
     
     private GameObject gunFOVGO;
     
 
     void Start()
     {
         gunFOVGO = new GameObject();
         gunFOVGO.name = "Gun_FOV_GO";
         
         MeshFilter meshFilter = gunFOVGO.AddComponent<MeshFilter>();
         meshFilter.mesh = MeshBuilder();
         
         MeshRenderer meshRenderer = gunFOVGO.AddComponent<MeshRenderer>();
         meshRenderer.material = mat1;
         
         //moving the created GO and mesh to a parent GO, then making the local pos and rot (0,0,0).
         //gunFOVGO.transform.parent = gameObject.transform;
         //gunFOVGO.transform.localPosition = Vector3.zero;
         //gunFOVGO.transform.localRotation = Quaternion.identity;
     }
     
     
     private Mesh MeshBuilder()
     {
         Mesh newMesh = new Mesh();
         newMesh.name = "FOV mesh";
         newMesh.Clear();
 
         //float length = 1f;
         //float width = 1f;
         //float height = 1f;
         
         #region Vertices
         //FRONT ->  input from gunGroup
         //top left
         //Vector3 p0 = new Vector3( -length * .5f,    -width * .5f, height * .5f );
         Vector3 p0 = testGunGroups.fovTopLeftBase;
 
         //top right
         //Vector3 p1 = new Vector3( length * .5f,     -width * .5f, height * .5f );
         Vector3 p1 = testGunGroups.fovTopRightBase;
 
         //bottom right
         //Vector3 p2 = new Vector3( length * .5f,     -width * .5f, -height * .5f );
         Vector3 p2 = testGunGroups.fovBotRightBase;
 
         //bottom left
         //Vector3 p3 = new Vector3( -length * .5f,    -width * .5f, -height * .5f );
         Vector3 p3 = testGunGroups.fovBotLeftBase;
 
         //BACK -> calculated(not sure if should look at back from through front, or only back...So I'm not sure how to name these points...
         //top left
         //Vector3 p4 = new Vector3( -length * .5f,    width * .5f,  height * .5f );
         Vector3 p4 = CalculateNextVertice(p0, testGunGroups.fovUpAngle, testGunGroups.fovLeftAngle, testGunGroups.fovDistance);
             
         //top right
         //Vector3 p5 = new Vector3( length * .5f,     width * .5f,  height * .5f );
         Vector3 p5 = CalculateNextVertice(p1, testGunGroups.fovUpAngle, testGunGroups.fovRightAngle, testGunGroups.fovDistance);
 
         //bottom right
         //Vector3 p6 = new Vector3( length * .5f,     width * .5f,  -height * .5f );
         Vector3 p6 = CalculateNextVertice(p2, testGunGroups.fovDownAngle, testGunGroups.fovRightAngle, testGunGroups.fovDistance);
 
         //bottom left
         //Vector3 p7 = new Vector3( -length * .5f,    width * .5f,  -height * .5f );
         Vector3 p7 = CalculateNextVertice(p3, testGunGroups.fovDownAngle, testGunGroups.fovLeftAngle, testGunGroups.fovDistance);
 
         
         Vector3[] vertices = new Vector3[]
         {
             // Bottom
             p0, p1, p2, p3,
             
             // Left
             p7, p4, p0, p3,
             
             // Front
             p4, p5, p1, p0,
             
             // Back
             p6, p7, p3, p2,
             
             // Right
             p5, p6, p2, p1,
             
             // Top
             p7, p6, p5, p4
         };
         #endregion
         
         #region Normales
         Vector3 up     = Vector3.up;
         Vector3 down     = Vector3.down;
         Vector3 front     = Vector3.forward;
         Vector3 back     = Vector3.back;
         Vector3 left     = Vector3.left;
         Vector3 right     = Vector3.right;
         
         Vector3[] normales = new Vector3[]
         {
             // Bottom
             down, down, down, down,
             
             // Left
             left, left, left, left,
             
             // Front
             front, front, front, front,
             
             // Back
             back, back, back, back,
             
             // Right
             right, right, right, right,
             
             // Top
             up, up, up, up
         };
         #endregion    
         
         #region UVs
         Vector2 _00 = new Vector2( 0f, 0f );
         Vector2 _10 = new Vector2( 1f, 0f );
         Vector2 _01 = new Vector2( 0f, 1f );
         Vector2 _11 = new Vector2( 1f, 1f );
         
         Vector2[] uvs = new Vector2[]
         {
             // Bottom
             _11, _01, _00, _10,
             
             // Left
             _11, _01, _00, _10,
             
             // Front
             _11, _01, _00, _10,
             
             // Back
             _11, _01, _00, _10,
             
             // Right
             _11, _01, _00, _10,
             
             // Top
             _11, _01, _00, _10,
         };
         #endregion
         
         #region Triangles
         int[] triangles = new int[]
         {
             // Bottom
             3, 1, 0,
             3, 2, 1,            
             
             // Left
             3 + 4 * 1, 1 + 4 * 1, 0 + 4 * 1,
             3 + 4 * 1, 2 + 4 * 1, 1 + 4 * 1,
             
             // Front
             3 + 4 * 2, 1 + 4 * 2, 0 + 4 * 2,
             3 + 4 * 2, 2 + 4 * 2, 1 + 4 * 2,
             
             // Back
             3 + 4 * 3, 1 + 4 * 3, 0 + 4 * 3,
             3 + 4 * 3, 2 + 4 * 3, 1 + 4 * 3,
             
             // Right
             3 + 4 * 4, 1 + 4 * 4, 0 + 4 * 4,
             3 + 4 * 4, 2 + 4 * 4, 1 + 4 * 4,
             
             // Top
             3 + 4 * 5, 1 + 4 * 5, 0 + 4 * 5,
             3 + 4 * 5, 2 + 4 * 5, 1 + 4 * 5,
             
         };
         #endregion
         
         newMesh.vertices = vertices;
         newMesh.normals = normales;
         newMesh.uv = uvs;
         newMesh.triangles = triangles;
         
         newMesh.RecalculateBounds();
         newMesh.Optimize();
 
         return newMesh;
     }
     
     //using parameters, calculate where the desired point will be:
     private Vector3 CalculateNextVertice(Vector3 startingPoint, float desiredUpDownAngle,  float desiredLeftRightAngle, float desiredDistance)
     {
         Vector3 createdVec3 = new Vector3();
         
         Ray tempRay = new Ray();
         tempRay.origin = startingPoint;
         tempRay.direction = Quaternion.AngleAxis(desiredLeftRightAngle, Vector3.up) * (gunFOVGO.transform.forward);
         tempRay.direction += Quaternion.AngleAxis(desiredUpDownAngle, Vector3.right) * (gunFOVGO.transform.forward);
         
         Physics.Raycast (tempRay.origin, tempRay.direction, desiredDistance);
         Debug.DrawRay (tempRay.origin, tempRay.direction * desiredDistance, Color.red, 5f);
         
         //get the point at the end of the ray:
         createdVec3 = tempRay.GetPoint (desiredDistance);
         
         Debug.Log ("createdVec3 is: " + createdVec3);
         return createdVec3;
     }
 }