Пример #1
0
    static Mesh mesh(int N = 4)
    {
        Node[,] nodes_2D = new Node[2, N + 1];
        Vector3 dir   = Vector3.up,
                start = Vector3.right;

        float a_s = 360f / N;

        for (int x = 0; x <= 1; x += 1)
        {
            Vector3 o = dir * x;

            for (int y = 0; y <= N; y += 1)
            {
                Vector3 v = Z.Rotate(start, -dir, a_s * y);
                nodes_2D[x, y] = new Node()
                {
                    pos  = o + v,
                    wrap = new Vector2(x, 0)
                };
            }
        }

        return(MESH.mesh(nodes_2D));
    }
Пример #2
0
    public static Mesh mesh(int N = 32)
    {
        #region Ball

        /*
         * Vector3 a = Vector3.right,
         * b = Vector3.up,
         * K = -Vector3.forward;
         *
         * Node[,] nodes_2D = new Node[N + 1, N + 1];
         * float A_s = 180f / N,
         *    a_s = 2f * A_s;
         *
         * for (int y = 0; y <= N; y += 1)
         * {
         *  Vector3 V = Z.Rotate(-b, K, y * A_s);
         *  float _x = Z.dot(V, a),
         *        _y = Z.dot(V, b);
         *
         *  for (int x = 0; x <= N; x += 1)
         *  {
         *      Vector3 pos = Z.Rotate(a, b, x * a_s);
         *
         *      nodes_2D[x, y] = new Node()
         *      {
         *          pos = pos * _x + b * _y,
         *          wrap = new Vector2(x, y) / N
         *      };
         *  }
         * }
         */
        #endregion


        float[] R = new float[3]
        {
            0f, 0.7f, 1f
        };
        int l = R.Length - 1;

        Node[,] nodes_2D = new Node[l + 1, N + 1];

        Vector3 k     = Vector3.forward,
                start = Vector3.up;
        float a_s     = 360f / N;

        for (int x = 0; x <= l; x += 1)
        {
            for (int y = 0; y <= N; y += 1)
            {
                Vector3 pos = Z.Rotate(start, -k, a_s * y);

                nodes_2D[x, y] = new Node()
                {
                    pos  = pos * R[x],
                    wrap = new Vector2(x, 0) / l
                };
            }
        }

        return(MESH.mesh(nodes_2D));
    }