Vector3[] CreateVertices(int corners)
    {
        int pl = points.Count;
        int numOfSplits; // min number of vertex splitting for disconected surfaces
        int v;           // number of vertices needed for the mesh

        if (corners % 2 == 1)
        {
            // then the shape has an odd number of corners (eg triangular, pentagonal)
            //  so there must be four splits
            numOfSplits = 4;
            v           = (pl * 2) * 4;
        }
        else
        {
            numOfSplits = 3;
            v           = (pl * 2) * 3;
        }

        Vector3[] vertices_ = new Vector3[v];
        if (verbose)
        {
            Debug.Log("Number of vertices_: " + v);
        }

        // split the vertices to have hard edges between surfaces
        Vector3[] verticesTemp = new Vector3[pl * 2];
        for (int i = 0; i < pl; i++)
        {
            // for the top of the column
            verticesTemp[i] = points[i];

            // for the bottom of the column
            Vector3 p = new Vector3(points[i].x,
                                    points[i].y - columnLength,
                                    points[i].z);
            verticesTemp[i + pl] = p;
        }

        if (numOfSplits == 4)
        {
            vertices_ = verticesTemp.Concat(verticesTemp).Concat(verticesTemp).Concat(verticesTemp).ToArray();
        }
        else
        {
            vertices_ = verticesTemp.Concat(verticesTemp).Concat(verticesTemp).ToArray();
        }

        return(vertices_);
    }
Exemplo n.º 2
0
        private void UpdateBindings()
        {
            bool         flag1         = false;
            ushort       extractorID   = GetFishExtractorID();
            ushort       fishFarmID    = BuildingExtension.GetFishFarm(extractorID);
            BuildingInfo extractorInfo = BuildingManager.instance.m_buildings.m_buffer[extractorID].Info;
            BuildingInfo fishFarmInfo  = BuildingManager.instance.m_buildings.m_buffer[fishFarmID].Info;

            ItemClass.Service service = fishFarmInfo.GetService();
            BuildingExtension.FishItemClass fishfarm = new BuildingExtension.FishItemClass(service);
            if (!FishFarmUtil.IsValidFishFarm(fishFarmID))
            {
                flag1 = true;
            }
            if (flag1 || _updateFishFarms[fishfarm])
            {
                PopulateFishFarmDropDown(extractorInfo, fishFarmInfo);
                _updateFishFarms[fishfarm] = false;
            }
            if (_fishFarmDropDown.Items.Length == 0)
            {
                _fishFarmDropDown.Text = "No fish farm found.";
            }
            else
            {
                _fishFarmDropDown.SelectedItem = fishFarmID;
            }
            Vector3[] extractor_pos_arr = new Vector3[BuildingExtension._extractorData.Length];
            BuildingExtension._extractorData.ForEach <BuildingExtension.ExtractorData>(item => {
                extractor_pos_arr = extractor_pos_arr.Concat <Vector3>(new Vector3[] { item.Position }).ToArray();
            });
            m_extractionPositions = extractor_pos_arr;
        }
        /// <summary>
        /// Gets the vertices.
        /// </summary>
        /// <returns>The vertices.</returns>
        Vector3[] GetVertices(Transform trans, List <Vector3> points, float thickness, AXIS axis = AXIS.Y, int vertexPerSide = 4)
        {
            int sideVertexCount = GetVertexCount(points.Count, vertexPerSide);

            //All the vertices with thickness
            Vector3[] _vertices = new Vector3[(2 * points.Count) + sideVertexCount];

            //Top Vertices
            Vector3[] _topVertices = new Vector3[points.Count];
            for (int i = 0; i < points.Count; i++)
            {
                _topVertices[i] = trans.InverseTransformPoint(points[i]);
            }

            //Bottom Vertices
            Vector3[] _bottomVertices = new Vector3[points.Count];
            for (int i = 0; i < points.Count; i++)
            {
                if (axis == AXIS.X)
                {
                    _bottomVertices[i] = trans.InverseTransformPoint(new Vector3(points[i].x - thickness, points[i].y, points[i].z));
                }
                else if (axis == AXIS.Y)
                {
                    _bottomVertices[i] = trans.InverseTransformPoint(new Vector3(points[i].x, points[i].y - thickness, points[i].z));
                }
                else if (axis == AXIS.Z)
                {
                    _bottomVertices[i] = trans.InverseTransformPoint(new Vector3(points[i].x, points[i].y, points[i].z + thickness));
                }
            }

            //Side Vertices
            Vector3[] _sideVertices = new Vector3[sideVertexCount];
            int       _vertexIndex  = 0;

            for (int point = 0; point < points.Count; point++)
            {
                int nextPoint = point + 1;
                if (nextPoint == points.Count)
                {
                    nextPoint = 0;
                }

                //For every side quads, create side vertices
                //Side vertices are arranged like topvertex(0,1),botvertex(0,1) to get quad
                _sideVertices[_vertexIndex]     = _topVertices[point];
                _sideVertices[_vertexIndex + 1] = _topVertices[nextPoint];
                _sideVertices[_vertexIndex + 2] = _bottomVertices[point];
                _sideVertices[_vertexIndex + 3] = _bottomVertices[nextPoint];
                _vertexIndex += 4;
            }

            _vertices = (_topVertices.Concat(_bottomVertices).Concat(_sideVertices)).ToArray();

            return(_vertices);
        }
