示例#1
0
    /*
     * void GenerateCap(List<Vector3> vertices, List<Vector2> uvs, List<Vector3> normals, List<int> triangles)
     * {
     *  if (feature_info.s_feature == 1)//rectangle
     *  {
     *
     *      Vector3 center = (feature_info.rec[0] + feature_info.rec[2]) / 2;
     *
     *
     *      //bottom
     *      for(int i = 0; i < 4; i++)
     *      {
     *          vertices.Add(feature_info.rec[i]);
     *          normals.Add( -direct * feature_info.rec_plane.normal);
     *
     *      }
     *      uvs.Add(new Vector2(0.0f, 0.0f));
     *      uvs.Add(new Vector2(1.0f, 0.0f));
     *      uvs.Add(new Vector2(1.0f, 1.0f));
     *      uvs.Add(new Vector2(0.0f, 1.0f));
     *
     *
     *
     *      //top
     *      for (int i = 0; i < 4; i++)
     *      {
     *          vertices.Add(feature_info.rec[i]+length * feature_info.rec_plane.normal);
     *          normals.Add(direct * feature_info.rec_plane.normal);
     *
     *      }
     *
     *      uvs.Add(new Vector2(0.0f, 0.0f));
     *      uvs.Add(new Vector2(1.0f, 0.0f));
     *      uvs.Add(new Vector2(1.0f, 1.0f));
     *      uvs.Add(new Vector2(0.0f, 1.0f));
     *
     *      vertices.Add(center);
     *      uvs.Add(new Vector2(0.5f, 0.5f));
     *      normals.Add(-direct * feature_info.rec_plane.normal);
     *
     *      vertices.Add(center + length  * feature_info.rec_plane.normal);
     *      uvs.Add(new Vector2(0.5f, 0.5f));
     *      normals.Add(direct * feature_info.rec_plane.normal);
     *
     *      //direction: 1-positive, -1 -negative
     *      if (direct == 1)
     *      {
     *          //bottom
     *          int j = 0;
     *          for (int i = 0; i < 4; i++)
     *          {
     *              triangles.Add(8 + 1 * j);
     *              triangles.Add(i + 4 * j);
     *
     *              if (i != 3)
     *              {
     *                  triangles.Add(i + 1 + 4 * j);
     *              }
     *              else
     *              {
     *                  triangles.Add(0 + 4 * j);
     *              }
     *          }
     *
     *          //top
     *          j = 1;
     *          for (int i = 0; i < 4; i++)
     *          {
     *              triangles.Add(8 + 1 * j);
     *
     *              if (i != 3)
     *              {
     *                  triangles.Add(i + 1 + 4 * j);
     *              }
     *              else
     *              {
     *                  triangles.Add(0 + 4 * j);
     *              }
     *
     *              triangles.Add(i + 4 * j);
     *
     *          }
     *      }
     *      else
     *      {
     *          //bottom
     *          int j = 0;
     *          for (int i = 0; i < 4; i++)
     *          {
     *              triangles.Add(i + 4 * j);
     *              triangles.Add(8 + 1 * j);
     *
     *
     *              if (i != 3)
     *              {
     *                  triangles.Add(i + 1 + 4 * j);
     *              }
     *              else
     *              {
     *                  triangles.Add(0 + 4 * j);
     *              }
     *          }
     *
     *          //top
     *          j = 1;
     *          for (int i = 0; i < 4; i++)
     *          {
     *              triangles.Add(8 + 1 * j);
     *              triangles.Add(i + 4 * j);
     *
     *              if (i != 3)
     *              {
     *                  triangles.Add(i + 1 + 4 * j);
     *              }
     *              else
     *              {
     *                  triangles.Add(0 + 4 * j);
     *              }
     *
     *
     *
     *          }
     *      }
     *
     *
     *  }
     *  else if (feature_info.s_feature == 2)
     *  {
     *      int segments = 60;
     *      Vector3 temp;
     *
     *      float angle = 0.0f;
     *
     *      //bottom
     *      for (int i = 0; i < (segments); i++)
     *      {
     *          temp = feature_info.cir.center + Mathf.Cos(Mathf.Deg2Rad * angle) * feature_info.cir.radius.x * feature_info.cir.cir_plane.u + Mathf.Sin(Mathf.Deg2Rad * angle) * feature_info.cir.radius.y * feature_info.cir.cir_plane.v;
     *          vertices.Add(temp);
     *          uvs.Add(new Vector2((float)i / (segments - 1), 0.0f));
     *
     *          //normals.Add(new Vector3(0,0,1));
     *          normals.Add(-direct * feature_info.cir.cir_plane.normal);
     *
     *          angle += (360f / segments);
     *      }
     *      //top
     *      angle = 0.0f;
     *      for (int i = 0; i < (segments); i++)
     *      {
     *          temp = feature_info.cir.center + Mathf.Cos(Mathf.Deg2Rad * angle) * feature_info.cir.radius.x * feature_info.cir.cir_plane.u + Mathf.Sin(Mathf.Deg2Rad * angle) * feature_info.cir.radius.y * feature_info.cir.cir_plane.v;
     *          temp = temp + +length  * feature_info.cir.cir_plane.normal;
     *          vertices.Add(temp);
     *          uvs.Add(new Vector2((float)i / (segments - 1), 1.0f));
     *          normals.Add(direct * feature_info.cir.cir_plane.normal);
     *
     *          angle += (360f / segments);
     *      }
     *
     *      vertices.Add(feature_info.cir.center);
     *      uvs.Add(new Vector2(0.5f, 0.5f));
     *      //normals.Add(new Vector3(0, 0, 1));
     *      normals.Add(-direct * feature_info.cir.cir_plane.normal);
     *
     *      vertices.Add(feature_info.cir.center + length  * feature_info.cir.cir_plane.normal);
     *      uvs.Add(new Vector2(0.5f, 0.5f));
     *      normals.Add(direct * feature_info.cir.cir_plane.normal);
     *
     *      //
     *
     *      //direction: 1-positive, -1 -negative
     *      if (direct == 1)
     *      {
     *          for (int i = 0; i < segments; i++)
     *          {
     *              triangles.Add(2 * segments);
     *              if (i + 1 != segments)
     *              {
     *                  triangles.Add(i + 1);
     *              }
     *              else
     *              {
     *                  triangles.Add(0);
     *              }
     *              triangles.Add(i);
     *          }
     *
     *          for (int i = 0; i < segments; i++)
     *          {
     *              triangles.Add(2 * segments + 1);
     *              triangles.Add(segments + i);
     *
     *              if (i + 1 != segments)
     *              {
     *                  triangles.Add(segments + i + 1);
     *              }
     *              else
     *              {
     *                  triangles.Add(segments);
     *              }
     *
     *
     *
     *          }
     *      }
     *      else
     *      {
     *          for (int i = 0; i < segments; i++)
     *          {
     *              triangles.Add(2 * segments);
     *              triangles.Add(i);
     *              if (i + 1 != segments)
     *              {
     *                  triangles.Add(i + 1);
     *              }
     *              else
     *              {
     *                  triangles.Add(0);
     *              }
     *
     *          }
     *
     *          for (int i = 0; i < segments; i++)
     *          {
     *              triangles.Add(segments + i);
     *              triangles.Add(2 * segments + 1);
     *
     *
     *              if (i + 1 != segments)
     *              {
     *                  triangles.Add(segments + i + 1);
     *              }
     *              else
     *              {
     *                  triangles.Add(segments);
     *              }
     *
     *
     *
     *          }
     *      }
     *
     *
     *  }
     * }
     *
     * void GenerateSide(List<Vector3> vertices, List<Vector2> uvs, List<Vector3> normals, List<int> triangles)
     * {
     *  if (feature_info.s_feature == 1)//rectangle
     *  {
     *      for(int i = 0; i < 4; i++)
     *      {
     *          if (i != 3)
     *          {
     *              vertices.Add(vertices[i]);
     *              vertices.Add(vertices[i + 1]);
     *              vertices.Add(vertices[i + 4]);
     *              vertices.Add(vertices[i + 1 + 4]);
     *
     *              uvs.Add(new Vector2(0.0f, 0.0f));
     *              uvs.Add(new Vector2(1.0f, 0.0f));
     *              uvs.Add(new Vector2(1.0f, 1.0f));
     *              uvs.Add(new Vector2(0.0f, 1.0f));
     *
     *              Vector3 tot_normal = Vector3.Cross(vertices[i + 1] - vertices[i], vertices[i + 4] - vertices[i]);
     *              normals.Add(tot_normal);
     *              normals.Add(tot_normal);
     *              normals.Add(tot_normal);
     *              normals.Add(tot_normal);
     *
     *              //direction: 1-positive, -1 -negative
     *              if (direct == 1)
     *              {
     *                  triangles.Add(10 + i * 4);
     *                  triangles.Add(10 + i * 4 + 2);
     *                  triangles.Add(10 + i * 4 + 1);
     *
     *
     *                  triangles.Add(10 + i * 4 + 2);
     *                  triangles.Add(10 + i * 4 + 3);
     *                  triangles.Add(10 + i * 4 + 1);
     *              }
     *              else
     *              {
     *                  triangles.Add(10 + i * 4);
     *                  triangles.Add(10 + i * 4 + 1);
     *                  triangles.Add(10 + i * 4 + 2);
     *
     *
     *                  triangles.Add(10 + i * 4 + 2);
     *                  triangles.Add(10 + i * 4 + 1);
     *                  triangles.Add(10 + i * 4 + 3);
     *              }
     *
     *
     *          }
     *
     *          else
     *          {
     *              vertices.Add(vertices[i]);
     *              vertices.Add(vertices[0]);
     *              vertices.Add(vertices[i + 4]);
     *              vertices.Add(vertices[0+ 4]);
     *
     *              uvs.Add(new Vector2(0.0f, 0.0f));
     *              uvs.Add(new Vector2(1.0f, 0.0f));
     *              uvs.Add(new Vector2(1.0f, 1.0f));
     *              uvs.Add(new Vector2(0.0f, 1.0f));
     *
     *              Vector3 tot_normal = Vector3.Cross(vertices[0] - vertices[i], vertices[i + 4] - vertices[i]);
     *              normals.Add(tot_normal);
     *              normals.Add(tot_normal);
     *              normals.Add(tot_normal);
     *              normals.Add(tot_normal);
     *
     *              //direction: 1-positive, -1 -negative
     *              if (direct == 1)
     *              {
     *                  triangles.Add(10 + i * 4);
     *                  triangles.Add(10 + i * 4 + 2);
     *                  triangles.Add(10 + i * 4 + 1);
     *
     *
     *                  triangles.Add(10 + i * 4 + 2);
     *                  triangles.Add(10 + i * 4 + 3);
     *                  triangles.Add(10 + i * 4 + 1);
     *              }
     *              else
     *              {
     *                  triangles.Add(10 + i * 4);
     *
     *                  triangles.Add(10 + i * 4 + 1);
     *                  triangles.Add(10 + i * 4 + 2);
     *
     *
     *                  triangles.Add(10 + i * 4 + 2);
     *
     *                  triangles.Add(10 + i * 4 + 1);
     *                  triangles.Add(10 + i * 4 + 3);
     *              }
     *
     *
     *          }
     *
     *      }
     *
     *
     *  }
     *  else if (feature_info.s_feature == 2)
     *  {
     *      int segments = 60;
     *      Vector3 temp;
     *
     *      float angle = 0.0f;
     *
     *      //bottom
     *      for (int i = 0; i < (segments); i++)
     *      {
     *          temp = feature_info.cir.center + Mathf.Cos(Mathf.Deg2Rad * angle) * feature_info.cir.radius.x * feature_info.cir.cir_plane.u + Mathf.Sin(Mathf.Deg2Rad * angle) * feature_info.cir.radius.y * feature_info.cir.cir_plane.v;
     *          vertices.Add(temp);
     *          uvs.Add(new Vector2((float)i / (segments - 1), 0.0f));
     *          normals.Add(Mathf.Cos(Mathf.Deg2Rad * angle) * feature_info.cir.cir_plane.u + Mathf.Sin(Mathf.Deg2Rad * angle) * feature_info.cir.cir_plane.v);
     *
     *          angle += (360f / segments);
     *      }
     *      //top
     *      angle = 0.0f;
     *      for (int i = 0; i < (segments); i++)
     *      {
     *          temp = feature_info.cir.center + Mathf.Cos(Mathf.Deg2Rad * angle) * feature_info.cir.radius.x * feature_info.cir.cir_plane.u + Mathf.Sin(Mathf.Deg2Rad * angle) * feature_info.cir.radius.y * feature_info.cir.cir_plane.v;
     *          temp = temp + +length * feature_info.cir.cir_plane.normal;
     *          vertices.Add(temp);
     *          uvs.Add(new Vector2((float)i / (segments - 1), 1.0f));
     *          normals.Add(Mathf.Cos(Mathf.Deg2Rad * angle) * feature_info.cir.cir_plane.u + Mathf.Sin(Mathf.Deg2Rad * angle) * feature_info.cir.cir_plane.v);
     *
     *          angle += (360f / segments);
     *      }
     *
     *      //direction: 1-positive, -1 -negative
     *      if (direct == 1)
     *      {
     *          for (int i = 0; i < (segments); i++)
     *          {
     *              triangles.Add(i +2*(segments+1));
     *              if (i + 1 != segments)
     *              {
     *                  triangles.Add(i + 1 + 2 * (segments + 1));
     *              }
     *              else
     *              {
     *                  triangles.Add(0 + 2 * (segments + 1));
     *              }
     *              triangles.Add(i + segments + 2 * (segments + 1));
     *
     *              if (i + 1 != segments)
     *              {
     *                  triangles.Add(i + 1 + 2 * (segments + 1));
     *                  triangles.Add(i + 1 + segments + 2 * (segments + 1));
     *              }
     *              else
     *              {
     *                  triangles.Add(0 + 2 * (segments + 1));
     *                  triangles.Add(0 + segments + 2 * (segments + 1));
     *              }
     *
     *              triangles.Add(i + segments + 2 * (segments + 1));
     *          }
     *      }
     *      else
     *      {
     *          for (int i = 0; i < (segments); i++)
     *          {
     *
     *              if (i + 1 != segments)
     *              {
     *                  triangles.Add(i + 1 + 2 * (segments + 1));
     *              }
     *              else
     *              {
     *                  triangles.Add(0 + 2 * (segments + 1));
     *              }
     *              triangles.Add(i + 2 * (segments + 1));
     *              triangles.Add(i + segments + 2 * (segments + 1));
     *
     *              if (i + 1 != segments)
     *              {
     *
     *                  triangles.Add(i + 1 + segments + 2 * (segments + 1));
     *                  triangles.Add(i + 1 + 2 * (segments + 1));
     *              }
     *              else
     *              {
     *
     *                  triangles.Add(0 + segments + 2 * (segments + 1));
     *                  triangles.Add(0 + 2 * (segments + 1));
     *              }
     *
     *              triangles.Add(i + segments + 2 * (segments + 1));
     *          }
     *      }
     *
     *
     *  }
     * }
     *
     */

    Vector3[] calculate_position(line_def sketch)
    {
        Vector3[] pos;
        if (sketch.type == 0) //rectangle
        {
            pos = new Vector3[4];

            pos[0] = sketch.center - sketch.plane.u * sketch.radius.x + sketch.plane.v * sketch.radius.y;
            pos[1] = sketch.center - sketch.plane.u * sketch.radius.x - sketch.plane.v * sketch.radius.y;
            pos[2] = sketch.center + sketch.plane.u * sketch.radius.x - sketch.plane.v * sketch.radius.y;
            pos[3] = sketch.center + sketch.plane.u * sketch.radius.x + sketch.plane.v * sketch.radius.y;
        }
        else //circle: sketch.type == 1
        {
            int segments = 60;
            pos = new Vector3[segments];

            Vector3 temp;

            float angle = 0.0f;

            for (int i = 0; i < (segments); i++)
            {
                temp = sketch.center + Mathf.Cos(Mathf.Deg2Rad * angle) * sketch.radius.x * sketch.plane.u + Mathf.Sin(Mathf.Deg2Rad * angle) * sketch.radius.y * sketch.plane.v;
                pos[segments - i - 1] = temp;

                angle += (360f / segments);
            }
        }

        return(pos);
    }
