예제 #1
0
        //---------------------------------------------------------

        /// <summary>
        /// インスタンス生成(スクリプトから生成する場合)
        /// </summary>
        /// <returns></returns>
        public static UIEventSystem Create()
        {
            if (m_Instance != null)
            {
                return(m_Instance);
            }

#if UNITY_EDITOR
            if (GameObject.FindObjectOfType <EventSystem>() != null)
            {
                Debug.LogWarning("既にシーン内に EventSystem が存在しています。UIEventSystm への差し替えを推奨します。");
            }
#endif

            // オブジェクトが非アクティブだと検出されないのでオブジェクトを非アクティブにしてはならない
            // この判定は必須で mInstance は static であるためシーンの最初はオブジェクトが存在しても null になっている
            m_Instance = GameObject.FindObjectOfType(typeof(UIEventSystem)) as UIEventSystem;
            if (m_Instance == null)
            {
                GameObject tGameObject = new GameObject("EventSystem");
                tGameObject.AddComponent <UIEventSystem>();

                tGameObject.transform.localPosition = Vector3.zero;
                tGameObject.transform.localRotation = Quaternion.identity;
                tGameObject.transform.localScale    = Vector3.one;
            }

            return(m_Instance);
        }
예제 #2
0
 void OnDestroy()
 {
     if (m_Instance == this)
     {
         m_Instance = null;
     }
 }
예제 #3
0
        // Clicked(UIButton から呼び出される)
        internal protected void OnClicked(bool tWaitForTransition)
        {
            if (m_State != State.Clicked && m_State != State.Finished)
            {
                m_WaitForTransition = tWaitForTransition;
                if (m_WaitForTransition == true)
                {
//					Debug.LogWarning( "------- クリックされたのでクリック後のトランジション発動" ) ;
                    UIEventSystem.Disable(31);
                }

                // 押されたボタンを同階層で最も手前に表示する
                if (transform.parent != null)
                {
                    UIView tParent = transform.parent.GetComponent <UIView>();
                    if (tParent != null)
                    {
                        Vector3 p = transform.localPosition;
                        p.z = 10;
                        transform.localPosition = p;
                        tParent.SortChildByZ();
                    }
                }

                ChangeTransitionState(State.Clicked, State.Clicked);
                m_Press = false;
            }
        }
예제 #4
0
        //-------------------------------------------------------------------
        // トランジジョンの状態を変える
        private bool ChangeTransitionState(State tState, State tEaseState)
        {
            if (m_State == tState)
            {
                // 状態が同じなので処理しない
                return(true);
            }

            // 現在の RectTransform の状態を退避する

            if (m_RectTransform == null)
            {
                m_RectTransform = GetComponent <RectTransform>();
            }
            if (m_RectTransform == null)
            {
                // RectTransform がアタッチされていない
                return(false);
            }


            // 現在変化中の状態を変化前の状態とする
            //		m_BasePosition	= m_MovePosition ;
            m_BaseRotation = m_MoveRotation;
            m_BaseScale    = m_MoveScale;

            m_State      = tState;
            m_EaseState  = tEaseState;
            m_BaseTime   = Time.realtimeSinceStartup;
            m_Processing = true;

            if (spriteOverwriteEnabled == true)
            {
                UIImage tImage = GetComponent <UIImage>();
                if (tImage != null && tImage.atlasSprite != null)
                {
                    // 画像を変更する

                    Transition tData = transition[( int )m_State];

                    if (tData.sprite != null)
                    {
                        tImage.SetSpriteInAtlas(tData.sprite.name);
                    }
                }
            }

            if (m_State == State.Clicked)
            {
                UIEventSystem.Disable(31);
            }

            return(true);
        }
예제 #5
0
        //-----------------------------------------------------

        /// <summary>
        /// 派生クラスの Awake
        /// </summary>
        override protected void OnAwake()
        {
            if (Application.isPlaying == true)
            {
                // 実行中のみイベントシステムを生成する
                UIEventSystem.Create();

                //---------------------------------------------------------

                // 実行時に簡易的に状態を設定する

                if (renderMode != AutomaticRenderMode.None)
                {
                    SetRenderMode(renderMode);
                }
            }
        }