Exemplo n.º 4
0
    public static void CombinePointMeshes()
    {
        var go = Selection.activeGameObject;

        if (go == null)
        {
            return;
        }
        go.transform.position = Vector3.zero;


        var mfs    = go.GetComponentsInChildren <MeshFilter> ().ToArray();
        var vCount = mfs.Select(b => b.sharedMesh.vertexCount).Sum();

        Vector3[] vertices = new Vector3[0];
        Vector2[] uv2      = new Vector2[0];
        Color[]   colors   = new Color[0];
        int[]     indeces  = new int[vCount];
        for (var i = 0; i < vCount; i++)
        {
            indeces [i] = i;
        }

        for (int i = 0; i < mfs.Length; i++)
        {
            var mf = mfs [i];
            var m  = mf.mesh;
            var vs = m.vertices.Select(b => mf.transform.TransformPoint(b)).ToArray();
            vertices = vertices.Concat(vs).ToArray();
            uv2      = uv2.Concat(m.uv2).ToArray();
            colors   = colors.Concat(m.colors).ToArray();
        }

        var mesh = new Mesh();

        mesh.vertices = vertices;
        mesh.uv2      = uv2;
        mesh.colors   = colors;
        mesh.SetIndices(indeces, MeshTopology.Points, 0);

        AssetDatabase.CreateAsset(mesh, string.Format("Assets/{0}_combine.asset", go.name));
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();

        new GameObject("mesh", typeof(MeshFilter), typeof(MeshRenderer)).GetComponent <MeshFilter> ().mesh = mesh;
    }
Exemplo n.º 5
0
    // Update is called once per frame
    void Update()
    {
        int mask   = LayerMask.GetMask("Wall");
        var blocks = Physics2D.CircleCastAll(this.transform.position, 10.0f, Vector2.zero, mask);
        //获取阻挡物上的点
        var points = blocks
                     .Select(rh => rh.collider as BoxCollider2D)
                     .Where(bx => bx != null)
                     .SelectMany(bx =>
        {
            Vector2[] pts = new Vector2[8];
            var temp      = bx.size;
            temp.y        = -temp.y;
            //转换到世界坐标
            pts[0] = bx.transform.TransformPoint(bx.offset + bx.size / 2.001f);
            pts[1] = bx.transform.TransformPoint(bx.offset - bx.size / 2.001f);
            pts[2] = bx.transform.TransformPoint(bx.offset + temp / 2.001f);
            pts[3] = bx.transform.TransformPoint(bx.offset - temp / 2.001f);
            pts[4] = bx.transform.TransformPoint(bx.offset + bx.size / 1.999f);
            pts[5] = bx.transform.TransformPoint(bx.offset - bx.size / 1.999f);
            pts[6] = bx.transform.TransformPoint(bx.offset + temp / 1.999f);
            pts[7] = bx.transform.TransformPoint(bx.offset - temp / 1.999f);
            return(pts);
        });

        //填充边界点,BorderDentisy表示边界一共有多少点。值越大,阴影越圆滑。
        Vector2[] borderPoints = new Vector2[BorderDensity];
        float     deltaAngle   = 360.0f / BorderDensity;

        for (int i = 0; i < BorderDensity; i++)
        {
            borderPoints[i] = transform.position + Quaternion.Euler(0, 0, i * deltaAngle) * Vector2.up * 10.0f;
        }
        //向所有点投影。留下最近的交点。
        points = points.Concat(borderPoints).Select(
            pt => {
            var t = Physics2D.Raycast(transform.position, pt - (Vector2)transform.position, 110.0f, mask);
            if (t.collider == null)
            {
                return((Vector2)transform.position + (pt - (Vector2)transform.position).normalized * 10.0f);
            }
            else
            {
                return(t.point);
            }
        }
            );
        //转回local space并且按角度排序
        var orderedpts = points
                         .Select(pt => transform.InverseTransformPoint(pt))
                         .OrderByDescending(
            pt => {
            var sign = Mathf.Sign(Vector2.up.x * pt.y - Vector2.up.y * pt.x);
            return(Vector2.Angle(Vector2.up, pt) * sign);               //Angle只会返回正值,要角度排序必须区分正负
        }
            );

        var zeropt = new Vector3[1];            //记得加入原点

        zeropt[0] = new Vector3(0, 0, 2);
        var verticesArray = zeropt.Concat(orderedpts).ToArray();

        //Debug.Log(verticesArray.Length);

        int[] triangles = new int[(verticesArray.Length - 1) * 3];
        for (int i = 0; i < verticesArray.Length - 1; i++)
        {        //相邻两点和原点构成一个三角形。
            triangles[i * 3]     = 0;
            triangles[i * 3 + 1] = i + 1;
            triangles[i * 3 + 2] = (i + 1) % (verticesArray.Length - 1) + 1;    //让最后一个三角形的最后一个顶点为1。
        }

        mesh.Clear();
        mesh.vertices  = verticesArray;
        mesh.triangles = triangles;
        mesh.RecalculateNormals();
        filter.mesh = mesh;
    }
