Ejemplo n.º 1
0
        // 文章をアニメーション表示させる
        private IEnumerator Play_Coroutine <T>(int tStartLine, int tEndLine, float tCodeTime, bool tIsAbsoluteTime, Func <RichText.ExtraTagEvent, T, IEnumerator> tOnEvent, T tObject, params string[] tFilter)
        {
            RichText tRichText = _richText;

            if (tRichText == null)
            {
                yield break;
            }

            int tLine = line;

            if (tStartLine < 0)
            {
                tStartLine = 0;
            }
            if (tStartLine > (tLine - 1))
            {
                tStartLine = (tLine - 1);
            }

            if (tEndLine < 0)
            {
                tEndLine = tLine;
            }
            if (tEndLine > tLine)
            {
                tEndLine = tLine;
            }

            if (tEndLine >= 0 && tEndLine < (tStartLine + 1))
            {
                tEndLine = (tStartLine + 1);
            }

            if (tCodeTime <= 0)
            {
                tCodeTime = 0.05f;
            }

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

            m_Playing      = true;
            m_Pausing      = false;
            m_EventPausing = false;
            m_Break        = false;

            tRichText.viewControllEnabled = true;
            tRichText.lengthOfView        = -1;
            tRichText.startLineOfView     = tStartLine;
            tRichText.endLineOfView       = tEndLine;

            List <RichText.ExtraTagEvent> tEvent = new List <RichText.ExtraTagEvent>();

            RichText.ExtraTagEvent[] tEventTemporary = tRichText.GetExtraTagEvent(tFilter);

            bool f = false;

            if (tEvent != null)
            {
                int i, l = tEventTemporary.Length;
                for (i = 0; i < l; i++)
                {
                    tEvent.Add(tEventTemporary[i]);
                }

                l = tEvent.Count;
                if (l > 0)
                {
                    if (tEvent[l - 1].offset >= tRichText.endOffsetOfView)
                    {
                        // 一番最後にスベントが存在する
                        f = true;
                    }
                }
            }

            if (f == false)
            {
                // 最後の終端を追加する
                tEvent.Add(new RichText.ExtraTagEvent(tRichText.endOffsetOfView, null, null));
            }

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

            // タイマー開始
            StartTimer(tIsAbsoluteTime);

            float tTime, t;

            int o = tRichText.startOffsetOfView;

            // イベントでループ
            int e;

            for (e = 0; e < tEvent.Count; e++)
            {
                //--------------------------------------------------------/

                // 1イベントあたりの文字列の表示時間
                tTime = (tEvent[e].offset - o) * tCodeTime;

                tRichText.ratioOfFade       = 0;
                tRichText.startOffsetOfFade = o;
                tRichText.endOffsetOfFade   = tEvent[e].offset;

                // 1イベントの文字列の表示ループ
                t = 0;
                while (t < tTime)
                {
                    if (m_Pausing == true)
                    {
                        // 先にポーズ中かのチェックを入れておかないと1フレーム消費して表示が激遅なる
                        yield return(new WaitWhile(() => m_Pausing == true));
                    }

                    if (m_Break == true)
                    {
                        // 強制終了
                        tRichText.ratioOfFade       = 1;
                        tRichText.startOffsetOfFade = tRichText.startOffsetOfView;
                        tRichText.endOffsetOfFade   = tRichText.endOffsetOfView;

                        m_Break   = false;
                        m_Playing = false;

                        yield break;
                    }

                    t = t + GetDeltaTime();
                    if (t > tTime)
                    {
                        t = tTime;
                    }

                    tRichText.ratioOfFade = t / tTime;

                    yield return(null);
                }

                if (string.IsNullOrEmpty(tEvent[e].tagName) == false)
                {
                    if (tOnEvent != null)
                    {
                        m_EventPausing = true;

                        // イベント用のコールバックを呼び出す
                        m_Callback = tOnEvent(tEvent[e], tObject);
                        yield return(StartCoroutine(m_Callback));

                        m_EventPausing = false;
                    }
                }

                o = tEvent[e].offset;
            }

            m_Break   = false;
            m_Playing = false;

            m_Coroutine = null;
        }
        public override void OnInspectorGUI()
        {
            serializedObject.Update();

            EditorGUILayout.PropertyField(m_Text);
            EditorGUILayout.PropertyField(m_FontData);
            AppearanceControlsGUI();
            RaycastControlsGUI();
            serializedObject.ApplyModifiedProperties();

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

            EditorGUILayout.Separator();                // 少し区切りスペース

            // ターゲットのインスタンス
            RichText tTarget = target as RichText;

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

            bool tViewControllEnabled = EditorGUILayout.Toggle("View Controll Enabled", tTarget.viewControllEnabled);

            if (tViewControllEnabled != tTarget.viewControllEnabled)
            {
                Undo.RecordObject(tTarget, "RichText : View Controll Enabled Change");                          // アンドウバッファに登録
                tTarget.viewControllEnabled = tViewControllEnabled;
                EditorUtility.SetDirty(tTarget);
//				UnityEditor.SceneManagement.EditorSceneManager.MarkSceneDirty( UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene() ) ;
            }

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

            if (tTarget.viewControllEnabled == true)
            {
                int tLengthOfView = EditorGUILayout.IntSlider("Length Of View", tTarget.lengthOfView, -1, tTarget.length);
                if (tLengthOfView != tTarget.lengthOfView)
                {
                    Undo.RecordObject(tTarget, "RichText : Length Of View Change");                             // アンドウバッファに登録
                    tTarget.lengthOfView = tLengthOfView;
                    EditorUtility.SetDirty(tTarget);
                }

                int tLine = tTarget.line;

                int tStartLineOfView = EditorGUILayout.IntSlider("Start Line Of View", tTarget.startLineOfView, 0, tLine - 1);

                if (tStartLineOfView > (tLine - 1))
                {
                    tStartLineOfView = (tLine - 1);
                }

                if (tStartLineOfView != tTarget.startLineOfView)
                {
                    tTarget.startLineOfView = tStartLineOfView;
                    EditorUtility.SetDirty(tTarget);
                }

                int tEndLineOfView = EditorGUILayout.IntSlider("End Line Of View", tTarget.endLineOfView, tTarget.startLineOfView + 1, tLine);

                if (tEndLineOfView < (tTarget.startLineOfView + 1))
                {
                    tEndLineOfView = (tTarget.startLineOfView + 1);
                }

                if (tEndLineOfView > tLine)
                {
                    tEndLineOfView = tLine;
                }

                if (tEndLineOfView != tTarget.endLineOfView)
                {
                    tTarget.endLineOfView = tEndLineOfView;
                    EditorUtility.SetDirty(tTarget);
                }

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

                int tStartOffsetOfView = tTarget.startOffsetOfView;
                int tEndOffsetOfView   = tTarget.endOffsetOfView;

                int tStartOffsetOfFade = EditorGUILayout.IntSlider("Start Offset Of Fade", tTarget.startOffsetOfFade, tStartOffsetOfView, tEndOffsetOfView);

                if (tStartOffsetOfFade < tStartOffsetOfView)
                {
                    tStartOffsetOfFade = tStartOffsetOfView;
                }

                if (tStartOffsetOfFade > tEndOffsetOfView)
                {
                    tStartOffsetOfFade = tEndOffsetOfView;
                }

                if (tStartOffsetOfFade != tTarget.startOffsetOfFade)
                {
                    Undo.RecordObject(tTarget, "RichText : Start Offset Of Fade Change");                               // アンドウバッファに登録
                    tTarget.startOffsetOfFade = tStartOffsetOfFade;
                    EditorUtility.SetDirty(tTarget);
                }

                int tEndOffsetOfFade = EditorGUILayout.IntSlider("End Offset Of Fade", tTarget.endOffsetOfFade, tTarget.startOffsetOfFade, tEndOffsetOfView);

                if (tEndOffsetOfFade < tTarget.startOffsetOfFade)
                {
                    tEndOffsetOfFade = tTarget.startOffsetOfFade;
                }

                if (tEndOffsetOfFade > tEndOffsetOfView)
                {
                    tEndOffsetOfFade = tEndOffsetOfView;
                }

                if (tEndOffsetOfFade != tTarget.endOffsetOfFade)
                {
                    Undo.RecordObject(tTarget, "RichText : End Offset Of Fade Change");                         // アンドウバッファに登録
                    tTarget.endOffsetOfFade = tEndOffsetOfFade;
                    EditorUtility.SetDirty(tTarget);
                }


                float tRatioOfFade = EditorGUILayout.Slider("Ratio Of Fade", tTarget.ratioOfFade, 0.0f, 1.0f);
                if (tRatioOfFade != tTarget.ratioOfFade)
                {
                    Undo.RecordObject(tTarget, "RichText : Ratio Of Fade Change");                              // アンドウバッファに登録
                    tTarget.ratioOfFade = tRatioOfFade;
                    EditorUtility.SetDirty(tTarget);
                }

                int tWidthOfFade = EditorGUILayout.IntSlider("Width Of Fade", tTarget.widthOfFade, 0, 10);
                if (tWidthOfFade != tTarget.widthOfFade)
                {
                    Undo.RecordObject(tTarget, "RichText : Width Of Fade Change");                              // アンドウバッファに登録
                    tTarget.widthOfFade = tWidthOfFade;
                    EditorUtility.SetDirty(tTarget);
                }
            }

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

            EditorGUILayout.Separator();                // 少し区切りスペース

            float tRubySizeScale = EditorGUILayout.Slider("Ruby Size Scale", tTarget.rubySizeScale, 0.1f, 1.0f);

            if (tRubySizeScale != tTarget.rubySizeScale)
            {
                Undo.RecordObject(tTarget, "RichText : Ruby Size Scale Change");                        // アンドウバッファに登録
                tTarget.rubySizeScale = tRubySizeScale;
                EditorUtility.SetDirty(tTarget);
            }

            float tSupOrSubSizeScale = EditorGUILayout.Slider("Sup Or Sub Size Scale", tTarget.supOrSubSizeScale, 0.1f, 1.0f);

            if (tSupOrSubSizeScale != tTarget.supOrSubSizeScale)
            {
                Undo.RecordObject(tTarget, "RichText : Sup Or Sub Size Scale Change");                          // アンドウバッファに登録
                tTarget.supOrSubSizeScale = tSupOrSubSizeScale;
                EditorUtility.SetDirty(tTarget);
            }

            float tTopMarginSpacing = EditorGUILayout.FloatField("Top Margin Spacing", tTarget.topMarginSpacing);

            if (tTopMarginSpacing != tTarget.topMarginSpacing)
            {
                Undo.RecordObject(tTarget, "RichText : Top Margin Spacing Change");                     // アンドウバッファに登録
                tTarget.topMarginSpacing = tTopMarginSpacing;
                EditorUtility.SetDirty(target);
            }

            float tBottomMarginSpacing = EditorGUILayout.FloatField("Bottom Margin Spacing", tTarget.bottomMarginSpacing);

            if (tBottomMarginSpacing != tTarget.bottomMarginSpacing)
            {
                Undo.RecordObject(tTarget, "RichText : Bottom Margin Spacing Change");                          // アンドウバッファに登録
                tTarget.bottomMarginSpacing = tBottomMarginSpacing;
                EditorUtility.SetDirty(target);
            }
        }
