コード例 #1
0
ファイル: QuickPolygon.cs プロジェクト: dkorobov2/stripes
        public void Reset()
        {
            GetComponent <MeshRenderer>().sharedMaterial = Material;
            GetComponent <MeshFilter>().sharedMesh       = Mesh;

            SquareShape   = new SquareShape();
            CircleShape   = new CircleShape();
            StarShape     = new StarShape();
            DiamondShape  = new DiamondShape();
            TriangleShape = new TriangleShape();
            HexagonShape  = new HexagonShape();
            PentagonShape = new PentagonShape();


            FacingModifier = new FacingModifier();
            StandardBorder = new StandardBorder();

            EmptyFill          = new EmptyFill();
            SingleColorFill    = new SingleColorFill();
            LinearGradientFill = new LinearGradientFill();
            RadialGradientFill = new RadialGradientFill();

            StandardBorder = new StandardBorder();

            ProportionsModifier  = new ProportionsModifier();
            SortingLayerModifier = new SortingLayerModifier();
            PivotModifier        = new PivotModifier();
        }
コード例 #2
0
ファイル: QuickPolygon.cs プロジェクト: dkorobov2/stripes
 public void SetBorderUnicolor(Color color, float outerScale = 0.01f, float innerScale = 0f, bool recalculate = false)
 {
     StandardBorder            = new StandardBorder();
     UseShapeBorder            = BorderFillType.Unicolor;
     StandardBorder.color      = color;
     StandardBorder.outerScale = Mathf.Max(0, Mathf.Min(4, outerScale));
     StandardBorder.innerScale = Mathf.Max(0, Mathf.Min(1, innerScale));
     if (recalculate)
     {
         RecalculateMesh();
     }
 }
コード例 #3
0
        private Vector3 BevelMoveSquare(float percent, float offset, Vector3 a, Vector3 b, Vector3 c)
        {
            float roundPercent = Mathf.Sin(percent * Mathf.PI);

            Vector3 nb = Vector3.Lerp(a, b, offset);
            Vector3 nc = Vector3.Lerp(a, c, offset);

            Vector3 l1    = Vector3.Lerp(nb, nc, percent);
            Vector3 norm  = StandardBorder.MakeNormal(c, b);
            float   scale = Vector3.Distance(a, Vector3.Lerp(b, c, 0.5f)) * 0.87f;
            Vector3 l3    = l1 + norm * roundPercent * scale;

            return(l3);
        }
コード例 #4
0
ファイル: ColliderManager.cs プロジェクト: dkorobov2/stripes
        public static void ReloadCollider(QuickPolygon shape, ColliderType colliderType, MeshData data, StandardBorder border)
        {
            switch (colliderType)
            {
            case ColliderType.None:
            {
                RemoveColliders(shape);
                break;
            }

            case ColliderType.Box:
            {
                BoxCollider2D col = shape.GetComponent <BoxCollider2D>();
                if (col == null)
                {
                    Collider2D prevCol = shape.GetComponent <Collider2D>();
                    if (prevCol != null)
                    {
                        Helpers.Destroy(prevCol);
                    }
                    col = shape.gameObject.AddComponent <BoxCollider2D>();
                }
                Bounds boundingBox = shape.Bounds;
                                                #if UNITY_5_0 || UNITY_5_1 || UNITY_5_2 || UNITY_5_3_OR_NEWER
                col.offset = new Vector2(boundingBox.center.x, boundingBox.center.y);
                                                #else
                col.center = new Vector2(boundingBox.center.x, boundingBox.center.y);
                                                #endif
                col.size = new Vector2(boundingBox.size.x, boundingBox.size.y);
                break;
            }

            case ColliderType.FillPolygon:
            {
                PolygonCollider2D col = shape.GetComponent <PolygonCollider2D>();
                if (col == null)
                {
                    Collider2D prevCol = shape.GetComponent <Collider2D>();
                    if (prevCol != null)
                    {
                        Helpers.Destroy(prevCol);
                    }
                    col = shape.gameObject.AddComponent <PolygonCollider2D>();
                }

                Vector2[] points = new Vector2[data.BorderVertices.Length];
                for (int i = 0; i < data.BorderVertices.Length; i++)
                {
                    Vector3 v = data.Vertices[data.BorderVertices[i]];
                    points[i] = new Vector2(v.x, v.y);
                }
                col.points = points;
                break;
            }

            case ColliderType.BorderPolygon:
            {
                if (border == null)
                {
                    Debug.LogWarning(MSG.Warnings.COLLIDER_POLYGON_BORDER_NOT_EXIST, shape);
                    shape.ShapeColliderIndex = ColliderType.None;
                    ReloadCollider(shape, shape.ShapeColliderIndex, data, border);
                    break;
                }
                PolygonCollider2D col = shape.GetComponent <PolygonCollider2D>();
                if (col == null)
                {
                    Collider2D prevCol = shape.GetComponent <Collider2D>();
                    if (prevCol != null)
                    {
                        Helpers.Destroy(prevCol);
                    }
                    col = shape.gameObject.AddComponent <PolygonCollider2D>();
                }
                Vector2[] points = new Vector2[border.OutVerID.Length];
                for (int i = 0; i < border.OutVerID.Length; i++)
                {
                    Vector3 v = data.Vertices[border.OutVerID[i]];
                    points[i] = new Vector2(v.x, v.y);
                }
                col.points = points;

                break;
            }

            case ColliderType.FillAndBorderPolygon:
            {
                if (border == null)
                {
                    Debug.LogWarning(MSG.Warnings.COLLIDER_POLYGON_BORDER_NOT_EXIST, shape);
                    shape.ShapeColliderIndex = ColliderType.None;
                    ReloadCollider(shape, shape.ShapeColliderIndex, data, border);
                    break;
                }
                PolygonCollider2D col = shape.GetComponent <PolygonCollider2D>();
                if (col == null)
                {
                    Collider2D prevCol = shape.GetComponent <Collider2D>();
                    if (prevCol != null)
                    {
                        Helpers.Destroy(prevCol);
                    }
                    col = shape.gameObject.AddComponent <PolygonCollider2D>();
                }
                Vector2[] points = new Vector2[data.BorderVertices.Length + 2 + border.OutVerID.Length];
                for (int i = 0; i < data.BorderVertices.Length; i++)
                {
                    Vector3 v = data.Vertices[data.BorderVertices[i]];
                    points[i] = new Vector2(v.x, v.y);
                }
                points[data.BorderVertices.Length] = points[0];
                for (int i = 0; i < border.OutVerID.Length; i++)
                {
                    Vector3 v = data.Vertices[border.OutVerID[i]];
                    points[i + data.BorderVertices.Length + 1] = new Vector2(v.x, v.y);
                }
                points[data.BorderVertices.Length + border.OutVerID.Length + 1] = points[data.BorderVertices.Length + 1];
                col.points = points;
                break;
            }

            default:
                throw new IndexOutOfRangeException();
            }
        }