Exemplo n.º 6
0
        public GemModel CreateRedGemModel()
        {
            var gemCorners = new Vector3[] {
                //Front face, 6 corners, counterclockwise from top
                new Vector3(0, 0.5F, 0.2F),
                new Vector3(-0.2F, 0.3F, 0.2F),
                new Vector3(-0.2F, -0.3F, 0.2F),
                new Vector3(0, -0.5F, 0.2F),
                new Vector3(0.2F, -0.3F, 0.2F),
                new Vector3(0.2F, 0.3F, 0.2F),

                //Outer vertices, 6 corners, counterclockwise from top
                new Vector3(0F, 1.0F, 0),
                new Vector3(-0.5F, 0.5F, 0),
                new Vector3(-0.5F, -0.5F, 0),
                new Vector3(0F, -1.0F, 0),
                new Vector3(0.5F, -0.5F, 0),
                new Vector3(0.5F, 0.5F, 0)
            };
            //Copy first 6 vertices to last 6, with inverted Z
            gemCorners = gemCorners.Concat(gemCorners.Take(6).Select(v => new Vector3(v.X, v.Y, -v.Z))).ToArray();

            var faceCorners = new int[][] {
                //Front face
                new int[] { 0, 1, 2 },
                new int[] { 2, 3, 4 },
                new int[] { 4, 5, 0 },
                new int[] { 0, 2, 4 },

                //6 faces, counterclockwise from top, 2 triangles each
                new int[] { 0, 6, 7 },
                new int[] { 7, 1, 0 },
                new int[] { 1, 7, 8 },
                new int[] { 8, 2, 1 },
                new int[] { 2, 8, 9 },
                new int[] { 9, 3, 2 },
                new int[] { 3, 9, 10 },
                new int[] { 10, 4, 3 },
                new int[] { 4, 10, 11 },
                new int[] { 11, 5, 4 },
                new int[] { 5, 11, 6 },
                new int[] { 6, 0, 5 },

                //6 faces, clockwise from top, 2 triangles each
                new int[] { 12, 7, 6 },
                new int[] { 12, 13, 7 },
                new int[] { 13, 8, 7 },
                new int[] { 13, 14, 8 },
                new int[] { 14, 9, 8 },
                new int[] { 14, 15, 9 },
                new int[] { 15, 10, 9 },
                new int[] { 15, 16, 10 },
                new int[] { 16, 11, 10 },
                new int[] { 16, 17, 11 },
                new int[] { 17, 6, 11 },
                new int[] { 17, 12, 6 },

                //Back face
                new int[] { 12, 14, 13 },
                new int[] { 16, 15, 14 },
                new int[] { 12, 17, 16 },
                new int[] { 12, 16, 14 },

            };

            var gemVerticesOuterList = new List<VertexPositionNormalTexture>();
            var gemVerticesInnerList = new List<VertexPositionNormalTexture>();

            foreach (int[] corners in faceCorners)
            {
                float edge0 = RedGemInsetEdge(corners[0], corners[1]);
                float edge1 = RedGemInsetEdge(corners[1], corners[2]);
                float edge2 = RedGemInsetEdge(corners[2], corners[0]);

                gemVerticesOuterList.AddRange(MakeTriangle(gemCorners, corners, new float[] { 0.0F, 0.0F, 0.0F }));
                gemVerticesInnerList.AddRange(MakeTriangle(gemCorners, corners, new float[] { edge0, edge1, edge2 }, 0.02F));
            }

            return new GemModel(device, gemVerticesOuterList, gemVerticesInnerList, Color.Red);
        }
