Beispiel #1
0
        void SetClipInfo()
        {
            if (Panel && Panel.hasClipping && Camera && Camera.GetComponent <Camera>() && Renderers != null && Renderers.Count > 0)
            {
                Vector2 soft      = Panel.clipSoftness;
                Vector2 sharpness = new Vector2(1000.0f, 1000.0f);

                if (soft.x > 0f)
                {
                    sharpness.x = Panel.baseClipRegion.z / soft.x;
                }
                if (soft.y > 0f)
                {
                    sharpness.y = Panel.baseClipRegion.w / soft.y;
                }

                Vector4 panelCenterAndSharpness;

                Camera camera = Camera.GetComponent <Camera>();

                Vector3[] panelWorldCorners = Panel.worldCorners;
                Vector3   leftBottom        = camera.WorldToViewportPoint(panelWorldCorners[0]);
                Vector3   topRight          = camera.WorldToViewportPoint(panelWorldCorners[2]);
                Vector3   center            = Vector3.Lerp(leftBottom, topRight, 0.5f);

                panelCenterAndSharpness.x = center.x;
                panelCenterAndSharpness.y = center.y;
                panelCenterAndSharpness.z = sharpness.x;
                panelCenterAndSharpness.w = sharpness.y;


                for (int i = 0; i < Renderers.Count; i++)
                {
                    Renderer renderer = Renderers[i];
                    Material mat      = null;
                    if (!Application.isPlaying)
                    {
                        mat = renderer.sharedMaterial;
                    }
                    else
                    {
                        mat = renderer.material;
                    }

                    if (mat == null)
                    {
                        continue;
                    }
                    mat.SetFloat(PanelWidthAttribID, topRight.x - leftBottom.x);
                    mat.SetFloat(PanelHeightAttribID, topRight.y - leftBottom.y);
                    mat.SetVector(PanelCenterAndSharpnessAttribID, panelCenterAndSharpness);
                }
            }
        }
Beispiel #2
0
 private void SetUICameraDepthAndCullingMask()
 {
     mUICameras            = FindObjectOfType <UICamera>();
     mUICamera             = mUICameras.GetComponent <Camera>();
     mUICamera.depth       = mDefaultUIDepth + 1;
     mUICamera.cullingMask = 1 << (int)GameLayer.BossShow;
     AudioController.Instance.PlayBackgroundMusic("BossIn", false);
 }
Beispiel #3
0
    /// <summary>
    /// Immediately update the root's scale. Call this function after changing the min/max/manual height values.
    /// </summary>

    public void UpdateScale(bool updateAnchors = true)
    {
        if (mTrans != null)
        {
            float calcActiveHeight = activeHeight;

            if (calcActiveHeight > 0f)
            {
                float   size = 2f / calcActiveHeight;
                Vector3 ls   = mTrans.localScale;
                if (mUICamera != null)
                {
                    if (!(Mathf.Abs(ls.x - size * mUICamera.GetComponent <Camera>().orthographicSize) <= UIRootEpsilon) ||
                        !(Mathf.Abs(ls.y - size * mUICamera.GetComponent <Camera>().orthographicSize) <= UIRootEpsilon) ||
                        !(Mathf.Abs(ls.z - size * mUICamera.GetComponent <Camera>().orthographicSize) <= UIRootEpsilon))
                    {
                        mTrans.localScale = new Vector3(standardScale, standardScale, standardScale);
                        float oldMainSize = mUICamera.GetComponent <Camera>().orthographicSize;
                        float newMainSize = standardScale / size;
                        mUICamera.GetComponent <Camera>().orthographicSize = newMainSize;

                        CurrentOrthographicSize = newMainSize;

                        //初始化各摄像机
                        for (int i = 0; i < mCameraList.Length; i++)
                        {
                            float oldSize = mCameraList[i].GetComponent <Camera>().orthographicSize;
                            mCameraList[i].GetComponent <Camera>().orthographicSize = oldSize / oldMainSize * newMainSize;
                        }

                        if (updateAnchors)
                        {
                            BroadcastMessage("UpdateAnchors");
                        }

                        /*
                         * if (EasyJoystick.Instance)
                         * {
                         *  EasyJoystick.Instance.FixedScale();
                         * }
                         * */
                    }
                }
            }
        }
    }
