Beispiel #1
0
 /// <summary>
 /// Adds mesh information from another draft
 /// </summary>
 public void Add(MeshDraft draft)
 {
     foreach (var triangle in draft.triangles)
     {
         triangles.Add(triangle + vertices.Count);
     }
     vertices.AddRange(draft.vertices);
     normals.AddRange(draft.normals);
     uv.AddRange(draft.uv);
     colors.AddRange(draft.colors);
 }
        public static MeshDraft Band(List<Vector3> lowerRing, List<Vector3> upperRing)
        {
            var draft = new MeshDraft {name = "Band"};
            if (lowerRing.Count < 3 || upperRing.Count < 3)
            {
                Debug.LogError("Array sizes must be greater than 2");
                return draft;
            }
            if (lowerRing.Count != upperRing.Count)
            {
                Debug.LogError("Array sizes must be equal");
                return draft;
            }

            draft.vertices.AddRange(lowerRing);
            draft.vertices.AddRange(upperRing);

            var lowerNormals = new List<Vector3>();
            var upperNormals = new List<Vector3>();
            var lowerUv = new List<Vector2>();
            var upperUv = new List<Vector2>();
            int i0, i1, i2, i3;
            Vector3 v0, v1, v2, v3;
            for (int i = 0; i < lowerRing.Count - 1; i++)
            {
                i0 = i;
                i1 = i + lowerRing.Count;
                i2 = i + 1;
                i3 = i + 1 + lowerRing.Count;
                v0 = draft.vertices[i0];
                v1 = draft.vertices[i1];
                v2 = draft.vertices[i2];
                v3 = draft.vertices[i3];
                draft.triangles.AddRange(new[] {i0, i1, i2});
                draft.triangles.AddRange(new[] {i2, i1, i3});

                lowerNormals.Add(Vector3.Cross(v1 - v0, v2 - v0).normalized);
                upperNormals.Add(Vector3.Cross(v3 - v1, v0 - v1).normalized);

                var u = (float) i/(lowerRing.Count - 1);
                lowerUv.Add(new Vector2(u, 0));
                upperUv.Add(new Vector2(u, 1));
            }

            i0 = lowerRing.Count - 1;
            i1 = lowerRing.Count*2 - 1;
            i2 = 0;
            i3 = lowerRing.Count;
            v0 = draft.vertices[i0];
            v1 = draft.vertices[i1];
            v2 = draft.vertices[i2];
            v3 = draft.vertices[i3];
            draft.triangles.AddRange(new[] {i0, i1, i2});
            draft.triangles.AddRange(new[] {i2, i1, i3});

            lowerNormals.Add(Vector3.Cross(v1 - v0, v2 - v0).normalized);
            upperNormals.Add(Vector3.Cross(v3 - v1, v0 - v1).normalized);
            draft.normals.AddRange(lowerNormals);
            draft.normals.AddRange(upperNormals);

            lowerUv.Add(new Vector2(1, 0));
            upperUv.Add(new Vector2(1, 1));
            draft.uv.AddRange(lowerUv);
            draft.uv.AddRange(upperUv);

            return draft;
        }
