CrowdControl/Assets/Feel/MMTools/Tools/MMGUI/MMPSBToUIConverter.cs

using UnityEngine;
using System.Collections;
using System;
using UnityEngine.UI;
using MoreMountains.Tools;
using System.Collections.Generic;

namespace MoreMountains.Tools
{
	[AddComponentMenu("More Mountains/Tools/GUI/MMPSBToUIConverter")]
	public class MMPSBToUIConverter : MonoBehaviour
	{
		[Header("Target")]
		public Canvas TargetCanvas;
		public float ScaleFactor = 100f;
		public bool ReplicateNesting = false;

		[Header("Size")]
		public float TargetWidth = 2048;
		public float TargetHeight = 1152;

		[Header("Conversion")]
		[MMInspectorButton("ConvertToCanvas")]
		public bool ConvertToCanvasButton;
		public Vector3 ChildImageOffset = new Vector3(-1024f, -576f, 0f);

		protected Transform _topLevel;
		protected Dictionary<Transform, int> _sortingOrders;

		public virtual void ConvertToCanvas()
		{
			Screen.SetResolution((int)TargetWidth, (int)TargetHeight, true);

			_sortingOrders = new Dictionary<Transform, int>();

			// remove existing canvas if found
			foreach (Transform child in TargetCanvas.transform)
			{
				if (child.name == this.name)
				{
					child.MMDestroyAllChildren();
					DestroyImmediate(child.gameObject);
				}
			}

			// force size on canvas scaler
			CanvasScaler canvasScaler = TargetCanvas.GetComponent<CanvasScaler>();
			if (canvasScaler != null)
			{
				canvasScaler.referenceResolution = new Vector2(TargetWidth, TargetHeight);
			}

			// create a parent in the target canvas
			GameObject newRoot = new GameObject(this.name, typeof(RectTransform));
			newRoot.transform.SetParent(TargetCanvas.transform);
			RectTransform newRootRect = newRoot.GetComponent<RectTransform>();
			SetupForStretch(newRootRect);

			_topLevel = newRoot.transform;
			CreateImageForChildren(this.transform, newRoot.transform);

			// apply sorting orders
			foreach (KeyValuePair<Transform, int> pair in _sortingOrders)
			{
				pair.Key.SetSiblingIndex(pair.Value);
			}
		}

		/// <summary>
		/// Recursively goes through the children of the specified "root" Transform, and parents them to the specified "parent" 
		/// </summary>
		/// <param name="root"></param>
		/// <param name="parent"></param>
		protected virtual void CreateImageForChildren(Transform root, Transform parent)
		{
			foreach (Transform child in root)
			{
				GameObject imageGO = new GameObject(child.name, typeof(RectTransform));
				imageGO.transform.localPosition = ScaleFactor * child.transform.localPosition;
				if (ReplicateNesting)
				{
					imageGO.transform.SetParent(parent);
				}
				else
				{
					imageGO.transform.SetParent(_topLevel);
					Vector3 newLocalPosition = imageGO.transform.localPosition;
					newLocalPosition.x = newLocalPosition.x + TargetWidth / 2f;
					imageGO.transform.localPosition = newLocalPosition;
				}

				SpriteRenderer spriteRenderer = child.gameObject.GetComponent<SpriteRenderer>();
				if (spriteRenderer != null)
				{
					Image image = imageGO.AddComponent<Image>();
					image.sprite = spriteRenderer.sprite;
					_sortingOrders.Add(image.transform, spriteRenderer.sortingOrder);
					image.SetNativeSize();

					RectTransform imageGoRect = imageGO.GetComponent<RectTransform>();
					Vector3 newPosition = imageGoRect.localPosition;
					newPosition += ChildImageOffset;
					newPosition.z = 0f;
					imageGoRect.localPosition = newPosition;
				}
				else
				{
					imageGO.name += " - NODE";
					RectTransform imageGoRect = imageGO.GetComponent<RectTransform>();
					imageGoRect.sizeDelta = new Vector2(TargetWidth, TargetHeight);
					imageGoRect.localPosition = Vector3.zero;
				}
				imageGO.GetComponent<RectTransform>().localScale = Vector3.one;
				CreateImageForChildren(child, imageGO.transform);
			}
		}

		protected virtual void SetupForStretch(RectTransform rect)
		{
			rect.localPosition = Vector3.zero;
			rect.anchorMin = new Vector2(0, 0);
			rect.anchorMax = new Vector2(1, 1);
			rect.pivot = new Vector2(0.5f, 0.5f);
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
			rect.localScale = Vector3.one;
		}

	}
}