Beispiel #4
0
    void LateUpdate()
    {
        var c = targetCamera;

        if (c == null)
        {
            c = Camera.main;
        }
        if (c == null)
        {
            return;
        }

        _wsPosition = GetVector3Value();

        if (_nguiCamera != null)
        {
            var ss = c.WorldToViewportPoint(_wsPosition);
            ss = _nguiCamera.GetComponent <Camera>().ViewportToWorldPoint(ss);
            if (pixelPerfect)
            {
                ss.x = (int)ss.x;
                ss.y = (int)ss.y;
            }
            ss.z = 0;
            gameObject.transform.localPosition = ss;
        }

        if (_anchor != null)
        {
            var ss = c.WorldToViewportPoint(_wsPosition);
            ss.x = -2 * ss.x * _anchor.localPosition.x;
            ss.y = -2 * ss.y * _anchor.localPosition.y;
            if (pixelPerfect)
            {
                ss.x = (int)ss.x;
                ss.y = (int)ss.y;
            }
            ss.z = 0;
            gameObject.transform.localPosition = ss;
        }
    }
Beispiel #5
0
    void Awake()
    {
        Instance = this;

        currentMenu = MenuType.Main;
        
        Transform UIRoot = transform.FindChild("UI Root");
      
        MainCamera = UIRoot.FindChild("Camera").GetComponent<UICamera>();
        MainCamera.enabled = true;
        MainCamera.GetComponent<Camera>().enabled = true;
        
        // Get transforms for each menu
        MainMenu        = UIRoot.FindChild("Main Menu");
        SettingsMenu    = UIRoot.FindChild("Settings Menu");
        LeaderboardMenu = UIRoot.FindChild("Leaderboard Menu");
        GameMenu        = UIRoot.FindChild("Game Menu");
        CustomizeMenu       = UIRoot.FindChild("Customize Menu");
        
        ToggleMenusOn();
    }
Beispiel #6
0
        public void SetViewport(int x, int y, float viewportWidth, float viewportHeight)
        {
            float viewportX = x * viewportWidth;
            float viewportY = y * viewportHeight;

            Rect viewport = new Rect(
                viewportX + ViewerManager.Instance.ViewportEpsilon,
                viewportY + ViewerManager.Instance.ViewportEpsilon,
                viewportWidth - (ViewerManager.Instance.ViewportEpsilon * 2.0f),
                viewportHeight - (ViewerManager.Instance.ViewportEpsilon * 2.0f));

            Camera.rect   = viewport;
            UICamera.rect = viewport;

            AspectRatio aspectRatio = UICamera.GetComponent <AspectRatio>();

            if (null != aspectRatio)
            {
                aspectRatio.UpdateAspectRatio();
            }
        }
Beispiel #7
0
	/// <summary>
	/// Create a new UI.
	/// </summary>

	static public UIPanel CreateUI (Transform trans, bool advanced3D, int layer)
	{
		// Find the existing UI Root
		UIRoot root = (trans != null) ? NGUITools.FindInParents<UIRoot>(trans.gameObject) : null;

		if (root == null && UIRoot.list.Count > 0)
		{
			foreach (UIRoot r in UIRoot.list)
			{
				if (r.gameObject.layer == layer)
				{
					root = r;
					break;
				}
			}
		}

		// If we are working with a different UI type, we need to treat it as a brand-new one instead
		if (root != null)
		{
			UICamera cam = root.GetComponentInChildren<UICamera>();

			if (cam != null && cam.GetComponent<Camera>().orthographic == advanced3D)
			{
				trans = null;
				root = null;
			}
		}

		// If no root found, create one
		if (root == null)
		{
			GameObject go = NGUITools.AddChild(null, false);
			root = go.AddComponent<UIRoot>();

			// Automatically find the layers if none were specified
			if (layer == -1) layer = LayerMask.NameToLayer("UI");
			if (layer == -1) layer = LayerMask.NameToLayer("2D UI");
			go.layer = layer;

			if (advanced3D)
			{
				go.name = "UI Root (3D)";
				root.scalingStyle = UIRoot.Scaling.Constrained;
			}
			else
			{
				go.name = "UI Root";
				root.scalingStyle = UIRoot.Scaling.Flexible;
			}
		}

		// Find the first panel
		UIPanel panel = root.GetComponentInChildren<UIPanel>();

		if (panel == null)
		{
			// Find other active cameras in the scene
			Camera[] cameras = NGUITools.FindActive<Camera>();

			float depth = -1f;
			bool colorCleared = false;
			int mask = (1 << root.gameObject.layer);

			for (int i = 0; i < cameras.Length; ++i)
			{
				Camera c = cameras[i];

				// If the color is being cleared, we won't need to
				if (c.clearFlags == CameraClearFlags.Color ||
					c.clearFlags == CameraClearFlags.Skybox)
					colorCleared = true;

				// Choose the maximum depth
				depth = Mathf.Max(depth, c.depth);

				// Make sure this camera can't see the UI
				c.cullingMask = (c.cullingMask & (~mask));
			}

			// Create a camera that will draw the UI
			Camera cam = NGUITools.AddChild<Camera>(root.gameObject, false);
			cam.gameObject.AddComponent<UICamera>();
			cam.clearFlags = colorCleared ? CameraClearFlags.Depth : CameraClearFlags.Color;
			cam.backgroundColor = Color.grey;
			cam.cullingMask = mask;
			cam.depth = depth + 1f;

			if (advanced3D)
			{
				cam.nearClipPlane = 0.1f;
				cam.farClipPlane = 4f;
				cam.transform.localPosition = new Vector3(0f, 0f, -700f);
			}
			else
			{
				cam.orthographic = true;
				cam.orthographicSize = 1;
				cam.nearClipPlane = -10;
				cam.farClipPlane = 10;
			}

			// Make sure there is an audio listener present
			AudioListener[] listeners = NGUITools.FindActive<AudioListener>();
			if (listeners == null || listeners.Length == 0)
				cam.gameObject.AddComponent<AudioListener>();

			// Add a panel to the root
			panel = root.gameObject.AddComponent<UIPanel>();
#if UNITY_EDITOR
			UnityEditor.Selection.activeGameObject = panel.gameObject;
#endif
		}

		if (trans != null)
		{
			// Find the root object
			while (trans.parent != null) trans = trans.parent;

			if (NGUITools.IsChild(trans, panel.transform))
			{
				// Odd hierarchy -- can't reparent
				panel = trans.gameObject.AddComponent<UIPanel>();
			}
			else
			{
				// Reparent this root object to be a child of the panel
				trans.parent = panel.transform;
				trans.localScale = Vector3.one;
				trans.localPosition = Vector3.zero;
				SetChildLayer(panel.cachedTransform, panel.cachedGameObject.layer);
			}
		}
		return panel;
	}
