//----------------------
// Protected Functions
/// <summary>
/// Set the parent object base on the
/// fit screen setting.
/// </summary>
protected void SetParentObjectByMode()
{
JCS_Canvas jcsCanvas = JCS_Canvas.instance;
if (jcsCanvas == null)
{
JCS_Debug.LogReminders("Does not use JCS_Canvas Object...");
return;
}
Transform parentObject = null;
// if is Resize UI is enable than add Dialogue under
// resize ui transform
if (JCS_UISettings.instance.RESIZE_UI)
{
parentObject = jcsCanvas.GetResizeUI().transform;
}
// Else we add it directly under the Canvas
else
{
parentObject = jcsCanvas.GetCanvas().transform;
}
// set it to parent
this.gameObject.transform.SetParent(parentObject);
}
/// <summary>
/// Set the parent object base on the fit screen setting.
/// </summary>
protected void SetParentObjectByMode()
{
var canvas = JCS_Canvas.GuessCanvas(this.transform);
var resizeUI = canvas.ResizeUI;
if (canvas == null)
{
JCS_Debug.LogReminder("Doesn't use JCS_Canvas object");
return;
}
Transform parentObject;
// if is Resize UI is enable than add Dialogue under resize ui transform
if (JCS_UISettings.instance.RESIZE_UI)
{
parentObject = resizeUI.transform;
}
// Else we add it directly under the Canvas
else
{
parentObject = canvas.canvas.transform;
}
// set it to parent
this.gameObject.transform.SetParent(parentObject);
}
/// <summary>
/// Create the Game Object during the editing time and
/// put under JCS_Canvas object.
/// </summary>
/// <param name="settingPath"> path to spawn </param>
/// <returns> object just spawned. </returns>
private static GameObject CreateHierarchyObjectUnderCanvas(string settingPath)
{
// since this will be in the editing time.
// so we don't worry to much about the performance.
JCS_Canvas jcsCanvas = (JCS_Canvas)FindObjectOfType(typeof(JCS_Canvas));
return(CreateHierarchyObjectUnderCanvas(settingPath, jcsCanvas));
}
/// <summary>
/// Start sliding the screen out the scene.
/// </summary>
/// <param name="align"> align type </param>
public void StartSlideOut(JCS_Align align, float time)
{
Vector2 sizeDelta = JCS_Canvas.GuessCanvas().AppRect.sizeDelta;
float imageSize = 1200;
float distanceX = sizeDelta.x + imageSize;
float distanceY = sizeDelta.y + imageSize;
// NOTE(jenchieh): this is just some tweeking.
mTweener.DurationX = time;
mTweener.DurationY = time;
mTweener.DurationZ = time;
Vector3 tweenTo = this.transform.localPosition;
switch (align)
{
// going left showing from right
// ============--------------
case JCS_Align.ALIGN_RIGHT:
{
tweenTo.x = JCS_Mathf.ToNegative(distanceX);
}
break;
// going right showing from left
// -----------=============
case JCS_Align.ALIGN_LEFT:
{
tweenTo.x = JCS_Mathf.ToPositive(distanceX);
}
break;
case JCS_Align.ALIGN_BOTTOM:
{
tweenTo.y = JCS_Mathf.ToPositive(distanceY);
}
break;
case JCS_Align.ALIGN_TOP:
{
tweenTo.y = JCS_Mathf.ToNegative(distanceY);
}
break;
}
// start sliding
mTweener.DoTween(tweenTo);
}
public static void ReattachSelf(RectTransform trans, ReattachCallback callback)
{
if (trans == null || callback == null)
return;
var canvas = JCS_Canvas.GuessCanvas();
var parent = trans.parent;
trans.SetParent(canvas.AppRect);
if (callback != null)
callback.Invoke(parent);
trans.SetParent(parent);
}
/// <summary>
/// Transfer canvas space to world space.
///
/// NOTE(jenchieh): this dont often use, cuz world space element
/// dont often follow the ui element.
/// </summary>
/// <param name="targetCanvasPos"> canvas position to transfer. </param>
/// <returns> world space position </returns>
public Vector3 CanvasToWorldSpace(Vector2 targetCanvasPos)
{
Camera cam = GetCamera();
//first you need the RectTransform component of your canvas
RectTransform canvasRect = JCS_Canvas.GuessCanvas().AppRect;
Vector2 canvasObject_WorldPosition = new Vector2(
((targetCanvasPos.x + (canvasRect.sizeDelta.x * JCS_Mathf.T_HALF)) / canvasRect.sizeDelta.x),
((targetCanvasPos.y + (canvasRect.sizeDelta.y * JCS_Mathf.T_HALF)) / canvasRect.sizeDelta.y));
Vector3 worldPos = cam.ViewportToWorldPoint(canvasObject_WorldPosition);
//now you can set the position to the world element
return(worldPos);
}
private List <JCS_Canvas> SortCanvases_Insertion()
{
for (int i = 0; i < mCanvases.Count; ++i)
{
for (int j = i; j > 0; --j)
{
if (mCanvases[j].canvas.sortingOrder < mCanvases[j - 1].canvas.sortingOrder)
{
JCS_Canvas temp = mCanvases[j];
mCanvases[j] = mCanvases[j - 1];
mCanvases[j - 1] = temp;
}
}
}
return(mCanvases);
}
private void Start()
{
#if (UNITY_5_4_OR_NEWER)
RectTransform appRect = JCS_Canvas.GuessCanvas().AppRect;
// TODO(jenchieh): unknown reason that something changes this to
// somewhere else. (since 5.4.0f3)
Vector3 tempPos = appRect.localPosition;
tempPos.z = 0;
this.transform.localPosition = Vector3.zero;
#endif
this.transform.localEulerAngles = Vector3.zero;
this.transform.localScale = Vector3.one;
}
private void Start()
{
// Set the canvas to be our root.
this.transform.SetParent(JCS_Canvas.GuessCanvas(transform).transform);
// Add panel root without losing the original size.
{
Vector2 originalSize = mRectTransform.sizeDelta;
this.mPanelRoot = this.gameObject.AddComponent <JCS_PanelRoot>();
mRectTransform.sizeDelta = originalSize;
}
SetToScreenEdge();
}
/// <summary>
/// Check weather the "type" in the screen space. (Sprite Renderer)
/// </summary>
/// <param name="checkTrans"> sprite renderer to check. (Sprite width & height) </param>
/// <returns>
/// true: in screen space,
/// false: not in screen space
/// </returns>
public bool CheckInScreenSpace(SpriteRenderer checkTrans)
{
Vector2 objectRect = JCS_Util.GetSpriteRendererRect(checkTrans);
Camera cam = main.GetCamera();
Vector2 objPos = cam.WorldToViewportPoint(checkTrans.transform.position);
Vector2 camPos = cam.WorldToViewportPoint(cam.transform.position);
float objLeft = objPos.x - (objectRect.x / JCS_Mathf.D_HALF);
float objRight = objPos.x + (objectRect.x / JCS_Mathf.D_HALF);
float objTop = objPos.y + (objectRect.y / JCS_Mathf.D_HALF);
float objBot = objPos.y - (objectRect.y / JCS_Mathf.D_HALF);
RectTransform appRect = JCS_Canvas.GuessCanvas().AppRect;
float camWidth = appRect.sizeDelta.x;
float camHeight = appRect.sizeDelta.y;
float camLeft = camPos.x - (camWidth / JCS_Mathf.D_HALF);
float camRight = camPos.x + (camWidth / JCS_Mathf.D_HALF);
float camTop = camPos.y + (camHeight / JCS_Mathf.D_HALF);
float camBot = camPos.y - (camHeight / JCS_Mathf.D_HALF);
#if (UNITY_EDITOR)
Vector3 topLeft = new Vector3(objLeft, objTop, 0.0f);
Vector3 topRight = new Vector3(objRight, objTop, 0.0f);
Vector3 botRight = new Vector3(objRight, objBot, 0.0f);
Vector3 botLeft = new Vector3(objLeft, objBot, 0.0f);
Debug.DrawLine(topLeft, topRight);
Debug.DrawLine(topLeft, botLeft);
Debug.DrawLine(botRight, botLeft);
Debug.DrawLine(topRight, botRight);
#endif
// TODO(JenChieh): Not done.
if ((objRight < camLeft || objLeft > camRight) &&
(objTop < camBot || objBot > camTop))
{
// out of screen.
return(false);
}
return(true);
}
/// <summary>
/// Create a tween panel.
/// </summary>
private static GameObject CreateTweenPanel()
{
JCS_Canvas jcsCanvas = (JCS_Canvas)FindObjectOfType(typeof(JCS_Canvas));
if (jcsCanvas == null)
{
JCS_Debug.Log(
"Cannot find the JCS_Canvas in the hierarchy. Plz create the canvas before create the base panel.");
return(null);
}
string setting_path = "JCSUnity_Resources/GUI/JCS_TweenPanel";
GameObject tweenPanel = CreateHierarchyObjectUnderCanvas(setting_path);
Undo.RegisterCreatedObjectUndo(tweenPanel, "Create Tween Panel");
return(tweenPanel);
}
/// <summary>
/// Check to see if enable to spawn the dialogue or not
/// </summary>
/// <returns></returns>
private static bool CheckIfOkayToSpawnDialogue(JCS_DialogueType type)
{
// Force Diaglogue have higher priority,
// so it will block the lower priority dialogue type
if (JCS_UIManager.instance.GetJCSDialogue(type) != null)
{
JCS_Debug.LogError("(" + type.ToString() + ")No able to spawn Dialogue cuz there are multiple dialogue in the scene...");
return(false);
}
if (JCS_Canvas.GuessCanvas() == null)
{
JCS_Debug.LogError("No able to spawn Dialogue cuz Canvas are null...");
return(false);
}
return(true);
}
/// <summary>
/// Create the clean base gui panel for JCSUnity and add in under to
/// the canvas.
///
/// Need:
/// 1) JCS_Canvas
/// in the scene before create base panel.
/// </summary>
private static GameObject CreateBasePanel()
{
JCS_Canvas canvas = (JCS_Canvas)FindObjectOfType(typeof(JCS_Canvas));
if (canvas == null)
{
JCS_Debug.Log("Can't find JCS_Canvas in hierarchy. Plz create canvas before creating new panel.");
return(null);
}
const string setting_path = "UI/JCS_BasePanel";
GameObject basePanel = CreateHierarchyObjectUnderCanvas(setting_path);
Undo.RegisterCreatedObjectUndo(basePanel, "Create Base Panel");
basePanel.transform.localScale = Vector3.one;
basePanel.name = "_BasePanel (Created)";
return(basePanel);
}
/// <summary>
/// Create a tween panel.
/// </summary>
private static GameObject CreateTweenPanel()
{
JCS_Canvas jcsCanvas = (JCS_Canvas)FindObjectOfType(typeof(JCS_Canvas));
if (jcsCanvas == null)
{
JCS_Debug.Log("Can't find JCS_Canvas in hierarchy. Plz create canvas before creating new panel.");
return(null);
}
const string setting_path = "JCSUnity_Resources/GUI/JCS_TweenPanel";
GameObject tweenPanel = CreateHierarchyObjectUnderCanvas(setting_path);
Undo.RegisterCreatedObjectUndo(tweenPanel, "Create Tween Panel");
tweenPanel.transform.localScale = Vector3.one;
tweenPanel.name = "_TweenPanel (Created)";
return(tweenPanel);
}
/// <summary>
/// Create the clean base gui panel for JCSUnity
/// and add in under to the canvas.
///
/// Need:
/// 1) JCS_Canvas
/// in the scene before create base panel.
/// </summary>
private static GameObject CreateBaseGUIPanel()
{
JCS_Canvas jcsCanvas = (JCS_Canvas)FindObjectOfType(typeof(JCS_Canvas));
if (jcsCanvas == null)
{
JCS_Debug.Log(
"Cannot find the JCS_Canvas in the hierarchy. Plz create the canvas before create the base panel.");
return(null);
}
string setting_path = "JCSUnity_Resources/GUI/JCS_BasePanel";
GameObject basePanel = CreateHierarchyObjectUnderCanvas(setting_path);
Undo.RegisterCreatedObjectUndo(basePanel, "Create Base GUI Panel");
basePanel.transform.localScale = Vector3.one;
return(basePanel);
}
public static List<RectTransform> DetachChildren(RectTransform trans)
{
var childs = new List<RectTransform>();
var canvas = JCS_Canvas.GuessCanvas();
for (int index = 0; index < trans.childCount; ++index)
{
Transform child = trans.GetChild(index);
var rect = child.GetComponent<RectTransform>();
if (rect == null)
continue;
childs.Add(rect);
// Remove from parent.
child.SetParent(canvas.AppRect);
}
return childs;
}
/// <summary>
/// Make a canvas space object to a world space position.
///
/// NOTE(jenchieh): Make UI object (canvas space) on top of the
/// world space game object.
/// </summary>
/// <param name="pos"></param>
/// <returns></returns>
public Vector3 CastToScreen(Vector3 pos)
{
var camera = JCS_Camera.main;
Vector3 positionOffset = mPositionOffset;
if (mPanelRoot != null)
{
positionOffset.x *= mPanelRoot.PanelDeltaWidthRatio;
positionOffset.y *= mPanelRoot.PanelDeltaHeightRatio;
}
switch (GetObjectType())
{
case JCS_UnityObjectType.TEXT:
case JCS_UnityObjectType.UI:
{
Vector2 worldToCanvasSpace = camera.WorldToCanvasSpace(pos);
var canvas = JCS_Canvas.GuessCanvas();
var resizeUI = canvas.ResizeUI;
float targetScale = resizeUI.TargetScale;
if (targetScale != 0.0f)
{
worldToCanvasSpace.x /= resizeUI.TargetScale;
worldToCanvasSpace.y /= resizeUI.TargetScale;
}
this.LocalPosition = worldToCanvasSpace + (Vector2)positionOffset;
}
break;
}
return(this.LocalPosition);
}
/// <summary>
/// Check weather the "type" in the screen space. (RectTransform)
/// </summary>
/// <param name="checkTrans"> rect transform's size, etc. </param>
/// <returns>
/// true: in screen space,
/// false: not in screen space
/// </returns>
public bool CheckInScreenSpace(RectTransform checkTrans)
{
Vector2 rectSize = checkTrans.sizeDelta;
Vector3 panelPos = checkTrans.localPosition;
float halfSlotWidth = rectSize.x / JCS_Mathf.D_HALF * checkTrans.localScale.x;
float halfSlotHeight = rectSize.y / JCS_Mathf.D_HALF * checkTrans.localScale.y;
float panelLeftBorder = panelPos.x - halfSlotWidth;
float panelRightBorder = panelPos.x + halfSlotWidth;
float panelTopBorder = panelPos.y + halfSlotHeight;
float panelBottomBorder = panelPos.y - halfSlotHeight;
Camera cam = main.GetCamera();
Vector3 camPos = cam.transform.position;
// Transfer 3D space to 2D space
Vector2 camPosToScreen = cam.WorldToScreenPoint(camPos);
// Get application rect
RectTransform appRect = JCS_Canvas.GuessCanvas().AppRect;
Vector2 screenRect = appRect.sizeDelta;
float camLeftBorder = camPosToScreen.x - screenRect.x / JCS_Mathf.D_HALF;
float camRightBorder = camPosToScreen.x + screenRect.x / JCS_Mathf.D_HALF;
float camTopBorder = camPosToScreen.y + screenRect.y / JCS_Mathf.D_HALF;
float camBottomBorder = camPosToScreen.y - screenRect.y / JCS_Mathf.D_HALF;
if (panelRightBorder - rectSize.x > camRightBorder ||
panelLeftBorder + rectSize.x < camLeftBorder ||
panelTopBorder - rectSize.y > camTopBorder ||
panelBottomBorder + rectSize.y < camBottomBorder)
{
return(false);
}
return(true);
}
private Vector3 GameDepthRect(Vector3 depth)
{
// Next step: find camera 4 bounds.
Camera cam = main.GetCamera();
var canvas = JCS_Canvas.GuessCanvas();
Vector3 camPos = cam.transform.position;
// only need to know the depth.
{
camPos.x = 0.0f;
camPos.y = 0.0f;
}
Vector3 canvasPos = canvas.transform.position;
// only need to know the depth.
{
canvasPos.x = 0.0f;
canvasPos.y = 0.0f;
}
float camToCanvasDistance = Vector3.Distance(camPos, canvasPos);
float camToGameDepthDistance = Vector3.Distance(camPos, depth);
RectTransform appRect = canvas.AppRect;
Vector2 canvasRect = appRect.sizeDelta;
// transfer rect from screen space to world space
{
canvasRect.x *= appRect.localScale.x;
canvasRect.y *= appRect.localScale.y;
}
return(new Vector3(
camToGameDepthDistance * canvasRect.x / camToCanvasDistance,
camToGameDepthDistance * canvasRect.y / camToCanvasDistance,
0));
}
/// <summary>
/// Transfer world space to canvas space.
/// Source -> http://answers.unity3d.com/questions/799616/unity-46-beta-19-how-to-convert-from-world-space-t.html
/// </summary>
/// <param name="targetWorldPos"> world position to transfer. </param>
/// <returns> Canvas space position </returns>
public Vector2 WorldToCanvasSpace(Vector3 targetWorldPos)
{
Camera cam = GetCamera();
//first you need the RectTransform component of your canvas
RectTransform canvasRect = JCS_Canvas.GuessCanvas().AppRect;
//then you calculate the position of the UI element
// 0,0 for the canvas is at the center of the screen,
// whereas WorldToViewPortPoint treats
// the lower left corner as 0,0. Because of
// this, you need to subtract the height / width of
// the canvas * 0.5 to get the correct position.
Vector3 viewportPos = cam.WorldToViewportPoint(targetWorldPos);
Vector2 worldObject_ScreenPosition = new Vector2(
((viewportPos.x * canvasRect.sizeDelta.x) - (canvasRect.sizeDelta.x * JCS_Mathf.T_HALF)),
((viewportPos.y * canvasRect.sizeDelta.y) - (canvasRect.sizeDelta.y * JCS_Mathf.T_HALF)));
//now you can set the position to the ui element
return(worldObject_ScreenPosition);
}
/// <summary>
/// Check weather the "type" in the screen space. (Character Controller)
/// </summary>
/// <param name="cap"> character controller to check. (Collider) </param>
/// <returns>
/// true: in screen space,
/// false: not in screen space
/// </returns>
public bool CheckInScreenSpace(CharacterController cap)
{
// First Step: Find CharacterController's 4 bounds.
Vector3 capScale = cap.transform.localScale;
capScale = JCS_Mathf.AbsoluteValue(capScale);
Vector3 cCenter = new Vector3(
cap.center.x * capScale.x,
cap.center.y * capScale.y,
cap.center.z * capScale.z);
float cR = cap.radius * capScale.x;
float cH = (cap.height - (cap.radius * 2.0f)) * capScale.y;
if (cH < 0)
{
cH = 0;
}
float cTopBound = cap.transform.position.y + cCenter.y + (cH / 2.0f) + cR;
float cBotBound = cap.transform.position.y + cCenter.y - (cH / 2.0f) - cR;
float cRightBound = cap.transform.position.x + cCenter.x + cR;
float cLeftBound = cap.transform.position.x + cCenter.x - cR;
#if (UNITY_EDITOR)
Vector3 cOrigin = cap.transform.position + cCenter;
Debug.DrawLine(cOrigin,
new Vector3(cOrigin.x, cTopBound, cOrigin.z));
Debug.DrawLine(cOrigin,
new Vector3(cOrigin.x, cBotBound, cOrigin.z));
Debug.DrawLine(cOrigin,
new Vector3(cRightBound, cOrigin.y, cOrigin.z));
Debug.DrawLine(cOrigin,
new Vector3(cLeftBound, cOrigin.y, cOrigin.z));
#endif
// Next step: find camera 4 bounds.
Camera cam = JCS_Camera.main.GetCamera();
JCS_Canvas jcsCanvas = JCS_Canvas.instance;
Vector3 camPos = cam.transform.position;
// only need to know the depth.
{
camPos.x = 0;
camPos.y = 0;
}
Vector3 canvasPos = jcsCanvas.transform.position;
// only need to know the depth.
{
canvasPos.x = 0;
canvasPos.y = 0;
}
float camToCanvasDistance = Vector3.Distance(camPos, canvasPos);
Vector3 gameDepth = new Vector3(0, cap.transform.position.z, 0);
float camToGameDepthDistance = Vector3.Distance(camPos, gameDepth);
//print("To Game depth Distance: " + camToGameDepthDistance);
//print("To Cavas Distnace: " + camToCanvasDistance);
Vector2 canvasRect = jcsCanvas.GetAppRect().sizeDelta;
// transfer rect from screen space to world space
{
canvasRect.x *= jcsCanvas.GetAppRect().localScale.x;
canvasRect.y *= jcsCanvas.GetAppRect().localScale.y;
}
Vector3 gameRect = new Vector3(
camToGameDepthDistance * canvasRect.x / camToCanvasDistance,
camToGameDepthDistance * canvasRect.y / camToCanvasDistance,
0);
// camPos name are named up there.
// cannot name the same.
Vector3 cCamPos = cam.transform.position;
float camTopBound = cCamPos.y + gameRect.y / 2;
float camBotBound = cCamPos.y - gameRect.y / 2;
float camRightBound = cCamPos.x + gameRect.x / 2;
float camLeftBound = cCamPos.x - gameRect.x / 2;
#if (UNITY_EDITOR)
Vector3 topLeft = cam.transform.position;
topLeft.x -= gameRect.x / 2;
topLeft.y += gameRect.y / 2;
Vector3 topRight = cam.transform.position;
topRight.x += gameRect.x / 2;
topRight.y += gameRect.y / 2;
Vector3 botLeft = cam.transform.position;
botLeft.x -= gameRect.x / 2;
botLeft.y -= gameRect.y / 2;
Vector3 botRight = cam.transform.position;
botRight.x += gameRect.x / 2;
botRight.y -= gameRect.y / 2;
// set depth to the same
topLeft.z = mGameDepth;
topRight.z = mGameDepth;
botLeft.z = mGameDepth;
botRight.z = mGameDepth;
// Draw the box
JCS_Debug.DrawRect(topLeft, topRight, botRight, botLeft);
#endif
if (cRightBound < camLeftBound ||
camRightBound < cLeftBound ||
cTopBound < camBotBound ||
camTopBound < cBotBound)
{
// no in the screen
return(false);
}
// in screen
return(true);
}
/// <summary>
/// Square inside the game editor screen. Display
/// the screen width and height in current game depth.
/// 2D Game probably need this. 3D Game is optional.
/// </summary>
private void DisplayGameDepthCamera()
{
if (!mDisplayGameDepthCamera)
{
return;
}
// Next step: find camera 4 bounds.
Camera cam = JCS_Camera.main.GetCamera();
JCS_Canvas jcsCanvas = JCS_Canvas.instance;
Vector3 camPos = cam.transform.position;
// only need to know the depth.
{
camPos.x = 0;
camPos.y = 0;
}
Vector3 canvasPos = JCS_Canvas.instance.transform.position;
// only need to know the depth.
{
canvasPos.x = 0;
canvasPos.y = 0;
}
float camToCanvasDistance = Vector3.Distance(camPos, canvasPos);
Vector3 gameDepth = new Vector3(0, mGameDepth, 0);
float camToGameDepthDistance = Vector3.Distance(camPos, gameDepth);
//print("To Game depth Distance: " + camToGameDepthDistance);
//print("To Cavas Distnace: " + camToCanvasDistance);
Vector2 canvasRect = jcsCanvas.GetAppRect().sizeDelta;
// transfer rect from screen space to world space
{
canvasRect.x *= jcsCanvas.GetAppRect().localScale.x;
canvasRect.y *= jcsCanvas.GetAppRect().localScale.y;
}
mCamRectSize = new Vector3(
camToGameDepthDistance * canvasRect.x / camToCanvasDistance,
camToGameDepthDistance * canvasRect.y / camToCanvasDistance,
0);
// camPos name are named up there.
// cannot name the same.
Vector3 cCamPos = cam.transform.position;
float camTopBound = cCamPos.y + mCamRectSize.y / 2;
float camBotBound = cCamPos.y - mCamRectSize.y / 2;
float camRightBound = cCamPos.x + mCamRectSize.x / 2;
float camLeftBound = cCamPos.x - mCamRectSize.x / 2;
// top left -> bot right
mCamRect.x = camLeftBound;
mCamRect.y = camTopBound;
mCamRect.width = camRightBound;
mCamRect.height = camBotBound;
Vector3 topLeft = cam.transform.position;
topLeft.x -= mCamRectSize.x / 2;
topLeft.y += mCamRectSize.y / 2;
Vector3 topRight = cam.transform.position;
topRight.x += mCamRectSize.x / 2;
topRight.y += mCamRectSize.y / 2;
Vector3 botLeft = cam.transform.position;
botLeft.x -= mCamRectSize.x / 2;
botLeft.y -= mCamRectSize.y / 2;
Vector3 botRight = cam.transform.position;
botRight.x += mCamRectSize.x / 2;
botRight.y -= mCamRectSize.y / 2;
// set depth to the same
topLeft.z = mGameDepth;
topRight.z = mGameDepth;
botLeft.z = mGameDepth;
botRight.z = mGameDepth;
// Draw the box
JCS_Debug.DrawRect(topLeft, topRight, botRight, botLeft, mGameCamColor);
}
/// <summary>
/// Add a canvas to the group.
/// </summary>
public void AddCanvas(JCS_Canvas canvas)
{
this.mCanvases.Add(canvas);
mCanvases = JCS_Util.RemoveEmptySlotIncludeMissing(mCanvases);
mCanvases = SortCanvases_Insertion();
}
/* Functions */
private void Awake()
{
if (instance != null)
{
string black_screen_name = JCS_UISettings.BLACK_SCREEN_NAME;
string white_screen_name = JCS_UISettings.WHITE_SCREEN_NAME;
// cuz the transform list will change while we set the transform to
// the transform,
List <Transform> readyToSetList = new List <Transform>();
Transform tempTrans = instance.transform;
// so record all the transform
for (int index = 0; index < tempTrans.childCount; ++index)
{
Transform child = tempTrans.GetChild(index);
if (child.name == black_screen_name ||
child.name == (black_screen_name + "(Clone)"))
{
continue;
}
if (child.name == white_screen_name ||
child.name == (white_screen_name + "(Clone)"))
{
continue;
}
if (child.name == "JCS_IgnorePanel")
{
continue;
}
// TODO(JenChieh): optimize this?
if (child.GetComponent <JCS_IgnoreDialogueObject>() != null)
{
continue;
}
// add to set list ready to set to the new transform as parent
readyToSetList.Add(child);
}
// set to the new transform
foreach (Transform trans in readyToSetList)
{
// set parent to the new canvas in the new scene
trans.SetParent(this.transform);
}
// Delete the old one
DestroyImmediate(instance.gameObject);
}
// attach the new one
instance = this;
this.mAppRect = this.GetComponent <RectTransform>();
this.mCanvas = this.GetComponent <Canvas>();
if (JCS_UISettings.instance.RESIZE_UI)
{
// resizable UI in order to resize the UI correctly
JCS_ResizeUI rui = JCS_Utility.SpawnGameObject(RESIZE_UI_PATH).GetComponent <JCS_ResizeUI>();
rui.transform.SetParent(this.transform);
}
}
/// <summary>
/// Create the Game Object during the editing time and
/// put under JCS_Canvas object.
///
/// Save O(n) time complexity during editing time.
/// </summary>
/// <param name="settingPath"> path to spawn </param>
/// <param name="jcsCanvas"> canvas to set on. </param>
/// <returns> object just spawned. </returns>
private static GameObject CreateHierarchyObjectUnderCanvas(string settingPath, JCS_Canvas jcsCanvas)
{
if (jcsCanvas == null)
{
JCS_Debug.Log("Can't find JCS_Canvas in hierarchy. Plz create canvas before creating new panel.");
return(null);
}
// spawn the object first.
GameObject hierarchyObj = CreateHierarchyObject(settingPath);
// set the canvas as parent.
hierarchyObj.transform.SetParent(jcsCanvas.transform);
// init position.
hierarchyObj.transform.localPosition = Vector3.zero;
return(hierarchyObj);
}
/// <summary>
/// Create 9x9 slide panel.
///
/// Need:
/// 1) JCS_Camera
/// 2) JCS_Canvas
/// in the scene before create 9 x 9 slide panel.
/// </summary>
private static void CreateSlidePanel()
{
JCS_Canvas jcsCanvas = (JCS_Canvas)FindObjectOfType(typeof(JCS_Canvas));
if (jcsCanvas == null)
{
JCS_Debug.Log("Can't find JCS_Canvas in hierarchy. Plz create canvas before creating new panel.");
return;
}
// find the camera in the scene.
JCS_2DCamera cam = (JCS_2DCamera)FindObjectOfType(typeof(JCS_Camera));
if (cam == null)
{
JCS_Debug.Log("Can't find JCS_Canvas in hierarchy. Plz create canvas before creating new panel.");
return;
}
const string settingPath = "JCSUnity_Resources/LevelDesignUI/JCS_SlideScreenPanelHolder";
// spawn the pane holder.
JCS_SlideScreenPanelHolder panelHolder9x9 = CreateHierarchyObjectUnderCanvas(settingPath, jcsCanvas).GetComponent <JCS_SlideScreenPanelHolder>();
// create the array of panel.
panelHolder9x9.slidePanels = new RectTransform[9];
int starting_pos_x = -1920;
int starting_pos_y = 1080;
const string slidePanelPath = "JCSUnity_Resources/LevelDesignUI/JCS_SlidePanel";
int index = 0;
// create all nine panel and assign to the slide panel.
for (int row = 0; row < 3; ++row)
{
for (int column = 0; column < 3; ++column)
{
// get the rect transform from the slide panel object.
RectTransform slidePanel = CreateHierarchyObjectUnderCanvas(slidePanelPath, jcsCanvas).GetComponent <RectTransform>();
// set the position into 9x9.
Vector3 slidePanelNewPos = slidePanel.localPosition;
slidePanelNewPos.x = starting_pos_x - (starting_pos_x * column);
slidePanelNewPos.y = starting_pos_y - (starting_pos_y * row);
slidePanel.localPosition = slidePanelNewPos;
// set scale to one.
slidePanel.localScale = Vector3.one;
Image panelImage = slidePanel.GetComponent <Image>();
if (panelImage != null)
{
panelImage.color = JCS_Random.RandomColor();
}
// assign to slide panel holder.
panelHolder9x9.slidePanels[index] = slidePanel;
++index;
}
}
const string slideScreenCameraPath = "JCSUnity_Resources/Camera/JCS_2DSlideScreenCamera";
JCS_2DSlideScreenCamera slideScreenCamera = CreateHierarchyObject(slideScreenCameraPath).GetComponent <JCS_2DSlideScreenCamera>();
Undo.RegisterCreatedObjectUndo(slideScreenCamera, "Create 2D Slide Screen Camera");
slideScreenCamera.name = "_2DSlideScreenCamera (Created)";
// set the panel holder.
slideScreenCamera.PanelHolder = panelHolder9x9;
slideScreenCamera.SetJCS2DCamera(cam);
// set to default 2d.
slideScreenCamera.UnityGUIType = JCS_UnityGUIType.uGUI_2D;
}