Beispiel #3
0
        public static MeshDraft RevolutionSurface(
            Func <float, float, float, float, Vector3> surfaceFunction,
            float radius,
            float height,
            int horizontalSegments,
            int verticalSegments)
        {
            var draft = new MeshDraft {
                name = "Revolution surface"
            };

            float horizontalSegmentAngle = 360f / horizontalSegments;
            float verticalSegmentAngle   = 180f / verticalSegments;
            float currentVerticalAngle   = -90;

            for (int ring = 0; ring <= verticalSegments; ring++)
            {
                float currentHorizontalAngle = 0f;
                for (int i = 0; i < horizontalSegments; i++)
                {
                    Vector3 point = surfaceFunction(radius, height, currentHorizontalAngle, currentVerticalAngle);
                    draft.vertices.Add(point);
                    draft.normals.Add(point.normalized);
                    draft.uv.Add(new Vector2((float)i / horizontalSegments, (float)ring / verticalSegments));
                    currentHorizontalAngle -= horizontalSegmentAngle;
                }
                currentVerticalAngle += verticalSegmentAngle;
            }

            for (int ring = 0; ring < verticalSegments; ring++)
            {
                int i0, i1, i2, i3;
                for (int i = 0; i < horizontalSegments - 1; i++)
                {
                    i0 = ring * horizontalSegments + i;
                    i1 = (ring + 1) * horizontalSegments + i;
                    i2 = ring * horizontalSegments + i + 1;
                    i3 = (ring + 1) * horizontalSegments + i + 1;

                    draft.triangles.Add(i0);
                    draft.triangles.Add(i1);
                    draft.triangles.Add(i2);

                    draft.triangles.Add(i2);
                    draft.triangles.Add(i1);
                    draft.triangles.Add(i3);
                }

                i0 = (ring + 1) * horizontalSegments - 1;
                i1 = (ring + 2) * horizontalSegments - 1;
                i2 = ring * horizontalSegments;
                i3 = (ring + 1) * horizontalSegments;

                draft.triangles.Add(i0);
                draft.triangles.Add(i1);
                draft.triangles.Add(i2);

                draft.triangles.Add(i2);
                draft.triangles.Add(i1);
                draft.triangles.Add(i3);
            }
            return(draft);
        }
Beispiel #4
0
 public static Mesh Prism(float radius, int segments, float height)
 {
     return(MeshDraft.Prism(radius, segments, height).ToMesh());
 }
        public static MeshDraft BaselessPyramid(Vector3 baseCenter, Vector3 apex, float radius, int segments,
            bool inverted = false)
        {
            float segmentAngle = Mathf.PI*2/segments*(inverted ? -1 : 1);
            float currentAngle = 0f;

            var vertices = new Vector3[segments + 1];
            vertices[0] = apex;
            for (var i = 1; i <= segments; i++)
            {
                vertices[i] = PTUtils.PointOnCircle3(radius, currentAngle) + baseCenter;
                currentAngle += segmentAngle;
            }

            var draft = new MeshDraft {name = "BaselessPyramid"};
            for (var i = 1; i < segments; i++)
            {
                draft.Add(Triangle(vertices[0], vertices[i], vertices[i + 1]));
            }
            draft.Add(Triangle(vertices[0], vertices[vertices.Length - 1], vertices[1]));
            return draft;
        }
 /// <remarks>
 /// https://en.wikipedia.org/wiki/Triangle_fan
 /// </remarks>
 public static MeshDraft TriangleFan(List<Vector3> vertices)
 {
     var draft = new MeshDraft
     {
         vertices = vertices,
         triangles = new List<int>(vertices.Count - 2),
         normals = new List<Vector3>(vertices.Count),
         uv = new List<Vector2>(vertices.Count),
         name = "TriangleFan"
     };
     for (int i = 1; i < vertices.Count - 1; i++)
     {
         draft.triangles.Add(0);
         draft.triangles.Add(i);
         draft.triangles.Add(i + 1);
     }
     var normal = Vector3.Cross(vertices[1] - vertices[0], vertices[2] - vertices[0]).normalized;
     for (int i = 0; i < vertices.Count; i++)
     {
         draft.normals.Add(normal);
         draft.uv.Add(new Vector2((float) i/vertices.Count, (float) i/vertices.Count));
     }
     return draft;
 }
        public static MeshDraft Plane(float xSize = 1, float zSize = 1, int xSegments = 1, int zSegments = 1)
        {
            float xStep = xSize/xSegments;
            float zStep = zSize/zSegments;
            var vertexCount = (xSegments + 1)*(zSegments + 1);
            var draft = new MeshDraft
            {
                name = "Plane",
                vertices = new List<Vector3>(vertexCount),
                triangles = new List<int>(xSegments*zSegments*6),
                normals = new List<Vector3>(vertexCount),
                uv = new List<Vector2>(vertexCount)
            };
            for (int z = 0; z <= zSegments; z++)
            {
                for (int x = 0; x <= xSegments; x++)
                {
                    draft.vertices.Add(new Vector3(x*xStep, 0f, z*zStep));
                    draft.normals.Add(Vector3.up);
                    draft.uv.Add(new Vector2((float) x/xSegments, (float) z/zSegments));
                }
            }

            int i = 0;
            for (int z = 0; z < zSegments; z++)
            {
                for (int x = 0; x < xSegments; x++)
                {
                    draft.triangles.Add(i);
                    draft.triangles.Add(i + xSegments + 1);
                    draft.triangles.Add(i + 1);
                    draft.triangles.Add(i + 1);
                    draft.triangles.Add(i + xSegments + 1);
                    draft.triangles.Add(i + xSegments + 2);
                    i++;
                }
                i++;
            }
            return draft;
        }
        public static MeshDraft FlatSphere(float radius, int longitudeSegments, int latitudeSegments)
        {
            float longitudeSegmentAngle = Mathf.PI*2/longitudeSegments;
            float latitudeSegmentAngle = Mathf.PI/latitudeSegments;

            float currentLatitude = -Mathf.PI/2;
            var rings = new List<List<Vector3>>(latitudeSegments);
            for (var i = 0; i <= latitudeSegments; i++)
            {
                var currentLongitude = 0f;
                var ring = new List<Vector3>(longitudeSegments);
                for (int j = 0; j < longitudeSegments; j++)
                {
                    ring.Add(PTUtils.PointOnSphere(radius, currentLongitude, currentLatitude));
                    currentLongitude -= longitudeSegmentAngle;
                }
                rings.Add(ring);
                currentLatitude += latitudeSegmentAngle;
            }

            var draft = new MeshDraft {name = "Flat sphere"};
            for (int i = 0; i < rings.Count - 1; i++)
            {
                draft.Add(FlatBand(rings[i], rings[i + 1]));
            }
            return draft;
        }