Exemplo n.º 7
0
        public GemModel CreateGreenGemModel()
        {
            var gemCorners = new Vector3[] {
                //Top back vertex
                new Vector3(0, 0.8F, -0.2F),
                //Middle ring two back vertices
                new Vector3(0.12F, 0.4F, -0.30F),
                new Vector3(-0.12F, 0.4F, -0.30F),
                //Bottom ring two back vertices
                new Vector3(0.08F, -0.8F, -0.20F),
                new Vector3(-0.08F, -0.8F, -0.20F),
            };
            //Now create more by rotating these 120° and 240° around the Y axis
            gemCorners = gemCorners
                .Concat(
                    gemCorners.Select(v => Vector3.Transform(v, Matrix.CreateRotationY(MathHelper.Pi * 2 / 3))).ToArray()
                ).Concat(
                    gemCorners.Select(v => Vector3.Transform(v, Matrix.CreateRotationY(MathHelper.Pi * 4 / 3))).ToArray()
                ).ToArray();

            var faceCorners = new int[][] {
                //Top face
                new int[] { 0, 5, 10 },
                //Upper band
                new int[] { 0, 1, 2 },
                new int[] { 0, 2, 6 },
                new int[] { 0, 6, 5 },
                new int[] { 5, 6, 7 },
                new int[] { 5, 7, 11 },
                new int[] { 5, 11, 10 },
                new int[] { 10, 11, 12 },
                new int[] { 10, 12, 1 },
                new int[] { 10, 1, 0 },
                //Lower band
                new int[] { 1, 3, 4 },
                new int[] { 1, 4, 2 },
                new int[] { 2, 4, 8 },
                new int[] { 2, 8, 6 },
                new int[] { 6, 8, 9 },
                new int[] { 6, 9, 7 },
                new int[] { 7, 9, 13 },
                new int[] { 7, 13, 11 },
                new int[] { 11, 13, 14 },
                new int[] { 11, 14, 12 },
                new int[] { 12, 14, 3 },
                new int[] { 12, 3, 1 },
                //Bottom face
                new int[] { 8, 4, 3 },
                new int[] { 13, 9, 8 },
                new int[] { 3, 14, 13 },
                new int[] { 3, 13, 8 }
            };

            //Just hardcode the list of edges to inset
            var insetEdges = new int[][] {
                new int[] {0, 1},
                new int[] {1, 2},
                new int[] {2, 0},
                new int[] {1, 3},
                new int[] {3, 4},
                new int[] {4, 2},
                new int[] {0, 5},
                new int[] {2, 6},
                new int[] {4, 8}
            };
            //Copy it 3 times
            var insetEdges1 = insetEdges.Select(ii => ii.Select(i => (i + 5) % 15).ToArray()).ToArray();
            var insetEdges2 = insetEdges.Select(ii => ii.Select(i => (i + 10) % 15).ToArray()).ToArray();
            insetEdges = insetEdges.Concat(insetEdges1).Concat(insetEdges2).ToArray();

            var gemVerticesOuterList = new List<VertexPositionNormalTexture>();
            var gemVerticesInnerList = new List<VertexPositionNormalTexture>();

            foreach (int[] corners in faceCorners)
            {
                float edge0 = GreenGemInsetEdge(corners[0], corners[1], insetEdges);
                float edge1 = GreenGemInsetEdge(corners[1], corners[2], insetEdges);
                float edge2 = GreenGemInsetEdge(corners[2], corners[0], insetEdges);

                gemVerticesOuterList.AddRange(MakeTriangle(gemCorners, corners, new float[] { 0.0F, 0.0F, 0.0F }));
                gemVerticesInnerList.AddRange(MakeTriangle(gemCorners, corners, new float[] { edge0, edge1, edge2 }, 0.02F));
            }

            return new GemModel(device, gemVerticesOuterList, gemVerticesInnerList, Color.Green );
        }