Beispiel #8
0
    // Token: 0x060032D2 RID: 13010 RVA: 0x000FF7A4 File Offset: 0x000FDBA4
    public static UIPanel CreateUI(Transform trans, bool advanced3D, int layer)
    {
        UIRoot uiroot = (!(trans != null)) ? null : NGUITools.FindInParents <UIRoot>(trans.gameObject);

        if (uiroot == null && UIRoot.list.Count > 0)
        {
            foreach (UIRoot uiroot2 in UIRoot.list)
            {
                if (uiroot2.gameObject.layer == layer)
                {
                    uiroot = uiroot2;
                    break;
                }
            }
        }
        if (uiroot != null)
        {
            UICamera componentInChildren = uiroot.GetComponentInChildren <UICamera>();
            if (componentInChildren != null && componentInChildren.GetComponent <Camera>().orthographic == advanced3D)
            {
                trans  = null;
                uiroot = null;
            }
        }
        if (uiroot == null)
        {
            GameObject gameObject = NGUITools.AddChild(null, false);
            uiroot = gameObject.AddComponent <UIRoot>();
            if (layer == -1)
            {
                layer = LayerMask.NameToLayer("UI");
            }
            if (layer == -1)
            {
                layer = LayerMask.NameToLayer("2D UI");
            }
            gameObject.layer = layer;
            if (advanced3D)
            {
                gameObject.name     = "UI Root (3D)";
                uiroot.scalingStyle = UIRoot.Scaling.Constrained;
            }
            else
            {
                gameObject.name     = "UI Root";
                uiroot.scalingStyle = UIRoot.Scaling.Flexible;
            }
        }
        UIPanel uipanel = uiroot.GetComponentInChildren <UIPanel>();

        if (uipanel == null)
        {
            Camera[] array = NGUITools.FindActive <Camera>();
            float    num   = -1f;
            bool     flag  = false;
            int      num2  = 1 << uiroot.gameObject.layer;
            foreach (Camera camera in array)
            {
                if (camera.clearFlags == CameraClearFlags.Color || camera.clearFlags == CameraClearFlags.Skybox)
                {
                    flag = true;
                }
                num = Mathf.Max(num, camera.depth);
                camera.cullingMask &= ~num2;
            }
            Camera camera2 = NGUITools.AddChild <Camera>(uiroot.gameObject, false);
            camera2.gameObject.AddComponent <UICamera>();
            camera2.clearFlags      = ((!flag) ? CameraClearFlags.Color : CameraClearFlags.Depth);
            camera2.backgroundColor = Color.grey;
            camera2.cullingMask     = num2;
            camera2.depth           = num + 1f;
            if (advanced3D)
            {
                camera2.nearClipPlane           = 0.1f;
                camera2.farClipPlane            = 4f;
                camera2.transform.localPosition = new Vector3(0f, 0f, -700f);
            }
            else
            {
                camera2.orthographic     = true;
                camera2.orthographicSize = 1f;
                camera2.nearClipPlane    = -10f;
                camera2.farClipPlane     = 10f;
            }
            AudioListener[] array2 = NGUITools.FindActive <AudioListener>();
            if (array2 == null || array2.Length == 0)
            {
                camera2.gameObject.AddComponent <AudioListener>();
            }
            uipanel = uiroot.gameObject.AddComponent <UIPanel>();
        }
        if (trans != null)
        {
            while (trans.parent != null)
            {
                trans = trans.parent;
            }
            if (NGUITools.IsChild(trans, uipanel.transform))
            {
                uipanel = trans.gameObject.AddComponent <UIPanel>();
            }
            else
            {
                trans.parent        = uipanel.transform;
                trans.localScale    = Vector3.one;
                trans.localPosition = Vector3.zero;
                NGUITools.SetChildLayer(uipanel.cachedTransform, uipanel.cachedGameObject.layer);
            }
        }
        return(uipanel);
    }
    /// <summary>
    /// Draw the inspector widget.
    /// </summary>

    public override void OnInspectorGUI()
    {
        UIPanel panel = target as UIPanel;
        BetterList <UIDrawCall> drawcalls = panel.drawCalls;

        EditorGUIUtility.LookLikeControls(80f);

        //NGUIEditorTools.DrawSeparator();
        EditorGUILayout.Space();

        float alpha = EditorGUILayout.Slider("Alpha", panel.alpha, 0f, 1f);

        if (alpha != panel.alpha)
        {
            NGUIEditorTools.RegisterUndo("Panel Alpha", panel);
            panel.alpha = alpha;
        }

        if (panel.showInPanelTool != EditorGUILayout.Toggle("Panel Tool", panel.showInPanelTool))
        {
            panel.showInPanelTool = !panel.showInPanelTool;
            EditorUtility.SetDirty(panel);
            EditorWindow.FocusWindowIfItsOpen <UIPanelTool>();
        }

        GUILayout.BeginHorizontal();
        bool norms = EditorGUILayout.Toggle("Normals", panel.generateNormals, GUILayout.Width(100f));

        GUILayout.Label("Needed for lit shaders");
        GUILayout.EndHorizontal();

        if (panel.generateNormals != norms)
        {
            panel.generateNormals = norms;
            panel.UpdateDrawcalls();
            EditorUtility.SetDirty(panel);
        }

        GUILayout.BeginHorizontal();
        bool depth = EditorGUILayout.Toggle("Depth Pass", panel.depthPass, GUILayout.Width(100f));

        GUILayout.Label("Doubles draw calls, saves fillrate");
        GUILayout.EndHorizontal();

        if (panel.depthPass != depth)
        {
            panel.depthPass = depth;
            panel.UpdateDrawcalls();
            EditorUtility.SetDirty(panel);
        }

        if (depth)
        {
            UICamera cam = UICamera.FindCameraForLayer(panel.gameObject.layer);

            if (cam == null || cam.GetComponent <Camera>().orthographic)
            {
                EditorGUILayout.HelpBox("Please note that depth pass will only save fillrate when used with 3D UIs, and only UIs drawn by the game camera. If you are using a separate camera for the UI, you will not see any benefit!", MessageType.Warning);
            }
        }

        GUILayout.BeginHorizontal();
        bool stat = EditorGUILayout.Toggle("Static", panel.widgetsAreStatic, GUILayout.Width(100f));

        GUILayout.Label("Check if widgets won't move");
        GUILayout.EndHorizontal();

        if (panel.widgetsAreStatic != stat)
        {
            panel.widgetsAreStatic = stat;
            panel.UpdateDrawcalls();
            EditorUtility.SetDirty(panel);
        }

        EditorGUILayout.LabelField("Widgets", panel.widgets.size.ToString());
        EditorGUILayout.LabelField("Draw Calls", drawcalls.size.ToString());

        UIPanel.DebugInfo di = (UIPanel.DebugInfo)EditorGUILayout.EnumPopup("Debug Info", panel.debugInfo);

        if (panel.debugInfo != di)
        {
            panel.debugInfo = di;
            EditorUtility.SetDirty(panel);
        }

        UIDrawCall.Clipping clipping = (UIDrawCall.Clipping)EditorGUILayout.EnumPopup("Clipping", panel.clipping);

        if (panel.clipping != clipping)
        {
            panel.clipping = clipping;
            EditorUtility.SetDirty(panel);
        }

        if (panel.clipping != UIDrawCall.Clipping.None)
        {
            Vector4 range = panel.clipRange;

            GUILayout.BeginHorizontal();
            GUILayout.Space(80f);
            Vector2 pos = EditorGUILayout.Vector2Field("Center", new Vector2(range.x, range.y));
            GUILayout.EndHorizontal();

            GUILayout.BeginHorizontal();
            GUILayout.Space(80f);
            Vector2 size = EditorGUILayout.Vector2Field("Size", new Vector2(range.z, range.w));
            GUILayout.EndHorizontal();

            if (size.x < 0f)
            {
                size.x = 0f;
            }
            if (size.y < 0f)
            {
                size.y = 0f;
            }

            range.x = pos.x;
            range.y = pos.y;
            range.z = size.x;
            range.w = size.y;

            if (panel.clipRange != range)
            {
                NGUIEditorTools.RegisterUndo("Clipping Change", panel);
                panel.clipRange = range;
                EditorUtility.SetDirty(panel);
            }

            if (panel.clipping == UIDrawCall.Clipping.SoftClip)
            {
                GUILayout.BeginHorizontal();
                GUILayout.Space(80f);
                Vector2 soft = EditorGUILayout.Vector2Field("Softness", panel.clipSoftness);
                GUILayout.EndHorizontal();

                if (soft.x < 1f)
                {
                    soft.x = 1f;
                }
                if (soft.y < 1f)
                {
                    soft.y = 1f;
                }

                if (panel.clipSoftness != soft)
                {
                    NGUIEditorTools.RegisterUndo("Clipping Change", panel);
                    panel.clipSoftness = soft;
                    EditorUtility.SetDirty(panel);
                }
            }

#if !UNITY_3_5 && !UNITY_4_0 && (UNITY_ANDROID || UNITY_IPHONE)
            if (PlayerSettings.targetGlesGraphics == TargetGlesGraphics.OpenGLES_1_x)
            {
                EditorGUILayout.HelpBox("Clipping requires shader support!\n\nOpen File -> Build Settings -> Player Settings -> Other Settings, then set:\n\n- Graphics Level: OpenGL ES 2.0.", MessageType.Error);
            }
#endif
        }

        if (clipping == UIDrawCall.Clipping.HardClip)
        {
            EditorGUILayout.HelpBox("Hard clipping has been removed due to major performance issues on certain Android devices. Alpha clipping will be used instead.", MessageType.Warning);
        }

        if (clipping != UIDrawCall.Clipping.None && !NGUIEditorTools.IsUniform(panel.transform.lossyScale))
        {
            EditorGUILayout.HelpBox("Clipped panels must have a uniform scale, or clipping won't work properly!", MessageType.Error);

            if (GUILayout.Button("Auto-fix"))
            {
                NGUIEditorTools.FixUniform(panel.gameObject);
            }
        }

        foreach (UIDrawCall dc in drawcalls)
        {
            NGUIEditorTools.DrawSeparator();
            EditorGUILayout.ObjectField("Material", dc.material, typeof(Material), false);
            EditorGUILayout.LabelField("Triangles", dc.triangles.ToString());

            if (clipping != UIDrawCall.Clipping.None && !dc.isClipped)
            {
                EditorGUILayout.HelpBox("You must switch this material's shader to Unlit/Transparent Colored or Unlit/Premultiplied Colored in order for clipping to work.",
                                        MessageType.Warning);
            }
        }
    }