Ejemplo n.º 3
0
        //--------------------------------------------------

        /// <summary>
        /// 各派生クラスでの初期化処理を行う(メニューまたは AddView から生成される場合のみ実行れる)
        /// </summary>
        /// <param name="tOption"></param>
        override protected void OnBuild(string tOption = "")
        {
            RichText tRichText = _richText;

            if (tRichText == null)
            {
                tRichText = gameObject.AddComponent <RichText>();
            }
            if (tRichText == null)
            {
                // 異常
                return;
            }

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

            Color tDefaultTextColor = Color.white;

            Font tDefaultFont     = null;
            int  tDefaultFontSize = 0;

#if UNITY_EDITOR
            if (Application.isPlaying == false)
            {
                // メニューから操作した場合のみ自動設定を行う
                DefaultSettings tDS = Resources.Load <DefaultSettings>("uGUIHelper/DefaultSettings");
                if (tDS != null)
                {
                    tDefaultTextColor = tDS.textColor;

                    tDefaultFont     = tDS.font;
                    tDefaultFontSize = tDS.fontSize;
                }
            }
#endif

            tRichText.color = tDefaultTextColor;

            if (tDefaultFont == null)
            {
                tRichText.font = Resources.GetBuiltinResource(typeof(Font), "Arial.ttf") as Font;
            }
            else
            {
                tRichText.font = tDefaultFont;
            }

            if (tDefaultFontSize <= 0)
            {
                tRichText.fontSize = 32;
            }
            else
            {
                tRichText.fontSize = tDefaultFontSize;
            }

            tRichText.alignment = TextAnchor.MiddleLeft;

            tRichText.horizontalOverflow = HorizontalWrapMode.Overflow;
            tRichText.verticalOverflow   = VerticalWrapMode.Overflow;

            ResetRectTransform();

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

            if (isCanvasOverlay == true)
            {
                tRichText.material = Resources.Load <Material>("uGUIHelper/Shaders/UI-Overlay-Default");
            }
        }