Ejemplo n.º 1
0
        protected override void OnResize()
        {
            var baseSize = Responsive.GetAreaSizeByMode(AreaMode.Viewport);
            var rect     = this.CalcWithScreen(UnityExtension.ScreenSafeAreaRect);

            this.UpdateSafeArea(rect, baseSize);
        }
Ejemplo n.º 2
0
        public float GetContentScale()
        {
            var areaSize = Responsive.GetAreaSizeByMode(AreaMode.Safe);
            var baseSize = Responsive.GetAreaSizeByMode(AreaMode.Viewport);
            var scale    = UnityExtension.GetScaleOfAreaSize(areaSize, baseSize);

            return(scale);
        }
Ejemplo n.º 3
0
        //public void ResetManualResolution(Vector2 manualArea)
        //{
        //    this.manualResolution = manualArea;
        //    this.UpdateResolution();
        //}
        public void ResetManualResolution()
        {
            var safeArea   = Responsive.GetAreaSizeByMode(AreaMode.Safe);
            var scale      = UnityExtension.GetScaleOfAreaSize(safeArea, Responsive.GetAreaSizeByMode(AreaMode.Viewport));
            var manualArea = safeArea / scale;

            this.manualResolution = manualArea;
        }
Ejemplo n.º 4
0
        public static void UpdateViews()
        {
            var screenSize = UnityExtension.ScreenSizeI;

            if (screenSize == Responsive.keepScreenSize)
            {
                return;
            }

            Responsive.keepScreenSize = screenSize;
            Responsive.ResetLayoutAll(true);
        }
Ejemplo n.º 5
0
        public static Rect GetViewportRect(RectTransform trans, Canvas canvas)
        {
            if (!trans)
            {
                return(Rect.zero);
            }

            var rect   = trans.rect;
            var size   = rect.size;
            var offset = Vector2.Scale(size, trans.pivot);

            var posMin = -offset;
            var posMax = size - offset;

            // TODO: Not supported rotation!
            var camera = canvas ? canvas.worldCamera : null;

            if (!camera)
            {
                camera = Camera.main;
            }
            var min = (Vector2)camera.WorldToViewportPoint(trans.TransformPoint(posMin));
            var max = (Vector2)camera.WorldToViewportPoint(trans.TransformPoint(posMax));

            var resolution     = Responsive.GetAreaSizeByMode(AreaMode.Screen);
            var resolutionHalf = resolution * 0.5f;
            var viewportMin    = new Vector2(min.x * resolution.x - resolutionHalf.x,
                                             min.y * resolution.y - resolutionHalf.y);
            var viewportMax = new Vector2(max.x * resolution.x - resolutionHalf.x,
                                          max.y * resolution.y - resolutionHalf.y);

            var viewportRect = Rect.MinMaxRect(viewportMin.x, viewportMin.y, viewportMax.x, viewportMax.y);

#if LOG_SOFTMASK
            Debug.Log(new System.Text.StringBuilder().Append("SOFTMASK:GETRECT:")
                      .Append("MIN:").Append("(X:").Append(min.x).Append(", Y:").Append(min.y).Append("), ")
                      .Append("MAX:").Append("(X:").Append(max.x).Append(", Y:").Append(max.y).Append("),\n")
                      //.Append("OFFMIN:").Append(offMin).Append(", ")
                      //.Append("OFFMAX:").Append(offMax).Append(", ")
                      .Append("VP_MIN:").Append(viewportMin).Append(", ")
                      .Append("VP_MAX:").Append(viewportMax).Append(", ")
                      .Append("SIZE:").Append(size).Append(", ")
                      .Append("RESOLUTION:").Append(resolution).Append(",\n")
                      .Append("RC:").Append(rect).Append(", ")
                      .Append("VP_RC:").Append(viewportRect).Append(",\n")
                      .ToString());
#endif// LOG_SOFTMASK
            return(viewportRect);
        }