Exemplo n.º 8
0
        public GemModel CreateBlueGemModel()
        {
            var gemCorners = new Vector3[] {
                new Vector3(0F, 0.7F, 0.5F),
                new Vector3(0.35F, 0.4F, 0.35F * (float) Math.Sqrt(3))
            };

            //Create 6 rotations of those two vertices
            gemCorners = (from i in Enumerable.Range(0, 6)
                          from v in gemCorners
                         select Vector3.Transform(v, Matrix.CreateRotationY(MathHelper.Pi * i / 3F))).ToArray();

            //Append top-center and bottom-center vertices
            gemCorners = gemCorners.Concat(new Vector3[] {
                new Vector3(0, 0.7F, 0),
                new Vector3(0, -0.7F, 0)
            }).ToArray();

            //Tilt entire gem slightly towards the viewer, so we can see the top face
            gemCorners = gemCorners.Select(v => Vector3.Transform(v, Matrix.CreateRotationX(0.3F))).ToArray();

            //Define 4 triangles, then create 6 rotations of them too
            var faceCorners = new int[][] {
                new int[] {12, 0, 2},
                new int[] {0, 1, 2},
                new int[] {1, 3, 2},
                new int[] {1, 13, 3}
            };
            Func<int, int, int> nextStep = (i, n) => (i >= 12 ? i : (i + n * 2) % 12);
            faceCorners = (from n in Enumerable.Range(0, 6)
                          from ints in faceCorners
                          select ints.Select(i => nextStep(i, n)).ToArray()).ToArray();

            var gemVerticesOuterList = new List<VertexPositionNormalTexture>();
            var gemVerticesInnerList = new List<VertexPositionNormalTexture>();

            foreach (int[] corners in faceCorners)
            {
                //Inset all edges, except edges 0 and 2 when vertex0 is 12 (top center)
                float edge0 = corners[0] != 12 ? 0.03F : 0;
                float edge1 = 0.03F;
                float edge2 = corners[0] != 12 ? 0.03F : 0;

                gemVerticesOuterList.AddRange(MakeTriangle(gemCorners, corners, new float[] { 0.0F, 0.0F, 0.0F }));
                gemVerticesInnerList.AddRange(MakeTriangle(gemCorners, corners, new float[] { edge0, edge1, edge2 }, 0.02F));
            }

            return new GemModel(device, gemVerticesOuterList, gemVerticesInnerList, new Color(48, 48, 255));
        }
Exemplo n.º 9
0
    void OnValidate()
    {
        if (!mf)
        {
            mf = GetComponent <MeshFilter>();
        }
        if (!mr)
        {
            mr = GetComponent <MeshRenderer>();
        }
        if (!mr)
        {
            return;
        }
        if (!mf)
        {
            return;
        }
        if (!material)
        {
            return;
        }
        if (!sprite)
        {
            return;
        }

        var newMat = new Material(material);

        newMat.mainTexture = sprite.texture;
        mr.sharedMaterial  = newMat;
        if (Application.isPlaying)
        {
            mr.material = newMat;
        }

        Mesh mesh;

        if (mf && mf.sharedMesh && mf.sharedMesh.name == "(MeshedSprite)" && mf.sharedMesh.vertexCount == 4)
        {
            mesh = mf.sharedMesh;
        }
        else
        {
            mesh      = new Mesh();
            mesh.name = "(MeshedSprite)";
        }
        var vs = new Vector3[4];
        var w2 = sprite.rect.width / pixelToUnits * 0.5f;
        var h2 = sprite.rect.height / pixelToUnits * 0.5f;

        vs[0] = new Vector3(-w2, -h2, 0);
        vs[1] = new Vector3(w2, -h2, 0);
        vs[2] = new Vector3(w2, h2, 0);
        vs[3] = new Vector3(-w2, h2, 0);
        vs    = vs.Concat(vs).ToArray();
        var uvs = new Vector2[4];

        uvs[0] = new Vector2(sprite.rect.xMin / sprite.texture.width, sprite.rect.yMin / sprite.texture.height);
        uvs[1] = new Vector2(sprite.rect.xMax / sprite.texture.width, sprite.rect.yMin / sprite.texture.height);
        uvs[2] = new Vector2(sprite.rect.xMax / sprite.texture.width, sprite.rect.yMax / sprite.texture.height);
        uvs[3] = new Vector2(sprite.rect.xMin / sprite.texture.width, sprite.rect.yMax / sprite.texture.height);
        var colors = new Color[4] {
            Color.white, Color.white, Color.white, Color.white
        };

        uvs    = uvs.Concat(uvs).ToArray();
        colors = colors.Concat(colors).ToArray();
        var tris = new int[12] {
            0, 1, 2, 0, 2, 3, 4 + 2, 4 + 1, 4 + 0, 4 + 3, 4 + 2, 4 + 0
        };

        mesh.vertices = vs;
        mesh.colors   = colors;
        mesh.uv       = uvs;
        mesh.SetTriangles(tris, 0);
        mesh.RecalculateNormals();
        mf.sharedMesh = mesh;
        if (Application.isPlaying)
        {
            mf.mesh = mesh;
        }
    }
