private void CreateCube()
    {
        this.name = "Diamond";

        MeshFilter meshFilter = GetComponent <MeshFilter>();

        if (meshFilter == null)
        {
            Debug.LogError("MeshFilter not found!");
            return;
        }

        Mesh mesh = meshFilter.sharedMesh;

        //mesh = meshFilter.mesh;
        if (mesh == null)
        {
            meshFilter.mesh = new Mesh();
            mesh            = meshFilter.sharedMesh;
            //mesh = meshFilter.mesh;
        }

        mesh.Clear();

        //cube details
        Vector3 v0 = new Vector3(-toplengthX, toplengthY, toplengthZ);         //left (top, front, left)
        Vector3 v1 = new Vector3(toplengthX, toplengthY, toplengthZ);          //right (top, front, right)
        Vector3 v2 = new Vector3(toplengthX, toplengthY, -toplengthZ);         //right (top, back, right)
        Vector3 v3 = new Vector3(-toplengthX, toplengthY, -toplengthZ);        //left (top, back, left)

        Vector3 v4 = new Vector3(-midlengthX, midlengthY, midlengthZ);         //left (mid, front, left)
        Vector3 v5 = new Vector3(midlengthX, midlengthY, midlengthZ);          //right (mid, front, right)
        Vector3 v6 = new Vector3(midlengthX, midlengthY, -midlengthZ);         //right (mid, back, right)
        Vector3 v7 = new Vector3(-midlengthX, midlengthY, -midlengthZ);        //left (mid, back, left)


        Vector3 v8  = new Vector3(-bottomlengthX, -bottomlengthY, bottomlengthZ);         //left (bottom, front, left)
        Vector3 v9  = new Vector3(bottomlengthX, -bottomlengthY, bottomlengthZ);          //right (bottom, front, right)
        Vector3 v10 = new Vector3(bottomlengthX, -bottomlengthY, -bottomlengthZ);         //right (bottom, back, right)
        Vector3 v11 = new Vector3(-bottomlengthX, -bottomlengthY, -bottomlengthZ);        //left (bottom, back, left)


        //Add region Vertices
        mesh.vertices = new Vector3[] {
            // top Front face
            v0, v1, v4, v5,

            // top Back face
            v2, v3, v6, v7,

            // top Left face
            v3, v0, v7, v4,

            // top Right face
            v1, v2, v5, v6,



            // bottom Front face
            v4, v5, v8, v9,


            // bottom Back face
            v6, v7, v10, v11,

            // bottom Left face
            v7, v4, v11, v8,

            // bottom Right face
            v5, v6, v9, v10,



            // Top face
            v3, v2, v0, v1,

            // Bottom face
            v8, v9, v11, v10
        };
        //end vertices region

        //Add Triangles region
        //these are three point, and work clockwise to determine what side is visible
        mesh.triangles = new int[] {
            // top front face
            0, 2, 3,           // first triangle
            3, 1, 0,           // second triangle

            // top back face
            4, 6, 7,           // first triangle
            7, 5, 4,           // second triangle

            // top left face
            8, 10, 11,          // first triangle
            11, 9, 8,           // second triangle

            // top right face
            12, 14, 15,           // first triangle
            15, 13, 12,           // second triangle


            //bottom front face
            16, 18, 19,           // first triangle
            19, 17, 16,           // second triangle

            //bottom back face
            20, 22, 23,           // first triangle
            23, 21, 20,           // second triangle

            //bottom left face
            24, 26, 27,           // first triangle
            27, 25, 24,           // second triangle

            //bottom right face
            28, 30, 31,           // first triangle
            31, 29, 28,           // second triangle



            //top face
            32, 34, 35,           // first triangle
            35, 33, 32,           // second triangle

            //bottom face
            36, 38, 39,          // first triangle
            39, 37, 36           // second triangle
        };
        //end triangles region


        //Normales vector3 region
        Vector3 front = Vector3.forward;
        Vector3 back  = Vector3.back;
        Vector3 left  = Vector3.left;
        Vector3 right = Vector3.right;
        Vector3 up    = Vector3.up;
        Vector3 down  = Vector3.down;

        //Add Normales region
        mesh.normals = new Vector3[]
        {
            // top Front face
            front, front, front, front,

            // top Back face
            back, back, back, back,

            // top Left face
            left, left, left, left,

            // top Right face
            right, right, right, right,


            // bottom Front face
            front, front, front, front,

            // bottom Back face
            back, back, back, back,

            // bottom Left face
            left, left, left, left,

            // bottom Right face
            right, right, right, right,



            // Top face
            up, up, up, up,

            // Bottom face
            down, down, down, down
        };
        //end Normales region

        //Add vector2 regions
        Vector2 u00 = new Vector2(0f, 0f);
        Vector2 u10 = new Vector2(1f, 0f);
        Vector2 u01 = new Vector2(0f, 1f);
        Vector2 u11 = new Vector2(1f, 1f);

        //Add UVs region
        mesh.uv = new Vector2[]
        {
            // Front face uv
            u01, u00, u11, u10,

            // Back face uv
            u01, u00, u11, u10,

            // Left face uv
            u01, u00, u11, u10,

            // Right face uv
            u01, u00, u11, u10,



            // Front face uv
            u01, u00, u11, u10,

            // Back face uv
            u01, u00, u11, u10,

            // Left face uv
            u01, u00, u11, u10,

            // Right face uv
            u01, u00, u11, u10,


            // Top face uv
            u01, u00, u11, u10,

            // Bottom face uv
            u01, u00, u11, u10
        };
        //End UVs region


//		Texture texture = Resources.Load ("TextureComplete1") as Texture;
//		material.mainTexture = texture;


        mesh.RecalculateNormals();
        mesh.RecalculateBounds();
        CalculateTangent.TangentSolver(mesh);
        mesh.Optimize();


        MeshRenderer renderer = GetComponent <MeshRenderer> ();

        renderer.material.color = color;


//		MeshCollider meshCollider = GetComponent(typeof(MeshCollider)) as MeshCollider;
//		meshCollider.sharedMesh = mesh; // Give it your mesh here.
//
        boxCollider        = gameObject.AddComponent <BoxCollider>();
        boxCollider.center = Vector3.zero;
        //Vector3 tempSize = boxCollider.size * 1.5f;
        //boxCollider.size = tempSize;

        //meshCollider = GetComponent<BoxCollider>();
        //meshCollider.size = new Vector3(xSize, ySize, zSize);
        //meshCollider.center = new Vector3 ((float)xSize/2, (float)ySize/2, (float)zSize/2);
    }
    private void CreateTorusKnot()
    {
        List <Vector2> uvs       = new List <Vector2>();
        List <Vector3> vertices  = new List <Vector3>();
        List <Vector3> normals   = new List <Vector3>();
        List <int>     triangles = new List <int>();

        var center = new Vector3();

        int[][] grid = new int[radialSegments][];

        var tang  = new Vector3();
        var n     = new Vector3();
        var bitan = new Vector3();


        MeshFilter filter = GetComponent <MeshFilter>();

        if (filter == null)
        {
            Debug.LogError("MeshFilter not found!");
            return;
        }

        Mesh mesh = filter.sharedMesh;

        if (mesh == null)
        {
            filter.mesh = new Mesh();
            mesh        = filter.sharedMesh;
        }
        mesh.name = "TorusKnotMesh";
        mesh.Clear();


        for (var i = 0; i < radialSegments; ++i)
        {
            grid[i] = new int[tubularSegments];
            var u  = i / (float)radialSegments * 2.0f * p * Mathf.PI;
            var p1 = GetPos(u, q, p, radius, heightScale);
            var p2 = GetPos(u + 0.01f, q, p, radius, heightScale);
            tang = p2 - p1;
            n    = p2 + p1;

            bitan = Vector3.Cross(tang, n);
            n     = Vector3.Cross(bitan, tang);
            bitan.Normalize();
            n.Normalize();

            for (var j = 0; j < tubularSegments; ++j)
            {
                var v  = j / (float)tubularSegments * 2.0f * Mathf.PI;
                var cx = -tube *Mathf.Cos(v);

                var cy = tube * Mathf.Sin(v);

                var vertex = new Vector3();
                vertex.x = p1.x + cx * n.x + cy * bitan.x;
                vertex.y = p1.y + cx * n.y + cy * bitan.y;
                vertex.z = p1.z + cx * n.z + cy * bitan.z;

                vertices.Add(vertex);
                uvs.Add(new Vector2(i / (float)radialSegments, j / (float)tubularSegments));

                Vector3 normal = vertex - center;
                normal.Normalize();
                normals.Add(normal);

                grid[i][j] = vertices.Count - 1;
            }
        }

        for (var i = 0; i < radialSegments; ++i)
        {
            for (var j = 0; j < tubularSegments; ++j)
            {
                var ip = (i + 1) % radialSegments;
                var jp = (j + 1) % tubularSegments;

                var a = grid[i][j];
                var b = grid[ip][j];
                var c = grid[ip][jp];
                var d = grid[i][jp];

                triangles.Add(a);
                triangles.Add(b);
                triangles.Add(d);

                triangles.Add(b);
                triangles.Add(c);
                triangles.Add(d);
            }
        }



        mesh.vertices  = vertices.ToArray();
        mesh.normals   = normals.ToArray();
        mesh.uv        = uvs.ToArray();
        mesh.triangles = triangles.ToArray();

        mesh.RecalculateNormals();
        CalculateTangent.TangentSolver(mesh);

        mesh.RecalculateBounds();
        mesh.Optimize();

        //MeshRenderer renderer = GetComponent<MeshRenderer> ();
        //renderer.material.color = color;

        CreateCollider(mesh);
    }