Ejemplo n.º 6
0
        public static void Remove(Responsive responsive)
        {
            var reg = Responsive.registry;

            if (null == reg)
            {
                return;
            }

            HashSet <Responsive> set = null;
            var order = responsive.Order;

            if (reg.ContainsKey(order))
            {
                set = reg[order];
                set.Remove(responsive);
            }
        }
Ejemplo n.º 7
0
        public void Add(SortedDictionary <int, HashSet <Responsive> > dict, Responsive responsive)
        {
            if (null == dict)
            {
                return;
            }

            HashSet <Responsive> set = null;
            var order = responsive.Order;

            if (dict.ContainsKey(order))
            {
                set = dict[order];
            }
            else
            {
                set = new HashSet <Responsive>();
                dict.Add(order, set);
            }

            set.Add(responsive);
        }
Ejemplo n.º 8
0
        protected override void OnResize()
        {
            var safeAreaSize = Responsive.GetAreaSizeByMode(AreaMode.Safe);
            var viewportSize = Responsive.GetAreaSizeByMode(AreaMode.Viewport);
            var scale        = UnityExtension.GetScaleOfAreaSize(safeAreaSize, viewportSize);

            var transform = this.CachedRectTransform;

            var newScaleDelta = new Vector3(this.originScale.x, this.originScale.y, 1);

            if (this.horizontal)
            {
                newScaleDelta.x /= scale;
            }
            if (this.vertical)
            {
                newScaleDelta.y /= scale;
            }

            newScaleDelta.x = Mathf.Clamp(newScaleDelta.x, this.minScale.x, this.maxScale.x);
            newScaleDelta.y = Mathf.Clamp(newScaleDelta.y, this.minScale.y, this.maxScale.y);

            transform.localScale = newScaleDelta;
        }
Ejemplo n.º 9
0
 Rect CalcWithScreen(Rect safeAreaRect)
 {
     return(UnityExtension.GetCalculatedSafeAreaRect(safeAreaRect, Responsive.GetAreaSizeByMode(AreaMode.Viewport)));
 }