Beispiel #9
0
 public static Mesh Icosahedron(float radius)
 {
     return(MeshDraft.Icosahedron(radius).ToMesh());
 }
Beispiel #10
0
 public static Mesh Dodecahedron(float radius)
 {
     return(MeshDraft.Dodecahedron(radius).ToMesh());
 }
Beispiel #11
0
 public static Mesh Hexahedron(Vector3 width, Vector3 length, Vector3 height)
 {
     return(MeshDraft.Hexahedron(width, length, height).ToMesh());
 }
Beispiel #12
0
 public static Mesh Hexahedron(float width, float length, float height)
 {
     return(MeshDraft.Hexahedron(width, length, height).ToMesh());
 }
Beispiel #13
0
 public static Mesh TriangleStrip(List <Vector3> vertices)
 {
     return(MeshDraft.TriangleStrip(vertices).ToMesh());
 }
Beispiel #14
0
 public static Mesh Sphere(float radius, int longitudeSegments, int latitudeSegments)
 {
     return(MeshDraft.Sphere(radius, longitudeSegments, latitudeSegments).ToMesh());
 }
Beispiel #15
0
 public static Mesh Cylinder(float radius, int segments, float height)
 {
     return(MeshDraft.Cylinder(radius, segments, height).ToMesh());
 }
 public static MeshDraft BaselessPyramid(Vector3 apex, List<Vector3> ring)
 {
     var draft = new MeshDraft {name = "BaselessPyramid"};
     for (var i = 0; i < ring.Count - 1; i++)
     {
         draft.Add(Triangle(apex, ring[i], ring[i + 1]));
     }
     draft.Add(Triangle(apex, ring[ring.Count - 1], ring[0]));
     return draft;
 }
        public static MeshDraft FlatBand(List<Vector3> lowerRing, List<Vector3> upperRing)
        {
            var draft = new MeshDraft {name = "Flat band"};
            if (lowerRing.Count < 3 || upperRing.Count < 3)
            {
                Debug.LogError("Array sizes must be greater than 2");
                return draft;
            }
            if (lowerRing.Count != upperRing.Count)
            {
                Debug.LogError("Array sizes must be equal");
                return draft;
            }

            Vector3 v0, v1, v2, v3;
            for (int i = 0; i < lowerRing.Count - 1; i++)
            {
                v0 = lowerRing[i];
                v1 = upperRing[i];
                v2 = lowerRing[i + 1];
                v3 = upperRing[i + 1];
                draft.Add(Triangle(v0, v1, v2));
                draft.Add(Triangle(v2, v1, v3));
            }

            v0 = lowerRing[lowerRing.Count - 1];
            v1 = upperRing[upperRing.Count - 1];
            v2 = lowerRing[0];
            v3 = upperRing[0];
            draft.Add(Triangle(v0, v1, v2));
            draft.Add(Triangle(v2, v1, v3));

            return draft;
        }
