Esempio n. 1
0
    // Scale (based on screen size)
    public Vector3 RecalcScale()
    {
        CalcStretch();

        OGScrollView scrollView = this as OGScrollView;

        if (scrollView)
        {
            return(new Vector3(scrollView.size.x, scrollView.size.y, 1));
        }
        else
        {
            return(this.transform.lossyScale);
        }
    }
Esempio n. 2
0
    // Pivot (based on object size)
    private void CalcPivot()
    {
        Vector2      scale;
        OGScrollView scrollview = this as OGScrollView;

        if (scrollview)
        {
            scale = scrollview.size;
        }
        else
        {
            scale.x = this.transform.lossyScale.x;
            scale.y = this.transform.lossyScale.y;
        }

        switch (pivot.y)
        {
        case RelativeY.Top:
        case RelativeY.None:
            offset.y = 0;
            break;

        case RelativeY.Center:
            offset.y = -scale.y / 2;
            break;

        case RelativeY.Bottom:
            offset.y = -scale.y;
            break;
        }

        switch (pivot.x)
        {
        case RelativeX.Right:
            offset.x = -scale.x;
            break;

        case RelativeX.Center:
            offset.x = -scale.x / 2;
            break;

        case RelativeX.Left:
        case RelativeX.None:
            offset.x = 0;
            break;
        }
    }
Esempio n. 3
0
    // Stretch (based on screen size)
    private void CalcStretch()
    {
        if (stretch == null)
        {
            return;
        }

        Vector3      newScale   = this.transform.localScale;
        OGScrollView scrollView = this as OGScrollView;

        if (scrollView)
        {
            newScale.x = scrollView.size.x;
            newScale.y = scrollView.size.y;
        }

        if (stretch.width == ScreenSize.ScreenWidth)
        {
            newScale.x = (root.screenWidth * stretch.widthFactor) + stretch.widthOffset;
        }
        else if (stretch.width == ScreenSize.ScreenHeight)
        {
            newScale.x = (root.screenHeight * stretch.widthFactor) + stretch.widthOffset;
        }

        if (stretch.height == ScreenSize.ScreenWidth)
        {
            newScale.y = (root.screenWidth * stretch.heightFactor) + stretch.heightOffset;
        }
        else if (stretch.height == ScreenSize.ScreenHeight)
        {
            newScale.y = (root.screenHeight * stretch.heightFactor) + stretch.heightOffset;
        }

        if (!scrollView)
        {
            this.transform.localScale = newScale;
        }
        else
        {
            scrollView.size.x = newScale.x;
            scrollView.size.y = newScale.y;
        }
    }
Esempio n. 4
0
    // Position (based on screen size and flipped vertically because of OpenGL)
    public Vector3 RecalcPosition()
    {
        CalcAnchor();
        CalcPivot();

        Vector3      newPos     = this.transform.position;
        OGScrollView scrollView = this as OGScrollView;

        newPos += offset;
        newPos += scrollOffset;

        if (scrollView)
        {
            newPos.y += scrollView.size.y;
        }
        else
        {
            newPos.y += this.transform.lossyScale.y;
        }

        newPos.y = root.screenHeight - newPos.y;

        return(newPos);
    }