Ejemplo n.º 10
0
        public void UpdateSize()
        {
            // TODO: must be remove after whole components serialize it
            if (this.isFirst)
            {
                this.isFirst = false;
                this.ResetOriginOffsets();
            }

            var position = this.originPosition;
            var size     = this.originSize;

            var scaledScreenSize = Responsive.GetAreaSizeByMode(AreaMode.Screen);

            var baseArea        = Responsive.GetAreaRectByMode(AreaMode.Safe);
            var baseContentSize = Responsive.GetAreaSizeByMode(AreaMode.Viewport);

            var contentScale = UnityExtension.GetScaleOfAreaSize(baseArea.size, baseContentSize);
            var scaleFactor  = 1f / contentScale;

            var baseAreaRect = baseArea;
            var baseRectSize = new Vector2(baseContentSize.x * contentScale,
                                           baseContentSize.y * contentScale);
            var baseAreaRectSize = new Vector2(baseAreaRect.size.x, baseAreaRect.size.y);

            var actualContentSize  = baseRectSize;
            var actualSafeAreaSize = baseAreaRectSize;

            var areaPosition           = baseArea.position;
            var halfArea               = scaledScreenSize * 0.5f;
            var halfActualContentSize  = actualContentSize * 0.5f;
            var halfActualSafeAreaSize = actualSafeAreaSize * 0.5f;

            this.rightBlankValue  = Mathf.CeilToInt(scaledScreenSize.x - (halfArea.x + (this.ignoreContentTrasnformRight ? halfActualSafeAreaSize.x : halfActualContentSize.x)) - areaPosition.x);
            this.leftBlankValue   = Mathf.CeilToInt(halfArea.x - (this.ignoreContentTrasnformLeft ? halfActualSafeAreaSize.x : halfActualContentSize.x) + areaPosition.x);
            this.topBlankValue    = Mathf.CeilToInt(scaledScreenSize.y - (halfArea.y + (this.ignoreContentTrasnformTop ? halfActualSafeAreaSize.y : halfActualContentSize.y)) - areaPosition.y);
            this.bottomBlankValue = Mathf.CeilToInt(halfArea.y - (this.ignoreContentTrasnformBottom ? halfActualSafeAreaSize.y : halfActualContentSize.y) + areaPosition.y);

            var leftSize   = this.normalizedOffset.left * this.leftBlankValue;
            var rightSize  = this.normalizedOffset.right * this.rightBlankValue;
            var topSize    = this.normalizedOffset.top * this.topBlankValue;
            var bottomSize = this.normalizedOffset.bottom * this.bottomBlankValue;


            this.resultLeft   = leftSize * scaleFactor;
            this.resultRight  = rightSize * scaleFactor;
            this.resultTop    = topSize * scaleFactor;
            this.resultBottom = bottomSize * scaleFactor;

            if (this.useSizeLimit)
            {
                var blankMin = (this.minSize - size) * 0.5f;
                var blankMax = (this.maxSize - size) * 0.5f;

                this.resultLeft   = Mathf.Clamp(resultLeft, blankMin.x, blankMax.x);
                this.resultRight  = Mathf.Clamp(resultRight, blankMin.x, blankMax.x);
                this.resultTop    = Mathf.Clamp(resultTop, blankMin.y, blankMax.y);
                this.resultBottom = Mathf.Clamp(resultBottom, blankMin.y, blankMax.y);
            }

            var trans = this.CachedRectTransform;

            //TODO : Remove
#if LOG_DEBUG
            if (null == trans)
            {
                Debug.LogError("rt null");
            }
#endif// LOG_DEBUG

            this.SetSizeWithEdge(trans, RectTransform.Edge.Left, this.resultLeft);
            this.SetSizeWithEdge(trans, RectTransform.Edge.Right, this.resultRight);
            this.SetSizeWithEdge(trans, RectTransform.Edge.Top, this.resultTop);
            this.SetSizeWithEdge(trans, RectTransform.Edge.Bottom, this.resultBottom);

#if LOG_DEBUG
            if (this.calibrateCenter > CalibrateCenter.Both)
            {
                Debug.LogError("Invalid CalibrateCenter");
            }
#endif// LOG_DEBUG

            var anchorMax = trans.anchorMax;
            var anchorMin = trans.anchorMin;
            switch (this.calibrateCenter)
            {
            case CalibrateCenter.Horizontal:
                this.CalibratePositionX(trans, areaPosition, position, anchorMax, anchorMin, scaleFactor);
                break;

            case CalibrateCenter.Vertical:
                this.CalibratePositionY(trans, areaPosition, position, anchorMax, anchorMin, scaleFactor);
                break;

            case CalibrateCenter.Both:
                this.CalibratePositionXY(trans, areaPosition, position, anchorMax, anchorMin, scaleFactor);
                break;
            }
        }
Ejemplo n.º 11
0
 public Vector2 GetAreaSizeByCurrent()
 {
     return(Responsive.GetAreaSizeByMode(this.areaMode));
 }
Ejemplo n.º 12
0
        public static Vector2 GetAreaSizeByMode(AreaMode mode)
        {
            var areaRect = Responsive.GetAreaRectByMode(mode);

            return(areaRect.size);
        }
Ejemplo n.º 13
0
        //public void AddNewObject(Responsive responsive)
        //{
        //    this.Add(Responsive.newObjects, responsive);
        //}

//        public static void UpdateNewObjects()
//        {
//            var reg = Responsive.newObjects;
//            if (null == reg)
//                return;

//            if (reg.Count <= 0)
//                return;

//            foreach (var pair in reg)
//            {
//                var obj = pair.Value;
//                if (null == obj)
//                    continue;

//                foreach (var responsive in obj)
//                {
//                    if (null != responsive)
//                        responsive.UpdateResize();
//                    else
//                    {
//#if LOG_DEBUG
//                        Debug.LogWarning(string.Format("RESPONSIVE_NEW_OBJECT_IS_NULL:{0}", obj.ToString()));
//#endif// LOG_DEBUG
//                    }
//                }

//                obj.Clear();
//            }
//        }

        protected virtual void OnDestroyed()
        {
            Responsive.Remove(this);
        }