Beispiel #10
0
    public static UIPanel CreateUI(Transform trans, bool advanced3D, int layer)
    {
        UIRoot uIRoot = (!(trans != null)) ? null : NGUITools.FindInParents <UIRoot>(trans.get_gameObject());

        if (uIRoot == null && UIRoot.list.get_Count() > 0)
        {
            using (List <UIRoot> .Enumerator enumerator = UIRoot.list.GetEnumerator())
            {
                while (enumerator.MoveNext())
                {
                    UIRoot current = enumerator.get_Current();
                    if (current.get_gameObject().get_layer() == layer)
                    {
                        uIRoot = current;
                        break;
                    }
                }
            }
        }
        if (uIRoot != null)
        {
            UICamera componentInChildren = uIRoot.GetComponentInChildren <UICamera>();
            if (componentInChildren != null && componentInChildren.GetComponent <Camera>().get_orthographic() == advanced3D)
            {
                trans  = null;
                uIRoot = null;
            }
        }
        if (uIRoot == null)
        {
            GameObject gameObject = NGUITools.AddChild(null, false);
            uIRoot = gameObject.AddComponent <UIRoot>();
            if (layer == -1)
            {
                layer = LayerMask.NameToLayer("UI");
            }
            if (layer == -1)
            {
                layer = LayerMask.NameToLayer("2D UI");
            }
            gameObject.set_layer(layer);
            if (advanced3D)
            {
                gameObject.set_name("UI Root (3D)");
                uIRoot.scalingStyle = UIRoot.Scaling.Constrained;
            }
            else
            {
                gameObject.set_name("UI Root");
                uIRoot.scalingStyle = UIRoot.Scaling.Flexible;
            }
        }
        UIPanel uIPanel = uIRoot.GetComponentInChildren <UIPanel>();

        if (uIPanel == null)
        {
            Camera[] array = NGUITools.FindActive <Camera>();
            float    num   = -1f;
            bool     flag  = false;
            int      num2  = 1 << uIRoot.get_gameObject().get_layer();
            for (int i = 0; i < array.Length; i++)
            {
                Camera camera = array[i];
                if (camera.get_clearFlags() == 2 || camera.get_clearFlags() == 1)
                {
                    flag = true;
                }
                num = Mathf.Max(num, camera.get_depth());
                camera.set_cullingMask(camera.get_cullingMask() & ~num2);
            }
            Camera camera2 = NGUITools.AddChild <Camera>(uIRoot.get_gameObject(), false);
            camera2.get_gameObject().AddComponent <UICamera>();
            camera2.set_clearFlags((!flag) ? 2 : 3);
            camera2.set_backgroundColor(Color.get_grey());
            camera2.set_cullingMask(num2);
            camera2.set_depth(num + 1f);
            if (advanced3D)
            {
                camera2.set_nearClipPlane(0.1f);
                camera2.set_farClipPlane(4f);
                camera2.get_transform().set_localPosition(new Vector3(0f, 0f, -700f));
            }
            else
            {
                camera2.set_orthographic(true);
                camera2.set_orthographicSize(1f);
                camera2.set_nearClipPlane(-10f);
                camera2.set_farClipPlane(10f);
            }
            AudioListener[] array2 = NGUITools.FindActive <AudioListener>();
            if (array2 == null || array2.Length == 0)
            {
                camera2.get_gameObject().AddComponent <AudioListener>();
            }
            uIPanel = uIRoot.get_gameObject().AddComponent <UIPanel>();
        }
        if (trans != null)
        {
            while (trans.get_parent() != null)
            {
                trans = trans.get_parent();
            }
            if (NGUITools.IsChild(trans, uIPanel.get_transform()))
            {
                uIPanel = trans.get_gameObject().AddComponent <UIPanel>();
            }
            else
            {
                trans.set_parent(uIPanel.get_transform());
                trans.set_localScale(Vector3.get_one());
                trans.set_localPosition(Vector3.get_zero());
                NGUITools.SetChildLayer(uIPanel.cachedTransform, uIPanel.cachedGameObject.get_layer());
            }
        }
        return(uIPanel);
    }
    void LateUpdate()
    {
        // If we are in calibration scene, disable 3d cursor
        if (this.transform.parent == null)
        {
            this.enabled = false;
            return;
        }

        // TODO: instead of searching hierarchy on every frame, find the UICameras more efficiently
        uiCamera = ruisCamera.transform.GetComponentInChildren <UICamera>();        //menuScript.transform.parent.parent.GetComponentsInChildren<UICamera>();

        if (menuScript.menuIsVisible && !instancedCursor)
        {
            instancedCursor = Instantiate(this.markerObject) as GameObject;
        }
        if (!menuScript.menuIsVisible && instancedCursor)
        {
            Destroy(instancedCursor);
        }

        if (!menuScript.menuIsVisible)
        {
            return;
        }

        mouseInputCoordinates = Input.mousePosition;
        if (ruisCamera.centerCamera)
        {
            if (instancedCursor)
            {
                instancedCursor.transform.rotation = ruisCamera.centerCamera.transform.rotation;
            }
        }
        else
        {
            if (instancedCursor)
            {
                instancedCursor.transform.rotation = ruisCamera.transform.rotation;
            }
        }

        // HACK for MecanimBlendedCharacter: Keep cursor visible size even if character is scaled
        if (menuScript.transform.parent)
        {
            instancedCursor.transform.localScale = originalLocalScale * Mathf.Max(menuScript.transform.parent.lossyScale.x, menuScript.transform.parent.lossyScale.y);
        }

        RaycastHit hit;

        if (uiCamera)
        {
            /*
             * if(!ruisCamera.associatedDisplay.isStereo
             * &&	(camera.gameObject.name == "CameraLeft"
             ||	camera.gameObject.name == "CameraRight"
             || camera.gameObject.name == "guiCameraForRift"
             ||))
             ||{
             ||     camera.enabled = false;
             ||     continue;
             ||}
             ||
             ||if(ruisCamera.associatedDisplay.isStereo
             ||     && !ruisCamera.associatedDisplay.enableOculusRift
             ||     && !(camera.gameObject.name == "CameraLeft"
             ||	camera.gameObject.name == "CameraRight"
             ||     ))
             ||     {
             ||             camera.enabled = false;
             ||             continue;
             ||     }
             ||if(ruisCamera.associatedDisplay.enableOculusRift
             ||     && camera.gameObject.name != "guiCameraForRift")
             ||     {
             ||             camera.enabled = false;
             ||             continue;
             ||     }
             */

            Ray    ray;
            Camera rayCamera = uiCamera.GetComponent <Camera>();

            if (rayCamera)
            {
                if (UnityEngine.XR.XRSettings.enabled && rayCamera.stereoTargetEye != StereoTargetEyeMask.None)                // if(ruisCamera.associatedDisplay != null && ruisCamera.associatedDisplay.isHmdDisplay)
                {
                    // *** TODO remove this hack when Camera.ScreenPointToRay() works again
                    ray = RUISDisplayManager.HMDScreenPointToRay(mouseInputCoordinates, rayCamera);
                }
                else
                {
                    ray = rayCamera.ScreenPointToRay(mouseInputCoordinates);
                }
            }
            else
            {
                ray = new Ray();
            }

            if (ruisCamera.associatedDisplay != null && ruisCamera.associatedDisplay.isObliqueFrustum)
            {
                Quaternion outerRot = ruisCamera.transform.rotation;
                wallOrientation = Quaternion.LookRotation(-ruisCamera.associatedDisplay.DisplayNormal, ruisCamera.associatedDisplay.DisplayUp);

                // *** HACK why is this sign flip necessary to keep the menu at right place??
                outerRot = new Quaternion(outerRot.x, outerRot.y, -outerRot.z, outerRot.w);

                instancedCursor.transform.rotation = outerRot * wallOrientation;

                trackerPosition = outerRot * ruisCamera.KeystoningHeadTrackerPosition;
                ray.origin     += trackerPosition - outerRot * (new Vector3(ruisDisplayManager.guiX,
                                                                            ruisDisplayManager.guiY,
                                                                            ruisDisplayManager.guiZ));
//				ray.direction =  wallOrientation * ray.direction;
            }

            if (Physics.Raycast(ray, out hit, Mathf.Infinity, LayerMask.GetMask(LayerMask.LayerToName(ruisDisplayManager.menuLayer))))
            {
                if (instancedCursor)
                {
                    instancedCursor.transform.position = hit.point;

                    if (!wasVisible)
                    {
                        instancedCursor.SetActive(true);
                    }
                    wasVisible = true;
                }
                                #if UNITY_EDITOR
                Debug.DrawLine(ray.origin, hit.point);
                                #endif
            }
            else
            {
                if (wasVisible)
                {
                    instancedCursor.SetActive(false);
                }
                wasVisible = false;
            }
        }
    }
    void Update()
    {
        uiCam.enabled    = !GameManager.isPaused && !RoundEndManager.isRoundEnded;
        chatOutput.alpha = 1f - blackSprite.alpha;
        uiCam.GetComponent <BlurEffect>().blurSpread = blurREM;

        GunController primaryWep = WeaponDatabase.GetWeaponByID(primarySelection.selectionIndex);

        primaryTooltip.textSize = 0.8f;
        primaryTooltip.text     = "Weapon Statistics:[C6BCB6]" + "||" + "Damage: " + (primaryWep.bulletInfo.damage * primaryWep.bulletsPerShot)
                                  + "||" + "Rate of Fire: " + primaryWep.firstRPM.ToString("F0") + " RPM"
                                  + "||" + "Vertical Recoil: " + primaryWep.upKickAmount
                                  + "||" + "Horizontal Recoil: " + primaryWep.sideKickAmount
                                  + "||" + "Effective Range: " + primaryWep.GetMinimumRange() + "-" + primaryWep.GetMaximumRange() + "m"
                                  + "||" + "Weight: " + primaryWep.weaponWeight.ToString("F2") + " kg";

        GunController secondaryWep = WeaponDatabase.GetWeaponByID(secondarySelection.selectionIndex);

        secondaryTooltip.textSize = 0.8f;
        secondaryTooltip.text     = "Weapon Statistics:[C6BCB6]" + "||" + "Damage: " + (secondaryWep.bulletInfo.damage * secondaryWep.bulletsPerShot)
                                    + "||" + "Rate of Fire: " + secondaryWep.firstRPM.ToString("F0") + " RPM"
                                    + "||" + "Vertical Recoil: " + secondaryWep.upKickAmount
                                    + "||" + "Horizontal Recoil: " + secondaryWep.sideKickAmount
                                    + "||" + "Effective Range: " + secondaryWep.GetMinimumRange() + "-" + secondaryWep.GetMaximumRange() + "m"
                                    + "||" + "Weight: " + secondaryWep.weaponWeight.ToString("F2") + " kg";

        if (GeneralVariables.gameModeHasTeams)
        {
            if (spectateFollow.target == null)
            {
                GetAllTeamInstances();
            }
            else
            {
                Rigidbody theRigid = spectateFollow.target.GetComponent <Rigidbody>();
                if (theRigid != null && !theRigid.isKinematic)
                {
                    spectateFollow.target = null;
                    GetAllTeamInstances();
                }
            }
        }

        if (mpGUI != null)
        {
            timeLabel.color = mpGUI.timerLabels[0].color;
            if (GeneralVariables.Networking.countingDown)
            {
                timeLabel.text = "MATCH STARTING: " + GeneralVariables.Networking.countdown.ToString();
            }
            else
            {
                if (mpGUI.timerLabels[0].text == "--")
                {
                    timeLabel.text = "WAITING FOR: " + mpGUI.serverPL.ToString() + " player" + ((mpGUI.serverPL == 1) ? "" : "s");
                }
                else
                {
                    timeLabel.text = mpGUI.timerLabels[0].text + ":" + mpGUI.timerLabels[1].text;
                }
            }

            if (GeneralVariables.gameModeHasTeams)
            {
                redTitle.text  = "RED TEAM";
                blueTitle.text = "BLUE TEAM";
            }
            else
            {
                redTitle.text  = (mpGUI.youAreWinning) ? "YOU" : mpGUI.winningPlayerName.ToUpper();
                blueTitle.text = (mpGUI.youAreWinning) ? mpGUI.runnerUpName.ToUpper() : "YOU";
            }

            redTeamProgress.value = mpGUI.redTeamProgress.value;
            redTeamProgress.foregroundWidget.color = mpGUI.redTeamProgress.foregroundWidget.color;
            blueTeamProgress.value = mpGUI.blueTeamProgress.value;
            blueTeamProgress.foregroundWidget.color = mpGUI.blueTeamProgress.foregroundWidget.color;
            redTeamValue.text  = mpGUI.redTeamValue.text;
            blueTeamValue.text = mpGUI.blueTeamValue.text;
        }

        if (Topan.Network.isConnected && GeneralVariables.Networking != null)
        {
            string suffix         = "ready";
            int    playersWaiting = Topan.Network.connectedPlayers.Length;
            if (GeneralVariables.Networking.matchStarted)
            {
                matchStatus.text  = "BATTLE INITIATED";
                matchStatus.alpha = matchStatus.defaultAlpha;
                suffix            = "in battle";
            }
            else
            {
                matchStatus.text  = "BATTLE AWAITING";
                matchStatus.alpha = (matchStatus.defaultAlpha - 0.2f) + Mathf.PingPong(Time.time * 2f * 0.2f, 0.2f);
                playersWaiting    = Mathf.CeilToInt(playersWaiting * 0.25f);

                if (Topan.Network.HasServerInfo("pl"))
                {
                    playersWaiting -= (int)((byte)Topan.Network.GetServerInfo("pl"));
                }
            }

            matchName.text    = Topan.Network.GameName;
            matchDetails.text = StaticMapsList.mapsArraySorted[(byte)Topan.Network.GetServerInfo("m")].mapName + "\n" + "> [5C5C5C]" + NetworkingGeneral.currentGameType.typeName + "[-]" + "\n" + "\n" +
                                Mathf.Max(0, playersWaiting).ToString() + " combatant" + ((playersWaiting == 0 || playersWaiting > 1) ? "s " : " ") + suffix;
        }

        if (spectatorPositions != null && spectatorPositions.Count > 0)
        {
            if (Input.GetKeyDown(KeyCode.Space) && !RestrictionManager.restricted && UICamera.selectedObject == null && !isTransitioning)
            {
                autoSpectate = false;
                StartCoroutine(TransitionToIndex(specIndex + 1));
            }

            if (autoSpectate && Time.time - autoSpectateTimer >= spectateCycleInterval && specIndex < spectatorPositions.Count && spectatorPositions.Count > 1 && !isTransitioning)
            {
                int newRandomPoint = 0;

                do
                {
                    newRandomPoint = Random.Range(0, spectatorPositions.Count);
                }while (newRandomPoint == specIndex);

                autoSpectateTimer = Time.time;
                StartCoroutine(TransitionToIndex(newRandomPoint));
            }

            specIndex = Mathf.Clamp(specIndex, 0, spectatorPositions.Count + myAvailableTeamList.Count - 1);

            if (specIndex >= spectatorPositions.Count && myAvailableTeamList.Count > 0)
            {
                spectateFollow.enabled = true;
                spectateFollow.offset  = Vector3.up * 0.8f;
                spectateFollow.target  = myAvailableTeamList[specIndex - spectatorPositions.Count];
                spectateLabel.text     = "Spectating: " + myAvailableTeamList[specIndex - spectatorPositions.Count].root.name;
                spectateNote.text      = "[SPACE] to switch cameras" + "\n" + "[RMB] to rotate camera";
            }
            else
            {
                spectateFollow.enabled = false;
                spectateFollow.target  = null;

                //Regular spectator cameras
                specCamTr.position   = spectatorPositions[specIndex].position;
                specCamSway.focusRot = spectatorPositions[specIndex].eulerAngles;
                spectateLabel.text   = "Spectating: Camera_" + (specIndex + 1).ToString("000");
                spectateNote.text    = "[SPACE] to switch cameras";
            }
        }
    }