示例#1
0
        public override void DrawCommandGUI()
        {
            serializedObject.Update();
            ControlCG t = target as ControlCG;

            EditorGUILayout.PropertyField(atlasCGProp);


            bool showDSChild = false;

            if (t.AtlasCG != null &&
                t.GetCGInAtlas() != null &&
                t.GetCGInAtlas().Count > 0)
            {
                showDSChild = true;
            }

            if (showDSChild)
            {
                CommandEditor.ObjectField <SpriteDicing.DicedSprite>(spriteCGProp,
                                                                     new GUIContent("CG Child Name", "CG in the Atlas files name"),
                                                                     new GUIContent("<None>"),
                                                                     t.GetCGInAtlas());
            }

            EditorGUILayout.PropertyField(spriteCGProp);

            EditorGUILayout.PropertyField(sprtieColorProp);
            EditorGUILayout.PropertyField(displayProp);
            EditorGUILayout.PropertyField(durationProp);
            EditorGUILayout.PropertyField(FadeEaseTypeProp);
            EditorGUILayout.PropertyField(waitUntilFinishedProp);

            serializedObject.ApplyModifiedProperties();
        }
示例#2
0
        public override void DrawCommandGUI()
        {
            serializedObject.Update();

            ControlStage t = target as ControlStage;

            // Format Enum names
            string[] displayLabels = StringFormatter.FormatEnumNames(t.Display, "<None>");
            displayProp.enumValueIndex = EditorGUILayout.Popup("Display", (int)displayProp.enumValueIndex, displayLabels);

            string replaceLabel = "Portrait Stage";

            if (t.Display == StageDisplayType.Swap)
            {
                CommandEditor.ObjectField <Stage>(replacedStageProp,
                                                  new GUIContent("Replace", "Character to swap with"),
                                                  new GUIContent("<Default>"),
                                                  Stage.activeStages);
                replaceLabel = "With";
            }

            if (Stage.activeStages.Count > 0)
            {
                CommandEditor.ObjectField <Stage>(stageProp,
                                                  new GUIContent(replaceLabel, "Stage to display the character portraits on"),
                                                  new GUIContent("<Default>"),
                                                  Stage.activeStages);
            }

            bool  showOptionalFields = true;
            Stage s = t._Stage;

            // Only show optional portrait fields once required fields have been filled...
            if (t._Stage != null)            // Character is selected
            {
                if (t._Stage == null)        // If no default specified, try to get any portrait stage in the scene
                {
                    s = GameObject.FindObjectOfType <Stage>();
                }
                if (s == null)
                {
                    EditorGUILayout.HelpBox("No portrait stage has been set.", MessageType.Error);
                    showOptionalFields = false;
                }
            }
            if (t.Display != StageDisplayType.None && showOptionalFields)
            {
                EditorGUILayout.PropertyField(useDefaultSettingsProp);
                if (!t.UseDefaultSettings)
                {
                    EditorGUILayout.PropertyField(fadeDurationProp);
                }
                EditorGUILayout.PropertyField(waitUntilFinishedProp);
            }
            serializedObject.ApplyModifiedProperties();
        }