예제 #6
0
        //-----------------------------------------------------------------

        void Awake()
        {
            // 既に存在し重複になる場合は自身を削除する(シーンを加えようとした場合)
            if (m_Instance != null)
            {
                Debug.LogWarning("Destroy Myself !!:" + name);
                GameObject.DestroyImmediate(gameObject);
                return;
            }

            //-----------------------------
            // Awake 内でマニュアルで実行した場合とスクリプトで実行した場合の共通の処理を行う必要がある

            m_Instance = this;

            //-----------------------------

            // 原点じゃないと気持ち悪い
            gameObject.transform.localPosition = Vector3.zero;
            gameObject.transform.localRotation = Quaternion.identity;
            gameObject.transform.localScale    = Vector3.one;

            //-----------------------------

            EventSystem eventSystem = GetComponent <EventSystem>();

            if (eventSystem == null)
            {
                eventSystem = gameObject.AddComponent <EventSystem>();
            }

            eventSystem.enabled = (m_Lock == 0);

            // カスタマイズ版のインプットモジュールを使用する
            if (GetComponent <StandaloneInputModuleWrapper>() == null)
            {
                m_StandaloneInputModule = gameObject.AddComponent <StandaloneInputModuleWrapper>();
                m_StandaloneInputModule.SetProcessType(ProcessType);
                m_StandaloneInputModule.SetOnPressAction(m_OnPressAction);
            }
        }
예제 #7
0
        // トランジションの状態を反映させる
        private bool ProcessTransition()
        {
            if (m_RectTransform == null)
            {
                m_RectTransform = GetComponent <RectTransform>();
            }
            if (m_RectTransform == null)
            {
                // RectTransform がアタッチされていない
                return(false);
            }

            float tTime = Time.realtimeSinceStartup - m_BaseTime;

            Transition tData     = transition[( int )m_State];
            Transition tEaseData = transition[( int )m_EaseState];

            if (tData.processType == ProcessType.Ease)
            {
                if (tData.fadeDuration > 0)
                {
                    float tFactor = tTime / tData.fadeDuration;
                    if (tFactor > 1)
                    {
                        tFactor      = 1;
                        m_Processing = false;
                    }

                    //				m_MovePosition = GetValue( m_BasePosition, tData.fadePosition, tFactor, tEaseData.fadeEaseType ) ;
                    m_MoveRotation = GetValue(m_BaseRotation, tData.fadeRotation, tFactor, tEaseData.fadeEaseType);
                    m_MoveScale    = GetValue(m_BaseScale, tData.fadeScale, tFactor, tEaseData.fadeEaseType);

                    //				tRectTransform.anchoredPosition  = m_InitialPosition + m_MovePosition ;
                    //				tRectTransform.localEulerAngles  = m_InitialRotation + m_MoveRotation ;
                    //				tRectTransform.localScale        = new Vector3( m_InitialScale.x * m_MoveScale.x, m_InitialScale.y * m_MoveScale.y, m_InitialScale.z * m_MoveScale.z ) ;
                    //				tRectTransform.anchoredPosition  = m_InitialPosition + m_MovePosition ;
                    m_RectTransform.localEulerAngles = m_MoveRotation;
                    m_RectTransform.localScale       = m_MoveScale;
                }
            }
            else
            if (tData.processType == ProcessType.AnimationCurve)
            {
                int      l             = tData.fadeAnimationCurve.length;
                Keyframe tKeyFrame     = tData.fadeAnimationCurve[l - 1];                       // 最終キー
                float    tFadeDuration = tKeyFrame.time;

                if (tFadeDuration > 0)
                {
                    if (tTime > tFadeDuration)
                    {
                        tTime        = tFadeDuration;
                        m_Processing = false;
                    }

                    float tValue = tEaseData.fadeAnimationCurve.Evaluate(tTime);
                    //				m_MovePosition = Vector3.Lerp( m_BasePosition, tData.fadePosition, tValue ) ;
                    m_MoveRotation = Vector3.Lerp(m_BaseRotation, tData.fadeRotation, tValue);
                    m_MoveScale    = Vector3.Lerp(m_BaseScale, tData.fadeScale, tValue);

                    //				tRectTransform.anchoredPosition  = m_InitialPosition + m_MovePosition ;
                    //				tRectTransform.localEulerAngles  = m_InitialRotation + m_MoveRotation ;
                    //				tRectTransform.localScale        = new Vector3( m_InitialScale.x * m_MoveScale.x, m_InitialScale.y * m_MoveScale.y, m_InitialScale.z * m_MoveScale.z ) ;
                    m_RectTransform.localEulerAngles = m_MoveRotation;
                    m_RectTransform.localScale       = m_MoveScale;
                }
            }


            if (m_Processing == false)
            {
                // 終了
                if (m_State == State.Clicked)
                {
                    // 元の見た目に戻す
                    ChangeTransitionState(State.Finished, State.Finished);
                }
                else
                if (m_State == State.Finished)
                {
                    UIEventSystem.Enable(31);

                    UIButton tButton = GetComponent <UIButton>();
                    if (tButton != null)
                    {
                        tButton.OnButtonClickFromTransition();
                    }

                    if (m_PauseAfterFinished == true)
                    {
                        m_Pausing = true;                               // 動作をロックする
                    }
                }
            }


            return(true);
        }