示例#2
0
    void Update()
    {
        //var mesh = new Mesh(); //rendering 할꺼.
        temp = new solid_def();

        if (feature_info.m_mode == 3)
        {
            if (feature_info.line_collect.Count > 0)
            {
                feature_info.selected_line_num = 0; //첫번째 라인 선택.
            }

            switch (feature_info.s_mode)
            {
            case 0:
                text_length.text = "";
                break;

            case 1:     //extrusion

                info.text = "extrusion";

                //input: parent, direct, length

                if (feature_info.line_collect.Count > 0)     //수정 필요.
                {
                    //length value
                    length           = length_save + touch_info.length_v;
                    text_length.text = "Length= " + Mathf.Round(length * 10) * 0.1f;

                    if (touch_info.touch1 == 1)
                    {
                        length_save = length;
                    }

                    //mesh generation
                    temp.type   = 0;
                    temp.parent = feature_info.line_collect[0];      //수정 필요.

                    Filter.sharedMesh = Build(temp.parent, length, temp.faces);
                    temp.mesh         = Build(temp.parent, length, temp.faces);

                    info.text = "v:" + temp.mesh.vertices.Length + " uv:" + temp.mesh.uv.Length + "  n:" + temp.mesh.normals.Length + "  t:" + temp.mesh.triangles.Length;
                }

                break;

            case 2:     //cut extrusion
                text_length.text = "Length=";

                if (feature_info.solid_collect.Count > 0 && feature_info.line_collect.Count > 0)     //수정 필요.
                {
                    temp.type = 1;
                }
                break;

            default:
                text_length.text = "";
                break;
            }
        }
        else
        {
            text_length.text = "";
        }
    }