How to make a hexagon with quads

Hello, i’m trying to create a hexagon with quad but the hexagon looks like this:

This is the code:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class CreateQuads : MonoBehaviour {

    public Material cubeMaterial;

    enum Hexside {BOTTOM,BOTTOMLEFT,BOTTOMRIGHT,TOPLEFT,TOPRIGHT, TOP,  FRONT,FRONTLEFT,FRONTRIGHT, BACK,LEFT,RIGHT};

    void CreateQuad(Hexside side)
    {
        Mesh mesh = new Mesh();
        mesh.name = "ScriptedMesh" + side.ToString();

        Vector3[] vertices = new Vector3[4];
        Vector3[] normals = new Vector3[4];
        Vector2[] uvs = new Vector2[4];
        int[] triangles = new int[6];

        //all possible UVs
        Vector2 uv00 = new Vector2( 0f, 0f );
        Vector2 uv10 = new Vector2( 1f, 0f );
        Vector2 uv01 = new Vector2( 0f, 1f );
        Vector2 uv11 = new Vector2( 1f, 1f );

        //all possible vertices
      // BOTTOM
        Vector3 p0 = new Vector3( 0.5f,  0.0f,  -0.25f );
        Vector3 p1 = new Vector3(  0.25f,  -0.43f,  -0.25f );
        Vector3 p2 = new Vector3(  -0.25f,  -0.43f, -0.25f );
        Vector3 p3 = new Vector3( -0.5f,  0.0f, -0.25f );       
        Vector3 p4 = new Vector3( -0.25f,   0.43f,  -0.25f );
        Vector3 p5 = new Vector3(  0.25f,   0.43f,  -0.25f );
        //TOP
        Vector3 p6 = new Vector3(  0.5f,   -0.0f, 0.25f );
        Vector3 p7 = new Vector3( 0.25f,   -0.43f, 0.25f );
        Vector3 p8 = new Vector3( -0.25f,   -0.43f, 0.25f );
        Vector3 p9 = new Vector3( -0.5f,   -0.0f, 0.25f );
        Vector3 p10 = new Vector3( -0.25f,   0.43f, 0.25f );
        Vector3 p11 = new Vector3( 0.25f,   0.43f, 0.25f );

        switch(side)
        {
            case Hexside.BOTTOM:
                vertices = new Vector3[] {p0, p1, p3, p4};
                normals = new Vector3[] {Vector3.down, Vector3.down,
                                            Vector3.down, Vector3.down};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] { 3, 1, 0, 3, 2, 1};
            break;

            case Hexside.BOTTOMLEFT:
                vertices = new Vector3[] {p1, p2, p4, p5};
                normals = new Vector3[] {Vector3.down, Vector3.down,
                                            Vector3.down, Vector3.down};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] { 3, 1, 0, 3, 2, 1};
            break;

                 case Hexside.BOTTOMRIGHT:
                vertices = new Vector3[] {p2, p3, p5, p0};
                normals = new Vector3[] {Vector3.down, Vector3.down,
                                            Vector3.down, Vector3.down};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] { 3, 1, 0, 3, 2, 1};
            break;

            case Hexside.TOP:
                vertices = new Vector3[] {p10,p9,p7,p6};
                normals = new Vector3[] {Vector3.up, Vector3.up,
                                            Vector3.up, Vector3.up};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] {3, 1, 0, 3, 2, 1};
            break;

          
            case Hexside.TOPLEFT:
                vertices = new Vector3[] {p9,p8,p6,p11};
                normals = new Vector3[] {Vector3.up, Vector3.up,
                                            Vector3.up, Vector3.up};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] {3, 1, 0, 3, 2, 1};
            break;

             case Hexside.TOPRIGHT:
                vertices = new Vector3[] {p8,p7,p11,p10};
                normals = new Vector3[] {Vector3.up, Vector3.up,
                                            Vector3.up, Vector3.up};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] {3, 1, 0, 3, 2, 1};
            break;



            case Hexside.FRONTLEFT:
                vertices = new Vector3[] {p11, p6, p0, p5};
                normals = new Vector3[] {Vector3.left, Vector3.left,
                                            Vector3.left, Vector3.left};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] {3, 1, 0, 3, 2, 1};
            break;
            case Hexside.FRONTRIGHT:
                vertices = new Vector3[] {p7, p8, p2, p1};
                normals = new Vector3[] {Vector3.right, Vector3.right,
                                            Vector3.right, Vector3.right};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] {3, 1, 0, 3, 2, 1};
            break;

            case Hexside.FRONT:
                vertices = new Vector3[] {p6, p7, p1, p0};
                normals = new Vector3[] {Vector3.forward, Vector3.forward,
                                            Vector3.forward, Vector3.forward};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] {3, 1, 0, 3, 2, 1};
            break;

             case Hexside.LEFT:
                vertices = new Vector3[] {p10, p11, p5, p4};
                normals = new Vector3[] {Vector3.left, Vector3.left,
                                            Vector3.left, Vector3.left};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] {3, 1, 0, 3, 2, 1};
            break;

                case Hexside.RIGHT:
                vertices = new Vector3[] {p8, p9, p3, p2};
                normals = new Vector3[] {Vector3.right, Vector3.right,
                                            Vector3.right, Vector3.right};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] {3, 1, 0, 3, 2, 1};
            break;

            case Hexside.BACK:
                vertices = new Vector3[] {p9, p10, p4, p3};
                normals = new Vector3[] {Vector3.back, Vector3.back,
                                            Vector3.back, Vector3.back};
                uvs = new Vector2[] {uv11, uv01, uv00, uv10};
                triangles = new int[] {3, 1, 0, 3, 2, 1};
            break;
        }

        mesh.vertices = vertices;
        mesh.normals = normals;
        mesh.uv = uvs;
        mesh.triangles = triangles;
       
        mesh.RecalculateBounds();
      
        GameObject quad = new GameObject("Quad");
        quad.transform.parent = this.gameObject.transform;
         MeshFilter meshFilter = (MeshFilter) quad.AddComponent(typeof(MeshFilter));
        meshFilter.mesh = mesh;
        MeshRenderer renderer = quad.AddComponent(typeof(MeshRenderer)) as MeshRenderer;
        renderer.material = cubeMaterial;
    }

    void CombineQuads()
    {
      
        //1. Combine all children meshes
        MeshFilter[] meshFilters = GetComponentsInChildren<MeshFilter>();
        CombineInstance[] combine = new CombineInstance[meshFilters.Length];
        int i = 0;
        while (i < meshFilters.Length) {
            combine[i].mesh = meshFilters[i].sharedMesh;
            combine[i].transform = meshFilters[i].transform.localToWorldMatrix;
            i++;
        }

        //2. Create a new mesh on the parent object
        MeshFilter mf = (MeshFilter) this.gameObject.AddComponent(typeof(MeshFilter));
        mf.mesh = new Mesh();

        //3. Add combined meshes on children as the parent's mesh
        mf.mesh.CombineMeshes(combine);

        //4. Create a renderer for the parent
        MeshRenderer renderer = this.gameObject.AddComponent(typeof(MeshRenderer)) as MeshRenderer;
        renderer.material = cubeMaterial;

        //5. Delete all uncombined children
        foreach (Transform quad in this.transform) {
             Destroy(quad.gameObject);
         }

    }

    void CreateHex()
    {
        CreateQuad(Hexside.FRONT);
        CreateQuad(Hexside.BACK);
        CreateQuad(Hexside.TOP);
        CreateQuad(Hexside.TOPLEFT);
        CreateQuad(Hexside.TOPRIGHT);
        CreateQuad(Hexside.BOTTOM);
        CreateQuad(Hexside.BOTTOMLEFT);
        CreateQuad(Hexside.BOTTOMRIGHT);
        CreateQuad(Hexside.FRONTLEFT);
         CreateQuad(Hexside.FRONTRIGHT);
        CreateQuad(Hexside.LEFT);
        CreateQuad(Hexside.RIGHT);
        CombineQuads();
    }

    // Use this for initialization
    void Start () {
        CreateHex();
    }
  
    // Update is called once per frame
    void Update () {
      
    }
}

4782347--456296--Sin título.png

You may have specific need, for generating your hex-quad. But I would ask, just in case.
Can you not import already textured quad mesh with texture, from some external 3D software? For example blender? It would save a lot of time and effort.

Well, I can import a 3D FBX, but I want to learn to make some objects with code, that’s why i’m trying to make a hexagon.

Sure. If you that what you want / need.

Unfortunately I won’t be able to assist you on that matter.
I was playing with meshes / UV while ago. Now I am rusted :slight_smile:
Others will be more suitable on discussed topic.