示例#3
0
        public override void DrawCommandGUI()
        {
            serializedObject.Update();

            bool showPortraits = false;

            CommandEditor.ObjectField <Character>(characterProp,
                                                  new GUIContent("Character", "Character that is speaking"),
                                                  new GUIContent("<None>"),
                                                  Character.ActiveCharacters);

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel(" ");
            characterProp.objectReferenceValue = (Character)EditorGUILayout.ObjectField(characterProp.objectReferenceValue, typeof(Character), true);
            EditorGUILayout.EndHorizontal();

            Say t = target as Say;

            // Only show portrait selection if...
            if (t._Character != null &&              // Character is selected
                t._Character.Portraits != null &&    // Character has a portraits field
                t._Character.Portraits.Count > 0)    // Selected Character has at least 1 portrait
            {
                showPortraits = true;
            }

            if (showPortraits)
            {
                CommandEditor.ObjectField <Sprite>(portraitProp,
                                                   new GUIContent("Portrait", "Portrait representing speaking character"),
                                                   new GUIContent("<None>"),
                                                   t._Character.Portraits);
            }
            else
            {
                if (!t.ExtendPrevious)
                {
                    t.Portrait = null;
                }
            }

            EditorGUILayout.PropertyField(storyTextProp);

            EditorGUILayout.PropertyField(descriptionProp);
            EditorGUILayout.PropertyField(animationNameProp);

            EditorGUILayout.BeginHorizontal();

            EditorGUILayout.PropertyField(extendPreviousProp);

            GUILayout.FlexibleSpace();

            if (GUILayout.Button(new GUIContent("Tag Help", "View available tags"), new GUIStyle(EditorStyles.miniButton)))
            {
                showTagHelp = !showTagHelp;
            }
            EditorGUILayout.EndHorizontal();

            if (showTagHelp)
            {
                DrawTagHelpLabel();
            }

            EditorGUILayout.Separator();

            EditorGUILayout.PropertyField(voiceOverClipProp,
                                          new GUIContent("Voice Over Clip", "Voice over audio to play when the text is displayed"));

            EditorGUILayout.PropertyField(showAlwaysProp);

            if (showAlwaysProp.boolValue == false)
            {
                EditorGUILayout.PropertyField(showCountProp);
            }

            GUIStyle centeredLabel = new GUIStyle(EditorStyles.label);

            centeredLabel.alignment = TextAnchor.MiddleCenter;
            GUIStyle leftButton = new GUIStyle(EditorStyles.miniButtonLeft);

            leftButton.fontSize = 10;
            leftButton.font     = EditorStyles.toolbarButton.font;
            GUIStyle rightButton = new GUIStyle(EditorStyles.miniButtonRight);

            rightButton.fontSize = 10;
            rightButton.font     = EditorStyles.toolbarButton.font;

            EditorGUILayout.PropertyField(fadeWhenDoneProp);
            EditorGUILayout.PropertyField(waitForClickProp);
            EditorGUILayout.PropertyField(stopVoiceoverProp);
            EditorGUILayout.PropertyField(setSayDialogProp);
            EditorGUILayout.PropertyField(waitForVOProp);

            if (showPortraits && t.Portrait != null)
            {
                Texture2D characterTexture = t.Portrait.texture;
                float     aspect           = (float)characterTexture.width / (float)characterTexture.height;
                Rect      previewRect      = GUILayoutUtility.GetAspectRect(aspect, GUILayout.Width(100), GUILayout.ExpandWidth(true));
                if (characterTexture != null)
                {
                    GUI.DrawTexture(previewRect, characterTexture, ScaleMode.ScaleToFit, true, aspect);
                }
            }

            serializedObject.ApplyModifiedProperties();
        }