Exemplo n.º 10
0
    public static void Smooth(Mesh mesh)
    {
        iVertices = mesh.vertices;
        iFaces    = mesh.triangles;
        iUVs      = mesh.uv;//只判断一组UV,如果有多组UV就再加
        if (iUVs.Length > 0)
        {
            hasUvs = true;
        }

        /******************************************************
         *
         * Step 0:
         *
         *******************************************************/


        mVertices = new Vertex[iVertices.Length];     //创建一个和老顶点数组一样大的空数组,里面存的是使用该顶点做端点的边的数组
        EdgesDic  = new Dictionary <string, Edge>(0); // Edge => { oldVertex1, oldVertex2, faces[]  }//边的表
        BuildPointMap(mesh);
        GenerateLookups();

        /******************************************************
         *
         * Step 1: 在每条边上插入一个顶点
         *
         *******************************************************/
        Map_Pos_EdgeVertex = new Dictionary <string, List <EdgeVertex> >(0);
        Map_Edge_Vertex    = new Dictionary <string, int>();
        Vector3[] newEdgeVertices = new Vector3[EdgesDic.Count];

        int index = 0;

        foreach (var e in EdgesDic)//先找到每条边的中点,看看有没有相同位置的
        {
            Edge    currentEdge   = e.Value;
            Vector3 newEdgeVertex = Vector3.zero;
            newEdgeVertex          = iVertices[currentEdge.a] + iVertices[currentEdge.b];
            Map_Edge_Vertex[e.Key] = index;//记录的是新顶点的标号

            string vstr = Vector2String(newEdgeVertex);
            if (!Map_Pos_EdgeVertex.ContainsKey(vstr))
            {
                Map_Pos_EdgeVertex.Add(vstr, new List <EdgeVertex>());
            }
            Map_Pos_EdgeVertex[vstr].Add(new EdgeVertex(index, currentEdge));

            newEdgeVertices[index++] = newEdgeVertex;
        }
        foreach (var evs in Map_Pos_EdgeVertex)
        {
            List <EdgeVertex> edgeVertices = evs.Value;
            int     connectedFaces         = 0;
            Vector3 tmp1 = String2Vector(evs.Key);
            Vector3 tmp2 = Vector3.zero;
            foreach (var ev in edgeVertices)
            {
                int c = ev.edge.adjVertex.Count;
                connectedFaces += c;
                for (int j = 0; j < c; j++)
                {
                    int v = ev.edge.adjVertex[j];
                    tmp2 += iVertices[v];
                }//边两旁的两个顶点。如果边的两边都是面,则权重为1/8,如果位于边界处,权重为0
            }
            SetWeight1(connectedFaces);
            Vector3 newPos = tmp1 * edgeVertexWeight + tmp2 * adjacentVertexWeight;
            foreach (var ev in edgeVertices)
            {
                newEdgeVertices[ev.edgeVertexIndex] = newPos;
            }
        }


        /******************************************************
         *
         * Step 2: 根据新插入的顶点,改变原始顶点的位置
         *
         *******************************************************/
        Vector3[] newSourceVertices = new Vector3[iVertices.Length];

        foreach (var point in PointMap)
        {//对每一个原始顶点
            List <int> PointsAtPos     = point.Value;
            Vector3    oldVertex       = iVertices[PointsAtPos[0]];
            Vector3    ConnPointPosAve = Vector3.zero;
            int        n = 0;
            foreach (var p in PointsAtPos)
            {
                Vertex mVertex = mVertices[p];
                var    vlist   = mVertex.conVertexIndices;//与该点相连的顶点
                n += vlist.Count;
                foreach (var v in vlist)
                {
                    ConnPointPosAve += iVertices[v];
                }
            }
            SetWeight2(n);

            Vector3 newSourceVertex = Vector3.zero;
            newSourceVertex += (oldVertex * sourceVertexWeight);

            ConnPointPosAve *= connectingVertexWeight;
            newSourceVertex += ConnPointPosAve;

            foreach (var p in PointsAtPos)
            {
                newSourceVertices[p] = newSourceVertex;
            }
        }

        /******************************************************
         *
         * Step 3: 所有顶点构成新的面
         *
         *******************************************************/
        int sl = newSourceVertices.Length;

        Vector3[] newVertices  = newSourceVertices.Concat(newEdgeVertices).ToArray <Vector3>();
        Vector2[] newUVs       = new Vector2[newVertices.Length];
        int[]     newTriangles = new int[iFaces.Length * 4];
        for (int i = 0, l = iFaces.Length; i < l; i += 3)
        {
            int va = iFaces[i];
            int vb = iFaces[i + 1];
            int vc = iFaces[i + 2];

            // find the 3 new edges vertex of each old face

            int v1 = Map_Edge_Vertex[GetEdgeKey(va, vb)] + sl;
            int v2 = Map_Edge_Vertex[GetEdgeKey(vb, vc)] + sl;
            int v3 = Map_Edge_Vertex[GetEdgeKey(vc, va)] + sl;


            // create 4 faces.
            NewFace(newTriangles, i * 4, v1, v2, v3);
            NewFace(newTriangles, i * 4 + 3, va, v1, v3);
            NewFace(newTriangles, i * 4 + 6, vb, v2, v1);
            NewFace(newTriangles, i * 4 + 9, vc, v3, v2);
            if (hasUvs)
            {
                newUVs[va] = iUVs[va];
                newUVs[vb] = iUVs[vb];
                newUVs[vc] = iUVs[vc];
                newUVs[v1] = new Vector2((iUVs[va].x + iUVs[vb].x) * 0.5f, (iUVs[va].y + iUVs[vb].y) * 0.5f);
                newUVs[v2] = new Vector2((iUVs[vb].x + iUVs[vc].x) * 0.5f, (iUVs[vb].y + iUVs[vc].y) * 0.5f);
                newUVs[v3] = new Vector2((iUVs[vc].x + iUVs[va].x) * 0.5f, (iUVs[vc].y + iUVs[va].y) * 0.5f);
            }
        }

        // Overwrite old arrays
        mesh.vertices  = newVertices;
        mesh.triangles = newTriangles;
        if (hasUvs)
        {
            mesh.uv = newUVs;
        }


        mesh.SetIndices(newTriangles, MeshTopology.Triangles, 0);
        //if ( hasUvs ) geometry.faceVertexUvs = newUVs;
        mesh.RecalculateNormals();
        mesh.RecalculateTangents();
    }