Beispiel #18
0
 public static Mesh Plane(float xSize = 1, float zSize = 1, int xSegments = 1, int zSegments = 1)
 {
     return(MeshDraft.Plane(xSize, zSize, xSegments, zSegments).ToMesh());
 }
        /// <summary>
        /// Constructs partial hexahedron aka cube with specified faces
        /// </summary>
        public static MeshDraft Hexahedron(Vector3 width, Vector3 length, Vector3 height, Directions parts)
        {
            Vector3 corner0 = -width/2 - length/2 - height/2;
            Vector3 corner1 = width/2 + length/2 + height/2;

            var draft = new MeshDraft {name = "Hexahedron"};
            if ((parts & Directions.Left) == Directions.Left)
            {
                draft.Add(Quad(corner0, height, length));
            }
            if ((parts & Directions.Right) == Directions.Right)
            {
                draft.Add(Quad(corner1, -length, -height));
            }
            if ((parts & Directions.Down) == Directions.Down)
            {
                draft.Add(Quad(corner0, length, width));
            }
            if ((parts & Directions.Up) == Directions.Up)
            {
                draft.Add(Quad(corner1, -width, -length));
            }
            if ((parts & Directions.Back) == Directions.Back)
            {
                draft.Add(Quad(corner0, width, height));
            }
            if ((parts & Directions.Forward) == Directions.Forward)
            {
                draft.Add(Quad(corner1, -height, -width));
            }
            return draft;
        }
