Inheritance: PrettyPolyLayer
Esempio n. 1
0
        void OnCollisionEnter2D(Collision2D collision)
        {
            Vector2 norm = -collision.contacts[0].normal;

            for (int i = 0; i < meshLayers.Length; i++)
            {
                PrettyPolyMeshLayer layer = meshLayers[i];
                if (layer != null && layer.isTrigger && layer.ExistsInDirection(norm))
                {
                    onCollision2D(collision, layer);
                }
            }
        }
        static void CreatePrettyPoly()
        {
            Camera sceneCam = SceneView.lastActiveSceneView.camera;
            Vector3 spawnPos = sceneCam.ViewportToWorldPoint(new Vector3(0.5f,0.5f,10f));
            GameObject go = new GameObject("PrettyPoly");
            go.transform.position = spawnPos;
            Selection.activeGameObject = go;

            PrettyPoly p = go.AddComponent<PrettyPoly>();
            UpdateLabels(p);
            p.points = new PrettyPolyPoint[] {
            new PrettyPolyPoint(new Vector3(-1,-1,0)),
            new PrettyPolyPoint(new Vector3(1,-1,0)),
            new PrettyPolyPoint(new Vector3(0,1,0))
            };
            p.closed = true;
            PrettyPolyMeshLayer l = new PrettyPolyMeshLayer();
            p.meshLayers = new PrettyPolyMeshLayer[] {l};
            p.UpdateMesh();

            go.GetComponent<Renderer>().materials = new Material[] {new Material(Shader.Find("Sprites/Default"))};
            Undo.RegisterCreatedObjectUndo(go, "Created PrettyPoly");
        }
Esempio n. 3
0
        public void UpdateMesh()
        {
            PrettyPolyPoint[] pts = (subdivisions > 0)? GetCurve(): points;
            if (addCollider)
            {
                AddCollider(pts);
            }
            else
            {
                gameObject.DestroyComponent <PolygonCollider2D>();
            }
            if (meshLayers == null || meshLayers.Length == 0)
            {
                mesh.Clear();
                return;
            }

            mesh.Clear();
            List <Vector3>     verts  = new List <Vector3>();
            List <Vector2>     uvs    = new List <Vector2>();
            List <Color>       colors = new List <Color>();
            List <Vector3>     norms  = new List <Vector3>();
            List <Vector4>     tans   = new List <Vector4>();
            List <List <int> > tris   = new List <List <int> >();

            for (int i = 0; i < materials.Length; i++)
            {
                tris.Add(new List <int>());
            }

            Vector3[] positions = System.Array.ConvertAll(pts, point => point.position);
            float     winding   = closed ? positions.ClosedWinding() : positions.Winding();

            pts = (winding < 0) ? pts.Reverse() : pts.Shift(2);

            int      matIndex = -1;
            Material prevMat  = null;

            for (int i = 0; i < meshLayers.Length; i++)
            {
                PrettyPolyMeshLayer layer = sortedLayers[i];
                if (layer == null)
                {
                    continue;
                }
                Mesh m = layer.GetMesh(pts, closed);
                if (m == null)
                {
                    continue;
                }
                Material mat = layer.material;
                if (mat != prevMat)
                {
                    matIndex++;
                }
                prevMat = mat;
                tris[matIndex].AddRange(
                    System.Array.ConvertAll(m.triangles, t => t + verts.Count)
                    );
                verts.AddRange(m.vertices);
                uvs.AddRange(m.uv);
                colors.AddRange(m.colors);
                norms.AddRange(m.normals);
                tans.AddRange(m.tangents);
            }

            mesh.vertices     = verts.ToArray();
            mesh.uv           = uvs.ToArray();
            mesh.colors       = colors.ToArray();
            mesh.normals      = norms.ToArray();
            mesh.tangents     = tans.ToArray();
            mesh.subMeshCount = materials.Length;

            for (int i = materials.Length - 1; i >= 0; i--)
            {
                mesh.SetTriangles(tris[i].ToArray(), i);
            }

            mesh.RecalculateBounds();
            if (Application.isPlaying)
            {
                GetComponent <MeshFilter>().mesh = mesh;
            }
            else
            {
                GetComponent <MeshFilter>().sharedMesh = mesh;
            }

            UpdateRenderer();
        }