Exemplo n.º 11
0
    void CreateShape()
    {
        int pl = points.Length;
        int numOfSplits; // min number of vertex splitting for disconected surfaces
        int v;           // number of vertices needed for the mesh

        int   corners      = pl - 1;
        float columnLength = 5f;

        /*int v = pl * 2;
         * vertices = new Vector3[v];
         * for (int i = 0; i < pl; i++) {
         *  vertices[i] = points[i].position;
         *
         *  Vector3 p = new Vector3(points[i].position.x, points[i].position.y - 5f, points[i].position.z);
         *  vertices[i+pl] = p;
         * }*/

        if (corners % 2 == 1)
        {
            // then the shape has an odd number of corners (eg triangular, pentagonal)
            //  so there must be four splits
            numOfSplits = 4;
            v           = (pl * 2) * 4;
        }
        else
        {
            numOfSplits = 3;
            v           = (pl * 2) * 3;
        }

        vertices = new Vector3[v];
        uv       = new Vector2[v];
        // print("Number of vertices: " + v);

        // split the vertices to have hard edges between surfaces
        Vector3[] verticesTemp = new Vector3[pl * 2];
        Vector2[] uvTemp       = new Vector2[pl * 2];
        for (int i = 0; i < pl; i++)
        {
            // for the top of the column
            verticesTemp[i] = points[i].position;

            //uvTemp[i] = new Vector2(points[i].position.x/maxX, points[i].position.y/maxY);
            if (i == 0)
            {
                uvTemp[i] = new Vector2(0.5f, 0.5f);
            }
            else if (i % 2 == 0)
            {
                uvTemp[i] = new Vector2(0f, 0f);
            }
            else if (corners % 2 == 1 && i == pl - 1)
            {
                uvTemp[i] = new Vector2(1f, 0f);
            }
            else
            {
                uvTemp[i] = new Vector2(0f, 1f);
            }

            // for the bottom of the column
            Vector3 p = new Vector3(points[i].position.x,
                                    points[i].position.y - columnLength,
                                    points[i].position.z);
            verticesTemp[i + pl] = p;
            //uvTemp[i+pl] = new Vector2(p.x/maxX, p.y/maxY);
            if (i == 0)
            {
                uvTemp[i + pl] = new Vector2(0.5f, 0.5f);
            }
            else if (i % 2 == 0)
            {
                uvTemp[i + pl] = new Vector2(1f, 0f);
            }
            else if (corners % 2 == 1 && i == pl - 1)
            {
                uvTemp[i + pl] = new Vector2(0f, 1f);
            }
            else
            {
                uvTemp[i + pl] = new Vector2(1f, 1f);
            }
        }
        // for the sides of the UV
        Vector2[] uvTempS = new Vector2[pl * 2];
        for (int i = 0; i < pl; i++)
        {
            if (i % 2 == 0)
            {
                uvTempS[i] = new Vector2(0f, 0f);
            }
            else
            {
                uvTempS[i] = new Vector2(0f, 1f);
            }

            if (i % 2 == 0)
            {
                uvTempS[i + pl] = new Vector2(1f, 0f);
            }
            else
            {
                uvTempS[i + pl] = new Vector2(1f, 1f);
            }
        }
        // for the last odd size
        Vector2[] uvTempL = new Vector2[pl * 2];
        for (int i = 0; i < pl; i++)
        {
            Debug.Log(i);

            if (i % 2 == 0 || i == corners)
            {
                uvTempL[i] = new Vector2(0f, 1f);
            }
            else
            {
                uvTempL[i] = new Vector2(1f, 1f);
            }

            if (i % 2 == 0 || i == corners)
            {
                uvTempL[i + pl] = new Vector2(0f, 0f);
            }
            else
            {
                uvTempL[i + pl] = new Vector2(1f, 0f);
            }
        }


        if (numOfSplits == 4)
        {
            vertices = verticesTemp.Concat(verticesTemp).Concat(verticesTemp).Concat(verticesTemp).ToArray();
            //uv = uvTemp.Concat(uvTemp).Concat(uvTemp).Concat(uvTemp).ToArray();
            uv = uvTemp.Concat(uvTempS).Concat(uvTempS).Concat(uvTempL).ToArray();
        }
        else
        {
            vertices = verticesTemp.Concat(verticesTemp).Concat(verticesTemp).ToArray();
            //uv = uvTemp.Concat(uvTemp).Concat(uvTemp).ToArray();
            uv = uvTemp.Concat(uvTempS).Concat(uvTempS).ToArray();
        }

        CreatePrism(corners);

        /*if (corners == 4) CreateSquarePrism();
         * if (corners == 5) CreatePentagonalPrism();
         * if (corners == 6) CreateHexagonalPrism();
         * if (corners == 7) CreateHeptagonalPrism();
         * if (corners == 8) CreateOctagonalPrism();*/
    }