示例#4
0
        public override void DrawCommandGUI()
        {
            serializedObject.Update();

            Portrait t = target as Portrait;

            if (Stage.ActiveStages.Count > 1)
            {
                CommandEditor.ObjectField <Stage>(stageProp,
                                                  new GUIContent("Portrait Stage", "Stage to display the character portraits on"),
                                                  new GUIContent("<Default>"),
                                                  Stage.ActiveStages);
            }
            else
            {
                t._Stage = null;
            }
            // Format Enum names
            string[] displayLabels = StringFormatter.FormatEnumNames(t.Display, "<None>");
            displayProp.enumValueIndex = EditorGUILayout.Popup("Display", (int)displayProp.enumValueIndex, displayLabels);

            string characterLabel = "Character";

            if (t.Display == DisplayType.Replace)
            {
                CommandEditor.ObjectField <Character>(replacedCharacterProp,
                                                      new GUIContent("Replace", "Character to replace"),
                                                      new GUIContent("<None>"),
                                                      Character.ActiveCharacters);
                characterLabel = "With";
            }

            CommandEditor.ObjectField <Character>(characterProp,
                                                  new GUIContent(characterLabel, "Character to display"),
                                                  new GUIContent("<None>"),
                                                  Character.ActiveCharacters);

            bool  showOptionalFields = true;
            Stage s = t._Stage;

            // Only show optional portrait fields once required fields have been filled...
            if (t._Character != null)                  // Character is selected
            {
                if (t._Character.Portraits == null ||  // Character has a portraits field
                    t._Character.Portraits.Count <= 0) // Character has at least one portrait
                {
                    EditorGUILayout.HelpBox("This character has no portraits. Please add portraits to the character's prefab before using this command.", MessageType.Error);
                    showOptionalFields = false;
                }
                if (t._Stage == null)            // If default portrait stage selected
                {
                    if (t._Stage == null)        // If no default specified, try to get any portrait stage in the scene
                    {
                        s = GameObject.FindObjectOfType <Stage>();
                    }
                }
                if (s == null)
                {
                    EditorGUILayout.HelpBox("No portrait stage has been set.", MessageType.Error);
                    showOptionalFields = false;
                }
            }
            if (t.Display != DisplayType.None && t._Character != null && showOptionalFields)
            {
                if (t.Display != DisplayType.Hide && t.Display != DisplayType.MoveToFront)
                {
                    // PORTRAIT
                    CommandEditor.ObjectField <Sprite>(portraitProp,
                                                       new GUIContent("Portrait", "Portrait representing character"),
                                                       new GUIContent("<Previous>"),
                                                       t._Character.Portraits);
                    if (t._Character.PortraitsFace != FacingDirection.None)
                    {
                        // FACING
                        // Display the values of the facing enum as <-- and --> arrows to avoid confusion with position field
                        string[] facingArrows = new string[]
                        {
                            "<Previous>",
                            "<--",
                            "-->",
                        };
                        facingProp.enumValueIndex = EditorGUILayout.Popup("Facing", (int)facingProp.enumValueIndex, facingArrows);
                    }
                    else
                    {
                        t.Facing = FacingDirection.None;
                    }
                }
                else
                {
                    t._Portrait = null;
                    t.Facing    = FacingDirection.None;
                }
                string toPositionPrefix = "";
                if (t.Move)
                {
                    // MOVE
                    EditorGUILayout.PropertyField(moveProp);
                }
                if (t.Move)
                {
                    if (t.Display != DisplayType.Hide)
                    {
                        // START FROM OFFSET
                        EditorGUILayout.PropertyField(shiftIntoPlaceProp);
                    }
                }
                if (t.Move)
                {
                    if (t.Display != DisplayType.Hide)
                    {
                        if (t.ShiftIntoPlace)
                        {
                            t.FromPosition = null;
                            // OFFSET
                            // Format Enum names
                            string[] offsetLabels = StringFormatter.FormatEnumNames(t.Offset, "<Previous>");
                            offsetProp.enumValueIndex = EditorGUILayout.Popup("From Offset", (int)offsetProp.enumValueIndex, offsetLabels);
                        }
                        else
                        {
                            t.Offset = PositionOffset.None;
                            // FROM POSITION
                            CommandEditor.ObjectField <RectTransform>(fromPositionProp,
                                                                      new GUIContent("From Position", "Move the portrait to this position"),
                                                                      new GUIContent("<Previous>"),
                                                                      s.Positions);
                        }
                    }
                    toPositionPrefix = "To ";
                }
                else
                {
                    t.ShiftIntoPlace = false;
                    t.FromPosition   = null;
                    toPositionPrefix = "At ";
                }
                if (t.Display == DisplayType.Show || (t.Display == DisplayType.Hide && t.Move))
                {
                    // TO POSITION
                    CommandEditor.ObjectField <RectTransform>(toPositionProp,
                                                              new GUIContent(toPositionPrefix + "Position", "Move the portrait to this position"),
                                                              new GUIContent("<Previous>"),
                                                              s.Positions);
                }
                else
                {
                    t.ToPosition = null;
                }
                if (!t.Move && t.Display != DisplayType.MoveToFront)
                {
                    // MOVE
                    EditorGUILayout.PropertyField(moveProp);
                }
                if (t.Display != DisplayType.MoveToFront)
                {
                    EditorGUILayout.Separator();

                    // USE DEFAULT SETTINGS
                    EditorGUILayout.PropertyField(useDefaultSettingsProp);
                    if (!t.UseDefaultSettings)
                    {
                        // FADE DURATION
                        EditorGUILayout.PropertyField(fadeDurationProp);
                        if (t.Move)
                        {
                            // MOVE SPEED
                            EditorGUILayout.PropertyField(moveDurationProp);
                        }
                        if (t.ShiftIntoPlace)
                        {
                            // SHIFT OFFSET
                            EditorGUILayout.PropertyField(shiftOffsetProp);
                        }
                    }
                }
                else
                {
                    t.Move = false;
                    t.UseDefaultSettings = true;
                    EditorGUILayout.Separator();
                }

                EditorGUILayout.PropertyField(waitUntilFinishedProp);


                if (t._Portrait != null && t.Display != DisplayType.Hide)
                {
                    Texture2D characterTexture = t._Portrait.texture;

                    float aspect      = (float)characterTexture.width / (float)characterTexture.height;
                    Rect  previewRect = GUILayoutUtility.GetAspectRect(aspect, GUILayout.Width(100), GUILayout.ExpandWidth(true));

                    if (characterTexture != null)
                    {
                        GUI.DrawTexture(previewRect, characterTexture, ScaleMode.ScaleToFit, true, aspect);
                    }
                }

                if (t.Display != DisplayType.Hide)
                {
                    string portraitName = "<Previous>";
                    if (t._Portrait != null)
                    {
                        portraitName = t._Portrait.name;
                    }
                    string   portraitSummary = " " + portraitName;
                    int      toolbarInt      = 1;
                    string[] toolbarStrings  = { "<--", portraitSummary, "-->" };
                    toolbarInt = GUILayout.Toolbar(toolbarInt, toolbarStrings, GUILayout.MinHeight(20));
                    int portraitIndex = -1;

                    if (toolbarInt != 1)
                    {
                        for (int i = 0; i < t._Character.Portraits.Count; i++)
                        {
                            if (portraitName == t._Character.Portraits[i].name)
                            {
                                portraitIndex = i;
                            }
                        }
                    }

                    if (toolbarInt == 0)
                    {
                        if (portraitIndex > 0)
                        {
                            t._Portrait = t._Character.Portraits[--portraitIndex];
                        }
                        else
                        {
                            t._Portrait = null;
                        }
                    }
                    if (toolbarInt == 2)
                    {
                        if (portraitIndex < t._Character.Portraits.Count - 1)
                        {
                            t._Portrait = t._Character.Portraits[++portraitIndex];
                        }
                    }
                }
            }
            serializedObject.ApplyModifiedProperties();
        }
