public override Vector2 GetCoords(Vector2 position)
    {
        if (!RectTransformUtility.RectangleContainsScreenPoint(image.rectTransform, position, worldCamera))
        {
            return(Vector2.zero);
        }

        Vector2 point;

        RectTransformUtility.ScreenPointToLocalPointInRectangle(image.rectTransform, position, worldCamera, out point);

        Rect rect = image.GetPixelAdjustedRect();

        Vector2 size = rect.max - point;

        size.x = size.x / rect.size.x;
        size.y = size.y / rect.size.y;

        Vector2 r = new Vector2(size.x - .5f, size.y - .5f);

        int countX = api.width / OnlineMapsUtils.tileSize;
        int countY = api.height / OnlineMapsUtils.tileSize;

        double px, py;

        api.GetPosition(out px, out py);
        api.projection.CoordinatesToTile(px, py, api.zoom, out px, out py);

        px -= countX * r.x;
        py += countY * r.y;

        api.projection.TileToCoordinates(px, py, api.zoom, out px, out py);
        return(new Vector2((float)px, (float)py));
    }
    private static void Anchor(RectTransform rectTransform)
    {
        if (!rectTransform.transform.parent)
        {
            return;
        }
        UnityEngine.UI.Image ima = rectTransform.GetComponent <UnityEngine.UI.Image>();

        Rect parentRect = rectTransform.transform.parent.GetComponent <RectTransform>().rect;

        UnityEngine.UI.Image parentImage = rectTransform.transform.parent.GetComponent <UnityEngine.UI.Image>();
        if (parentImage != null)
        {
            if (parentImage.sprite != null)
            {
                var size = parentImage.sprite == null ? Vector2.zero : new Vector2(parentImage.sprite.rect.width, parentImage.sprite.rect.height);
                //parentRect = parentImage.sprite.rect;
                Rect r = parentImage.GetPixelAdjustedRect();
                if (size.sqrMagnitude > 0.0f)
                {
                    var spriteRatio = size.x / size.y;

                    var rectRatio = r.width / r.height;

                    if (spriteRatio > rectRatio)
                    {
                        var oldHeight = r.height;
                        r.height = r.width * (1.0f / spriteRatio);
                        r.y     += (oldHeight - r.height) * ((RectTransform)(rectTransform.transform.parent)).pivot.y;
                    }
                    else
                    {
                        var oldWidth = r.width;
                        r.width = r.height * spriteRatio;
                        r.x    += (oldWidth - r.width) * ((RectTransform)(rectTransform.transform.parent)).pivot.x;
                    }
                    //parentRect = r;
                }
                Debug.Log("Parent Image");
            }
        }
        rectTransform.anchorMin = new Vector2(rectTransform.anchorMin.x + (rectTransform.offsetMin.x / parentRect.width), rectTransform.anchorMin.y + (rectTransform.offsetMin.y / parentRect.height));
        rectTransform.anchorMax = new Vector2(rectTransform.anchorMax.x + (rectTransform.offsetMax.x / parentRect.width), rectTransform.anchorMax.y + (rectTransform.offsetMax.y / parentRect.height));
        rectTransform.offsetMin = Vector2.zero;
        rectTransform.offsetMax = Vector2.zero;
        rectTransform.pivot     = new Vector2(0.5f, 0.5f);
        rectTransform.pivot     = new Vector2(0.5f, 0.5f);
    }
Exemple #3
0
        public override void ModifyMesh(VertexHelper vh)
        {
            var sprite = m_image.overrideSprite;

            if (sprite == null)
            {
                return;
            }

            if (!m_image.hasBorder)
            {
                return;
            }

            var verts = ListPool <UIVertex> .Get();

            var newVert = ListPool <UIVertex> .Get();

            vh.GetUIVertexStream(verts);
            var shapeCount = verts.Count / vertexCountInOneShape;

            if (shapeCount == maxShapeCount || shapeCount == maxShapeCount - 1)
            {
                Vector2 minVert, maxVert;
                EffectHelper.GetMinMaxVerts(verts, out minVert, out maxVert);

                var     rect       = m_image.GetPixelAdjustedRect();
                var     spriteRect = sprite.rect;
                Vector2 middleSize = new Vector2((spriteRect.width - sprite.border.x - sprite.border.z) / m_image.pixelsPerUnit, (spriteRect.height - sprite.border.y - sprite.border.w) / m_image.pixelsPerUnit);

                middleSize = Vector2.Min(new Vector2(rect.width, rect.height), middleSize);
                var positionLB = minVert + Vector2.Scale(((maxVert - minVert) - middleSize) * 0.5f, new Vector2(offsetX, offsetY));
                var positionRT = positionLB + middleSize;
                var hasCenter  = (maxShapeCount == shapeCount);

                for (int i = 0; i < shapeCount; ++i)
                {
                    //if (i > drawIndex)//这两行不知道干什么用的,引起了bug,先注释掉了
                    //	break;

                    bool isLeftRect    = (i == 0 || i == 1 || i == 2);
                    bool isRightRect   = ((i == 6 || i == 7) || (hasCenter ? i == 8 : i == 5));
                    bool isTopRect     = (i == 2 || (hasCenter ? (i == 5 || i == 8) : (i == 4 || i == 7)));
                    bool isBottomRect  = (i == 0 || i == 3 || (hasCenter ? i == 6 : i == 5));
                    bool isXCenterRect = (i == 1 || (hasCenter ? (i == 4 || i == 7) : i == 6));
                    bool isYCenterRect = (i == 3 || (hasCenter ? (i == 4 || i == 5) : i == 4));
                    for (int j = 0; j < vertexCountInOneShape; ++j)
                    {
                        var  index          = i * vertexCountInOneShape + j;
                        var  vert           = verts [index];
                        var  pos            = vert.position;
                        bool isLeftBorder   = (j == 0 || j == 1 || j == 5);
                        bool isRightBorder  = (j == 2 || j == 3 || j == 4);
                        bool isTopBorder    = (j == 1 || j == 2 || j == 3);
                        bool isBottomBorder = (j == 0 || j == 4 || j == 5);
                        if (isLeftRect && isRightBorder || isYCenterRect && isLeftBorder)
                        {
                            pos.x = positionLB.x;
                        }
                        if (isRightRect && isLeftBorder || isYCenterRect && isRightBorder)
                        {
                            pos.x = positionRT.x;
                        }
                        if (isTopRect && isBottomBorder || isXCenterRect && isTopBorder)
                        {
                            pos.y = positionRT.y;
                        }
                        if (isBottomRect && isTopBorder || isXCenterRect && isBottomBorder)
                        {
                            pos.y = positionLB.y;
                        }
                        vert.position = pos;
                        newVert.Add(vert);
                    }
                }
                vh.Clear();
                vh.AddUIVertexTriangleStream(newVert);
            }
            newVert.ReleaseToPool();
            verts.ReleaseToPool();
        }