Exemplo n.º 12
0
        public static Mesh CreateMesh(Vector2[] poly, float extrusion)
        {
            // convert polygon to triangles

            Triangulator triangulator = new Triangulator(poly);

            int[] tris = triangulator.Triangulate();
            Mesh  m    = new Mesh();

            Vector3[] vertices = new Vector3[poly.Length * 2];

            Vector3[] sideVertices = new Vector3[poly.Length * 2];

            for (int i = 0; i < poly.Length; i++)
            {
                vertices[i].x = poly[i].x;
                vertices[i].y = poly[i].y;
                vertices[i].z = -extrusion; // front vertex
                vertices[i + poly.Length].x = poly[i].x;
                vertices[i + poly.Length].y = poly[i].y;
                vertices[i + poly.Length].z = 0;  // back vertex

                sideVertices[i].x = poly[i].x;
                sideVertices[i].y = poly[i].y;
                sideVertices[i].z = -extrusion; // front vertex
                sideVertices[i + poly.Length].x = poly[i].x;
                sideVertices[i + poly.Length].y = poly[i].y;
                sideVertices[i + poly.Length].z = 0;  // back vertex
            }

            // duplicate vectices for every faces to create sharp edges

            vertices = vertices.Concat(sideVertices).Concat(sideVertices).ToArray();


            int[] triangles  = new int[tris.Length * 2 + poly.Length * 6];
            int   count_tris = 0;

            for (int i = 0; i < tris.Length; i += 3)
            {
                triangles[i]     = tris[i];
                triangles[i + 1] = tris[i + 1];
                triangles[i + 2] = tris[i + 2];
            } // front vertices
            count_tris += tris.Length;
            for (int i = 0; i < tris.Length; i += 3)
            {
                triangles[count_tris + i]     = tris[i + 2] + poly.Length;
                triangles[count_tris + i + 1] = tris[i + 1] + poly.Length;
                triangles[count_tris + i + 2] = tris[i] + poly.Length;
            } // back vertices
            count_tris += tris.Length;


            // for (var j = 0; j < poly.Length; j++)
            // {

            //     var side = poly.Length * 2 + (2 * j);

            //     int n = ((j + 1) % poly.Length) + side;
            //     triangles[count_tris] = j;
            //     triangles[count_tris + 1] = n;
            //     triangles[count_tris + 2] = j + poly.Length;
            //     triangles[count_tris + 3] = n;
            //     triangles[count_tris + 4] = n + poly.Length;
            //     triangles[count_tris + 5] = j + poly.Length;
            //     count_tris += 6;
            // }

            for (int i = poly.Length * 2; i < poly.Length * 3; i++)
            {
                // triangles around the perimeter of the object
                int n = ((i + 1) % poly.Length) + poly.Length * 2;
                triangles[count_tris]     = i;
                triangles[count_tris + 1] = n + poly.Length * 2;               // second set
                triangles[count_tris + 2] = i + poly.Length + poly.Length * 2; // second set
                triangles[count_tris + 3] = n + poly.Length * 2;               // second set
                triangles[count_tris + 4] = n + poly.Length;
                triangles[count_tris + 5] = i + poly.Length + poly.Length * 2; // second set;
                count_tris += 6;
            }

            // Create the mesh
            Mesh msh = new Mesh();

            msh.vertices  = vertices;
            msh.triangles = triangles;
            msh.RecalculateNormals();
            msh.RecalculateBounds();

            Vector2[] uvs = new Vector2[vertices.Length];

            for (int i = 0; i < uvs.Length; i++)
            {
                uvs[i] = new Vector2(vertices[i].x, vertices[i].z);
            }
            msh.uv = uvs;


            return(msh);
        }