示例#5
0
        // Update is called once per frame
        public override void DrawCommandGUI()
        {
            serializedObject.Update();

            BillboardPrefab t = target as BillboardPrefab;

            if (shouldUpdatePrefab == true)
            {
                shouldUpdatePrefab = false;

                if (t._TargetPrefab != null)
                {
                    listEmoji = t._TargetPrefab.GetEmojiListString().ToArray();
                    listBody  = t._TargetPrefab.GetBodyListString().ToArray();
                    listEquip = t._TargetPrefab.GetEquipListString().ToArray();
                }
                else
                {
                    listEmoji = new string[] {}
                };
            }

            EditorGUILayout.PropertyField(displayProp);
            if (t._Display != DisplayType.None)
            {
                if (t._Display != DisplayType.MoveToFront)
                {
                    if (t._Display != DisplayType.Hide)
                    {
                        EditorGUI.BeginChangeCheck();
                        EditorGUILayout.PropertyField(targetPrefabProp, new GUIContent("角色立繪Prefab"));

                        if (AdvKeyContent.GetCurrentInstance().GroupBillboardPrefab != null)
                        {
                            CommandEditor.ObjectField <UIBillboardController>(targetPrefabProp,
                                                                              new GUIContent("In folder (Prefabs/ADV)", "Dynamic Emoji Prefab (UIBillboardController)"),
                                                                              new GUIContent("<None>"),
                                                                              AdvKeyContent.GetCurrentInstance().GroupBillboardPrefab);
                        }

                        if (EditorGUI.EndChangeCheck())
                        {
                            shouldUpdatePrefab = true;
                        }

                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PropertyField(useEmojiProp, new GUIContent("使用表情"));
                        int emojiIndex = EditorGUILayout.Popup(emojiId, listEmoji, EditorStyles.popup);
                        EditorGUILayout.EndHorizontal();

                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PropertyField(useBodyProp, new GUIContent("使用衣服"));
                        int bodyIndex = EditorGUILayout.Popup(bodyId, listBody, EditorStyles.popup);
                        EditorGUILayout.EndHorizontal();

                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PropertyField(useEquipsProp, new GUIContent("使用裝備(我前面有箭頭)"), true);
                        int equipIndex = EditorGUILayout.Popup(equipId, listEquip, EditorStyles.popup);
                        EditorGUILayout.EndHorizontal();


                        if (emojiIndex != emojiId)
                        {
                            useEmojiProp.stringValue = listEmoji[emojiIndex];
                        }
                        if (bodyIndex != bodyId)
                        {
                            useBodyProp.stringValue = listBody[bodyIndex];
                        }
                        if (equipIndex != equipId)
                        {
                            t._UseEquips.Add(listEquip[equipIndex]);
                            EditorUtility.SetDirty(t);
                        }

                        EditorGUILayout.PropertyField(flipFaceProp, new GUIContent("水平翻轉 ?"));
                        EditorGUILayout.PropertyField(spriteDistanceProp, new GUIContent("立繪所在距離"));
                    }
                    if (t._Display == DisplayType.Hide)
                    {
                        EditorGUILayout.PropertyField(hideWhichProp, new GUIContent("隱藏哪個位置"));
                    }

                    if (t._Display == DisplayType.Show || t._Display == DisplayType.Replace || (t._Move && t._Display == DisplayType.Hide))
                    {
                        EditorGUILayout.PropertyField(toPositionProp, new GUIContent("目標位置"));
                        EditorGUILayout.PropertyField(positionShiftProp, new GUIContent("目標位置加上偏移"));
                        EditorGUILayout.PropertyField(positionShiftValueProp, new GUIContent("偏移倍數"));
                    }
                    EditorGUILayout.LabelField("-- 移動設定 --", EditorStyles.boldLabel);
                    EditorGUILayout.PropertyField(moveProp, new GUIContent("移動動畫 ?"));

                    if (t._Move)
                    {
                        if (!t._ShiftIntoPlace)
                        {
                            EditorGUILayout.PropertyField(fromPositionProp, new GUIContent("從哪個相對位置滑入"));
                        }
                    }


                    EditorGUILayout.PropertyField(useDefaultSettingsProp, new GUIContent("使用預設數值 ?"));

                    if (!t._UseDefaultSettings)
                    {
                        if (t._Move)
                        {
                            if (t._Display != DisplayType.Hide)
                            {
                                EditorGUILayout.PropertyField(shiftIntoPlaceProp, new GUIContent("從目標位置附近滑入?"));
                                if (t._ShiftIntoPlace)
                                {
                                    EditorGUILayout.PropertyField(shiftOffsetProp, new GUIContent("從哪邊滑入(偏移量)"));
                                }
                            }
                        }
                        EditorGUILayout.PropertyField(fadeDurationProp, new GUIContent("淡出 / 淡入時間"));
                        if (t._Move)
                        {
                            EditorGUILayout.PropertyField(moveDurationProp, new GUIContent("滑動時間"));
                        }
                    }

                    EditorGUILayout.PropertyField(waitUntilFinishedProp);
                }
                else
                {
                    EditorGUILayout.PropertyField(toPositionProp, new GUIContent("哪個位置"));
                }
            }

            //EditorGUILayout.PropertyField(serializedObject.FindProperty("myVariable"), new GUIContent("aDifferentLabel"));

            serializedObject.ApplyModifiedProperties();
        }
    }