Beispiel #20
0
        public static MeshDraft BandDraft(List <Vector3> lowerRing, List <Vector3> upperRing)
        {
            var draft = new MeshDraft {
                name = "Band"
            };

            if (lowerRing.Count < 3 || upperRing.Count < 3)
            {
                Debug.LogError("Array sizes must be greater than 2");
                return(draft);
            }
            if (lowerRing.Count != upperRing.Count)
            {
                Debug.LogError("Array sizes must be equal");
                return(draft);
            }

            draft.vertices.AddRange(lowerRing);
            draft.vertices.AddRange(upperRing);

            var     lowerNormals = new List <Vector3>();
            var     upperNormals = new List <Vector3>();
            var     lowerUv = new List <Vector2>();
            var     upperUv = new List <Vector2>();
            int     i0, i1, i2, i3;
            Vector3 v0, v1, v2, v3;

            for (int i = 0; i < lowerRing.Count - 1; i++)
            {
                i0 = i;
                i1 = i + lowerRing.Count;
                i2 = i + 1;
                i3 = i + 1 + lowerRing.Count;
                v0 = draft.vertices[i0];
                v1 = draft.vertices[i1];
                v2 = draft.vertices[i2];
                v3 = draft.vertices[i3];
                draft.triangles.AddRange(new[] { i0, i1, i2 });
                draft.triangles.AddRange(new[] { i2, i1, i3 });

                lowerNormals.Add(Vector3.Cross(v1 - v0, v2 - v0).normalized);
                upperNormals.Add(Vector3.Cross(v3 - v1, v0 - v1).normalized);

                var u = (float)i / (lowerRing.Count - 1);
                lowerUv.Add(new Vector2(u, 0));
                upperUv.Add(new Vector2(u, 1));
            }

            i0 = lowerRing.Count - 1;
            i1 = lowerRing.Count * 2 - 1;
            i2 = 0;
            i3 = lowerRing.Count;
            v0 = draft.vertices[i0];
            v1 = draft.vertices[i1];
            v2 = draft.vertices[i2];
            v3 = draft.vertices[i3];
            draft.triangles.AddRange(new[] { i0, i1, i2 });
            draft.triangles.AddRange(new[] { i2, i1, i3 });

            lowerNormals.Add(Vector3.Cross(v1 - v0, v2 - v0).normalized);
            upperNormals.Add(Vector3.Cross(v3 - v1, v0 - v1).normalized);
            draft.normals.AddRange(lowerNormals);
            draft.normals.AddRange(upperNormals);

            lowerUv.Add(new Vector2(1, 0));
            upperUv.Add(new Vector2(1, 1));
            draft.uv.AddRange(lowerUv);
            draft.uv.AddRange(upperUv);

            return(draft);
        }
        public static MeshDraft Sphere(float radius, int longitudeSegments, int latitudeSegments)
        {
            var draft = new MeshDraft {name = "Sphere"};

            float longitudeSegmentAngle = Mathf.PI*2/longitudeSegments;
            float latitudeSegmentAngle = Mathf.PI/latitudeSegments;

            float currentLatitude = -Mathf.PI/2;
            for (var ring = 0; ring <= latitudeSegments; ring++)
            {
                var currentLongitude = 0f;
                for (int i = 0; i < longitudeSegments; i++)
                {
                    var point = PTUtils.PointOnSphere(radius, currentLongitude, currentLatitude);
                    draft.vertices.Add(point);
                    draft.normals.Add(point.normalized);
                    draft.uv.Add(new Vector2((float) i/longitudeSegments, (float) ring/latitudeSegments));
                    currentLongitude -= longitudeSegmentAngle;
                }
                currentLatitude += latitudeSegmentAngle;
            }

            int i0, i1, i2, i3;
            for (int ring = 0; ring < latitudeSegments; ring++)
            {
                for (int i = 0; i < longitudeSegments - 1; i++)
                {
                    i0 = ring*longitudeSegments + i;
                    i1 = (ring + 1)*longitudeSegments + i;
                    i2 = ring*longitudeSegments + i + 1;
                    i3 = (ring + 1)*longitudeSegments + i + 1;
                    draft.triangles.AddRange(new[] {i0, i1, i2});
                    draft.triangles.AddRange(new[] {i2, i1, i3});
                }

                i0 = (ring + 1)*longitudeSegments - 1;
                i1 = (ring + 2)*longitudeSegments - 1;
                i2 = ring*longitudeSegments;
                i3 = (ring + 1)*longitudeSegments;
                draft.triangles.AddRange(new[] {i0, i1, i2});
                draft.triangles.AddRange(new[] {i2, i1, i3});
            }

            return draft;
        }
        /// <summary>
        /// Constructs a flat revolution surface draft
        /// </summary>
        public static MeshDraft FlatRevolutionSurface(
            Func <float, float, float, float, Vector3> surfaceFunction,
            float radius,
            float height,
            int horizontalSegments,
            int verticalSegments,
            bool generateUV = true)
        {
            float horizontalSegmentAngle = 360f / horizontalSegments;
            float verticalSegmentAngle   = 180f / verticalSegments;
            float currentVerticalAngle   = -90;
            int   horizontalCount        = horizontalSegments + 1;

            var ringsVertices = new List <List <Vector3> >(verticalSegments);
            var ringsUV       = new List <List <Vector2> >(verticalSegments);

            for (int y = 0; y <= verticalSegments; y++)
            {
                float currentHorizontalAngle = 0f;
                var   ringVertices           = new List <Vector3>(horizontalCount);
                var   ringUV = new List <Vector2>(horizontalCount);

                for (int x = 0; x <= horizontalSegments; x++)
                {
                    var point = surfaceFunction(radius, height, currentHorizontalAngle, currentVerticalAngle);
                    ringVertices.Add(point);
                    if (generateUV)
                    {
                        ringUV.Add(new Vector2(1 - (float)x / horizontalSegments, (float)y / verticalSegments));
                    }
                    currentHorizontalAngle += horizontalSegmentAngle;
                }
                ringsVertices.Add(ringVertices);
                ringsUV.Add(ringUV);
                currentVerticalAngle += verticalSegmentAngle;
            }

            var draft = new MeshDraft {
                name = "Flat revolution surface"
            };

            for (int y = 0; y < ringsVertices.Count - 1; y++)
            {
                var lowerRingVertices = ringsVertices[y];
                var upperRingVertices = ringsVertices[y + 1];
                var lowerRingUV       = ringsUV[y];
                var upperRingUV       = ringsUV[y + 1];
                for (int x = 0; x < horizontalSegments; x++)
                {
                    Vector3 v00  = lowerRingVertices[x + 1];
                    Vector3 v01  = upperRingVertices[x + 1];
                    Vector3 v11  = upperRingVertices[x];
                    Vector3 v10  = lowerRingVertices[x];
                    Vector2 uv00 = lowerRingUV[x + 1];
                    Vector2 uv01 = upperRingUV[x + 1];
                    Vector2 uv11 = upperRingUV[x];
                    Vector2 uv10 = lowerRingUV[x];
                    draft.AddQuad(v00, v01, v11, v10, uv00, uv01, uv11, uv10);
                }
            }
            return(draft);
        }
 /// <remarks>
 /// https://en.wikipedia.org/wiki/Triangle_strip
 /// </remarks>
 public static MeshDraft TriangleStrip(List<Vector3> vertices)
 {
     var draft = new MeshDraft
     {
         vertices = vertices,
         triangles = new List<int>(vertices.Count - 2),
         normals = new List<Vector3>(vertices.Count),
         uv = new List<Vector2>(vertices.Count),
         name = "TriangleStrip"
     };
     for (int i = 0, j = 1, k = 2; i < vertices.Count - 2; i++, j += i%2*2, k += (i + 1)%2*2)
     {
         draft.triangles.Add(i);
         draft.triangles.Add(j);
         draft.triangles.Add(k);
     }
     var normal = Vector3.Cross(vertices[1] - vertices[0], vertices[2] - vertices[0]).normalized;
     for (int i = 0; i < vertices.Count; i++)
     {
         draft.normals.Add(normal);
         draft.uv.Add(new Vector2((float) i/vertices.Count, (float) i/vertices.Count));
     }
     return draft;
 }
        /// <summary>
        /// Constructs a revolution surface draft
        /// </summary>
        public static MeshDraft RevolutionSurface(
            Func <float, float, float, float, Vector3> surfaceFunction,
            float radius,
            float height,
            int horizontalSegments,
            int verticalSegments,
            bool generateUV   = true,
            float domeDegrees = 0f)
        {
            var draft = new MeshDraft {
                name = "Revolution surface"
            };

            float horizontalSegmentAngle = 360f / horizontalSegments;
            float verticalSegmentAngle   = 180f / verticalSegments;
            float currentVerticalAngle   = -90;

            // Calculate vertical segments required if we need to build a dome
            if (domeDegrees != 0f)
            {
                verticalSegments = (int)(domeDegrees / (360f / verticalSegments));
            }

            int startY = 0;
            int endY   = verticalSegments;
            int stepY  = 1;

            for (int y = startY; (stepY == 1 ? y <= endY : y >= endY); y += stepY)
            {
                float currentHorizontalAngle = 0f;
                for (int x = 0; x <= horizontalSegments; x++)
                {
                    Vector3 point = surfaceFunction(radius, height, currentHorizontalAngle, currentVerticalAngle);
                    draft.vertices.Add(point);
                    draft.normals.Add(point.normalized);
                    if (generateUV)
                    {
                        draft.uv.Add(new Vector2((float)x / horizontalSegments, (float)y / verticalSegments));
                    }
                    currentHorizontalAngle -= horizontalSegmentAngle;
                }
                currentVerticalAngle += verticalSegmentAngle;
            }

            // Extra vertices due to the uvmap seam
            int horizontalCount = horizontalSegments + 1;

            for (int ring = (startY > 0 ? startY - 1 : startY); (stepY == 1 ? ring <endY : ring> endY); ring += stepY)
            {
                for (int i = 0; i < horizontalCount - 1; i++)
                {
                    int i0 = ring * horizontalCount + i;
                    int i1 = (ring + 1) * horizontalCount + i;
                    int i2 = ring * horizontalCount + i + 1;
                    int i3 = (ring + 1) * horizontalCount + i + 1;

                    draft.triangles.Add(i0);
                    draft.triangles.Add(i1);
                    draft.triangles.Add(i2);

                    draft.triangles.Add(i2);
                    draft.triangles.Add(i1);
                    draft.triangles.Add(i3);
                }
            }
            return(draft);
        }
        /// <summary>
        /// Constructs a partial box with specified faces
        /// </summary>
        public static MeshDraft PartialBox(Vector3 width, Vector3 length, Vector3 height, Directions parts, bool generateUV = true)
        {
            Vector3 v000 = -width / 2 - length / 2 - height / 2;
            Vector3 v001 = v000 + height;
            Vector3 v010 = v000 + width;
            Vector3 v011 = v000 + width + height;
            Vector3 v100 = v000 + length;
            Vector3 v101 = v000 + length + height;
            Vector3 v110 = v000 + width + length;
            Vector3 v111 = v000 + width + length + height;

            var draft = new MeshDraft {
                name = "Partial box"
            };

            if (generateUV)
            {
                Vector2 uv0 = new Vector2(0, 0);
                Vector2 uv1 = new Vector2(0, 1);
                Vector2 uv2 = new Vector2(1, 1);
                Vector2 uv3 = new Vector2(1, 0);

                if (parts.HasFlag(Directions.Left))
                {
                    draft.AddQuad(v100, v101, v001, v000, Vector3.left, uv0, uv1, uv2, uv3);
                }
                if (parts.HasFlag(Directions.Right))
                {
                    draft.AddQuad(v010, v011, v111, v110, Vector3.right, uv0, uv1, uv2, uv3);
                }
                if (parts.HasFlag(Directions.Down))
                {
                    draft.AddQuad(v010, v110, v100, v000, Vector3.down, uv0, uv1, uv2, uv3);
                }
                if (parts.HasFlag(Directions.Up))
                {
                    draft.AddQuad(v111, v011, v001, v101, Vector3.up, uv0, uv1, uv2, uv3);
                }
                if (parts.HasFlag(Directions.Back))
                {
                    draft.AddQuad(v000, v001, v011, v010, Vector3.back, uv0, uv1, uv2, uv3);
                }
                if (parts.HasFlag(Directions.Forward))
                {
                    draft.AddQuad(v110, v111, v101, v100, Vector3.forward, uv0, uv1, uv2, uv3);
                }
            }
            else
            {
                if (parts.HasFlag(Directions.Left))
                {
                    draft.AddQuad(v100, v101, v001, v000, Vector3.left);
                }
                if (parts.HasFlag(Directions.Right))
                {
                    draft.AddQuad(v010, v011, v111, v110, Vector3.right);
                }
                if (parts.HasFlag(Directions.Down))
                {
                    draft.AddQuad(v010, v110, v100, v000, Vector3.down);
                }
                if (parts.HasFlag(Directions.Up))
                {
                    draft.AddQuad(v111, v011, v001, v101, Vector3.up);
                }
                if (parts.HasFlag(Directions.Back))
                {
                    draft.AddQuad(v000, v001, v011, v010, Vector3.back);
                }
                if (parts.HasFlag(Directions.Forward))
                {
                    draft.AddQuad(v110, v111, v101, v100, Vector3.forward);
                }
            }
            return(draft);
        }
Beispiel #26
0
 public static Mesh Pyramid(float radius, int segments, float height, bool inverted = false)
 {
     return(MeshDraft.Pyramid(radius, segments, height, inverted).ToMesh());
 }