void OnGUI()
        {
            EditorGUILayout.LabelField("Animation Name", fileName);

            EditorGUILayout.LabelField("Properties");
            using (var scroll = new EditorGUILayout.ScrollViewScope(scrollPos, GUI.skin.box))
            {
                scrollPos = scroll.scrollPosition;
                for (int i = 0; i < animParamList.Count; i++)
                {
                    using (new EditorGUILayout.HorizontalScope())
                    {
                        animParamList[i].IsSelect = EditorGUILayout.ToggleLeft(animParamList[i].BlendShapeName, animParamList[i].IsSelect);
                        GUILayout.Label(animParamList[i].Value + "");
                    }
                }
            }

            using (new EditorGUILayout.HorizontalScope())
            {
                GatoGUILayout.Button(
                    "Canncel",
                    () => {
                    this.Close();
                });

                GatoGUILayout.Button(
                    "Load Properties",
                    () => {
                    LoadAnimationProperties();
                    this.Close();
                });
            }
        }
        protected virtual void DrawCreatedAnimationSettingsGUI()
        {
            animName = EditorGUILayout.TextField(LocalizeText.instance.langPair.animClipFileNameLabel, animName);

            using (new EditorGUILayout.HorizontalScope())
            {
                EditorGUILayout.LabelField(LocalizeText.instance.langPair.animClipSaveFolderLabel, originalAvatar.AnimSavedFolderPath);

                GatoGUILayout.Button(
                    LocalizeText.instance.langPair.selectFolder,
                    () => {
                    originalAvatar.AnimSavedFolderPath = EditorUtility.OpenFolderPanel(LocalizeText.instance.langPair.selectFolderDialogMessageText, originalAvatar.AnimSavedFolderPath, string.Empty);
                    originalAvatar.AnimSavedFolderPath = $"{FileUtil.GetProjectRelativePath(originalAvatar.AnimSavedFolderPath)}{Path.DirectorySeparatorChar}";
                    if (originalAvatar.AnimSavedFolderPath == $"{Path.DirectorySeparatorChar}")
                    {
                        originalAvatar.AnimSavedFolderPath = $"Assets{Path.DirectorySeparatorChar}";
                    }
                    parentWindow.animationsGUI.UpdateSaveFolderPath(originalAvatar.AnimSavedFolderPath);
                },
                    true,
                    GUILayout.Width(100));
            }

            EditorGUILayout.Space();
        }
        protected override void DrawCreateButtonGUI()
        {
            GatoGUILayout.Button(
                LocalizeText.instance.langPair.createAnimFileButtonText,
                () => {
                var animController = originalAvatar.StandingAnimController;

                var createdAnimClip = FaceEmotion.CreateBlendShapeAnimationClip(animName, originalAvatar.AnimSavedFolderPath, editAvatar);
                if (selectedHandAnim != HandPose.HandPoseType.NoSelection)
                {
                    HandPose.AddHandPoseAnimationKeysFromOriginClip(createdAnimClip, handPoseAnim);
                    animController[AnimationsGUI.HANDANIMS[(int)selectedHandAnim - 1]] = createdAnimClip;
                    EditorUtility.SetDirty(animController);

                    FaceEmotion.ResetToDefaultFaceEmotion(editAvatar);
                }

                originalAvatar.StandingAnimController = animController;
                editAvatar.StandingAnimController     = animController;

                animationsGUI.ResetPathMissing(AnimationsGUI.HANDANIMS[(int)selectedHandAnim - 1]);
            },
                selectedHandAnim != HandPose.HandPoseType.NoSelection &&
                handPoseAnim != null);
        }
        protected void DrawFunctionButtons()
        {
            using (new EditorGUILayout.HorizontalScope())
            {
                GUILayout.FlexibleSpace();

                GatoGUILayout.Button(
                    LocalizeText.instance.langPair.loadAnimationButtonText,
                    () => {
                    FaceEmotion.LoadAnimationProperties(this, parentWindow);
                },
                    editAvatar.Descriptor != null);

                GatoGUILayout.Button(
                    LocalizeText.instance.langPair.setToDefaultButtonText,
                    () => {
                    if (EditorUtility.DisplayDialog(
                            LocalizeText.instance.langPair.setToDefaultDialogTitleText,
                            LocalizeText.instance.langPair.setToDefaultDialogMessageText,
                            LocalizeText.instance.langPair.ok, LocalizeText.instance.langPair.cancel))
                    {
                        FaceEmotion.SetToDefaultFaceEmotion(editAvatar, originalAvatar);
                    }
                },
                    editAvatar.Descriptor != null);

                GatoGUILayout.Button(
                    LocalizeText.instance.langPair.resetToDefaultButtonText,
                    () => {
                    FaceEmotion.ResetToDefaultFaceEmotion(editAvatar);
                    ChangeSaveAnimationState();
                },
                    editAvatar.Descriptor != null);
            }
        }
        private void OnGUI()
        {
            // TODO: ComputeShaderがAndroidBuildだと使えないから警告文を出す
            if (EditorUserBuildSettings.activeBuildTarget == BuildTarget.Android)
            {
                DrawNotSupportBuildTarget();
                return;
            }

            using (new EditorGUILayout.HorizontalScope())
            {
                GatoGUILayout.ObjectField(
                    localizedText.Data.rendererLabelText,
                    model.renderer,
                    renderer => model.OnChangeRenderer(canvasView, renderer)
                    );

                EditorGUILayout.Space();

                GatoGUILayout.EnumPopup(
                    localizedText.SelectedLanguage,
                    language => OnLanguagePopupChanged(language),
                    GUILayout.Width(50)
                    );
            }

            GUILayout.Space(20);

            using (new EditorGUILayout.HorizontalScope())
            {
                using (new EditorGUILayout.VerticalScope())
                {
                    canvasView.Render(model.HasTexture(), CANVAS_SIZE_RAITO);

                    using (new EditorGUILayout.HorizontalScope())
                    {
                        GatoGUILayout.Slider(
                            localizedText.Data.scaleLabelText,
                            canvasView.ZoomScale,
                            0.1f,
                            1.0f,
                            scale => canvasView.ZoomScale = scale
                            );

                        GatoGUILayout.Button(
                            localizedText.Data.resetButtonText,
                            () => canvasView.ResetScrollOffsetAndZoomScale()
                            );
                    }
                }

                toolView.Render(model, localizedText, canvasView, 1 - CANVAS_SIZE_RAITO);
            }

            if (InputKeyDown(KeyCode.Z))
            {
                canvasView.UndoPreviewTexture();
            }
        }
 protected AnimationClip EdittableAnimationField(string label, AnimationClip clip, bool hasError, bool edittable, Action OnEdit)
 {
     return(ValidatableAnimationField(label, clip, hasError, () =>
     {
         GatoGUILayout.Button(
             LocalizeText.instance.langPair.edit,
             () => OnEdit(),
             edittable,
             GUILayout.Width(50));
     }));
 }
示例#7
0
        private void SettingGUI()
        {
            EditorGUILayout.HelpBox(LocalizeText.instance.langPair.settingPageMessageText, MessageType.Info);

            avatarMonitorGUI.DrawSettingsGUI();

            EditorGUILayout.Space();

            faceEmotionGUI.DrawSettingsGUI();

            EditorGUILayout.Space();

            EditorGUILayout.LabelField(LocalizeText.instance.langPair.otherLabel, EditorStyles.boldLabel);

            layoutType = (LayoutType)EditorGUILayout.EnumPopup(LocalizeText.instance.langPair.layoutTypeLabel, layoutType);

            var languagePacks = LocalizeText.instance.langs;
            var index         = Array.IndexOf(languagePacks, language);

            using (var check = new EditorGUI.ChangeCheckScope())
            {
                index = EditorGUILayout.Popup(LocalizeText.instance.langPair.languageLabel, index, languagePacks);
                if (check.changed)
                {
                    language = languagePacks[index];
                    // TODO: 失敗している場合はBaseが入っているので表示もそうしないといけない
                    _ = LocalizeText.instance.LoadLanguage(language);
                    Repaint();
                }
            }

            EditorGUILayout.Space();

            GatoGUILayout.Button(
                LocalizeText.instance.langPair.saveSettingButtonText,
                () => {
                EditorSetting.instance.SaveSettingDataToScriptableObject(
                    layoutType, language,
                    avatarMonitorGUI, faceEmotionGUI);
            });

            GatoGUILayout.Button(
                LocalizeText.instance.langPair.changeDefaultSettingButtonText,
                () => {
                EditorSetting.instance.DeleteMySettingData();
                (layoutType, language) = EditorSetting.instance.LoadSettingDataFromScriptableObject(
                    editorFolderPath, language,
                    avatarMonitorGUI, faceEmotionGUI);
            });
        }
        protected AnimationClip ValidatableAnimationField(string label, AnimationClip clip, bool hasError, Action contents = null)
        {
            AnimationClip retClip;

            using (new EditorGUILayout.HorizontalScope(GUILayout.Width(350)))
            {
                GUILayout.Label(label, hasError ? errorStyle : normalStyle, GUILayout.Width(100));

                retClip = GatoGUILayout.ObjectField(
                    string.Empty,
                    clip,
                    true,
                    GUILayout.Width(200));

                contents?.Invoke();
            }
            return(retClip);
        }
        protected override void DrawCreatedAnimationSettingsGUI()
        {
            base.DrawCreatedAnimationSettingsGUI();

            using (var check = new EditorGUI.ChangeCheckScope())
            {
                selectedHandAnim = (HandPose.HandPoseType)Enum.ToObject(typeof(HandPose.HandPoseType), EditorGUILayout.Popup(
                                                                            LocalizeText.instance.langPair.animationOverrideLabel,
                                                                            (int)selectedHandAnim,
                                                                            Enum.GetNames(typeof(HandPose.HandPoseType)).Select((x, index) => index + ":" + x).ToArray()));

                if (check.changed)
                {
                    ChangeSelectionHandAnimation();
                }
            }

            using (new EditorGUI.DisabledGroupScope(selectedHandAnim == HandPose.HandPoseType.NoSelection))
            {
                handPoseAnim = GatoGUILayout.ObjectField(
                    LocalizeText.instance.langPair.handPoseAnimClipLabel,
                    handPoseAnim);
            }
        }
        public void DrawSettingsGUI()
        {
            EditorGUILayout.LabelField("FaceEmotion Creator", EditorStyles.boldLabel);

            selectedSortType = (SortType)EditorGUILayout.EnumPopup(LocalizeText.instance.langPair.sortTypeLabel, selectedSortType);

            isOpeningBlendShapeExclusionList = EditorGUILayout.Foldout(isOpeningBlendShapeExclusionList, LocalizeText.instance.langPair.blendShapeExclusionsLabel);
            if (isOpeningBlendShapeExclusionList)
            {
                using (new EditorGUI.IndentLevelScope())
                {
                    for (int i = 0; i < blendshapeExclusions.Count; i++)
                    {
                        using (new GUILayout.HorizontalScope())
                        {
                            blendshapeExclusions[i] = EditorGUILayout.TextField(blendshapeExclusions[i]);
                            if (GUILayout.Button(LocalizeText.instance.langPair.remove))
                            {
                                blendshapeExclusions.RemoveAt(i);
                            }
                        }
                    }
                }

                using (new GUILayout.HorizontalScope())
                {
                    GatoGUILayout.Button(
                        LocalizeText.instance.langPair.add,
                        () => {
                        blendshapeExclusions.Add(string.Empty);
                    });
                }
            }

            usePreviousAnimationOnHandAnimation = EditorGUILayout.ToggleLeft(LocalizeText.instance.langPair.usePreviousAnimationOnHandAnimationLabel, usePreviousAnimationOnHandAnimation);
        }
        protected override void DrawCreateButtonGUI()
        {
            GatoGUILayout.Button(
                LocalizeText.instance.langPair.createAnimFileButtonText,
                () =>
            {
                var controller      = originalAvatar.FxController;
                var createdAnimClip = FaceEmotion.CreateBlendShapeAnimationClip(
                    animName,
                    originalAvatar.AnimSavedFolderPath,
                    editAvatar,
                    true);

                // Stateがない場合は作成のみ
                if (states.Any())
                {
                    states[selectedStateIndex].state.motion = createdAnimClip;
                    EditorUtility.SetDirty(controller);

                    // 可能であればもう一方の手も同じAnimationClipを設定する
                    if (setLeftAndRight)
                    {
                        var layerName          = editAvatar.FxController.layers[editAvatar.TargetFxLayerIndex].name;
                        string targetLayerName = string.Empty;
                        if (layerName == "Left Hand")
                        {
                            targetLayerName = "Right Hand";
                        }
                        else if (layerName == "Right Hand")
                        {
                            targetLayerName = "Left Hand";
                        }

                        if (!string.IsNullOrEmpty(targetLayerName))
                        {
                            var targetLayer = editAvatar.FxController.layers
                                              .Where(l => l.name == targetLayerName)
                                              .SingleOrDefault();

                            if (targetLayer != null)
                            {
                                var targetStateName = states[selectedStateIndex].state.name;
                                var targetState     = targetLayer.stateMachine.states
                                                      .Where(s => s.state.name == targetStateName)
                                                      .SingleOrDefault();

                                if (targetState.state != null)
                                {
                                    targetState.state.motion = createdAnimClip;
                                    EditorUtility.SetDirty(controller);
                                }
                            }
                        }
                    }
                }

                FaceEmotion.ResetToDefaultFaceEmotion(editAvatar);
                originalAvatar.FxController = controller;
                editAvatar.FxController     = controller;
            },
                originalAvatar.FxController != null);
        }
        protected void BlendShapeListGUI()
        {
            // BlendShapeのリスト
            using (var scrollView = new EditorGUILayout.ScrollViewScope(scrollPos))
            {
                scrollPos = scrollView.scrollPosition;
                foreach (IFaceEmotionSkinnedMesh skinnedMesh in editAvatar.SkinnedMeshList)
                {
                    if (skinnedMesh.BlendShapeCount <= 0)
                    {
                        continue;
                    }

                    skinnedMesh.IsOpenBlendShapes = EditorGUILayout.Foldout(skinnedMesh.IsOpenBlendShapes, skinnedMesh.Obj.name);
                    if (skinnedMesh.IsOpenBlendShapes)
                    {
                        using (new EditorGUI.IndentLevelScope())
                        {
                            using (new GUILayout.HorizontalScope())
                            {
                                using (var check = new EditorGUI.ChangeCheckScope())
                                {
                                    skinnedMesh.IsContainsAll = EditorGUILayout.ToggleLeft(string.Empty, skinnedMesh.IsContainsAll, GUILayout.Width(45));
                                    if (check.changed)
                                    {
                                        FaceEmotion.SetContainsAll(skinnedMesh.IsContainsAll, skinnedMesh.Blendshapes);
                                    }
                                }
                                EditorGUILayout.LabelField(LocalizeText.instance.langPair.toggleAllLabel, GUILayout.Height(20));
                            }

                            foreach (var blendshape in skinnedMesh.Blendshapes)
                            {
                                if (!blendshape.IsExclusion)
                                {
                                    using (new EditorGUILayout.HorizontalScope())
                                    {
                                        blendshape.IsContains = EditorGUILayout.ToggleLeft(string.Empty, blendshape.IsContains, GUILayout.Width(45));

                                        EditorGUILayout.SelectableLabel(blendshape.Name, GUILayout.Height(20));
                                        using (var check = new EditorGUI.ChangeCheckScope())
                                        {
                                            var value = skinnedMesh.Renderer.GetBlendShapeWeight(blendshape.Id);
                                            value = EditorGUILayout.Slider(value, 0, 100);
                                            if (check.changed)
                                            {
                                                skinnedMesh.Renderer.SetBlendShapeWeight(blendshape.Id, value);
                                            }
                                        }

                                        GatoGUILayout.Button(
                                            LocalizeText.instance.langPair.minButtonText,
                                            () => {
                                            FaceEmotion.SetBlendShapeMinValue(skinnedMesh.Renderer, blendshape.Id);
                                        },
                                            true,
                                            GUILayout.MaxWidth(50));

                                        GatoGUILayout.Button(
                                            LocalizeText.instance.langPair.maxButtonText,
                                            () => {
                                            FaceEmotion.SetBlendShapeMaxValue(skinnedMesh.Renderer, blendshape.Id);
                                        },
                                            true,
                                            GUILayout.MaxWidth(50));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
示例#13
0
        private void OnGUI()
        {
            if (LocalizeText.instance.langPair is null)
            {
                DrawNowLoading();
                return;
            }

            using (new EditorGUILayout.HorizontalScope(GUILayout.Height(EditorGUIUtility.singleLineHeight * 1.5f)))
            {
                GUILayout.FlexibleSpace();

                GatoGUILayout.Button(
                    LocalizeText.instance.langPair.reloadAvatarButtonText,
                    () => {
                    OnChangedAvatar();
                },
                    originalAvatar != null);

                EditorGUILayout.Space();

                var toolInfoButtonText = (!isShowingToolInfo) ? LocalizeText.instance.langPair.toolInfoButtonText : LocalizeText.instance.langPair.close;
                var settingButtonText  = (!isShowingSetting) ? LocalizeText.instance.langPair.settingButtonText : LocalizeText.instance.langPair.close;
                GatoGUILayout.Button(
                    toolInfoButtonText,
                    () => {
                    isShowingToolInfo = !isShowingToolInfo;
                    isShowingSetting  = false;
                },
                    true,
                    GUILayout.MinWidth(50));

                GatoGUILayout.Button(
                    settingButtonText,
                    () =>
                {
                    isShowingSetting  = !isShowingSetting;
                    isShowingToolInfo = false;

                    if (!isShowingSetting)
                    {
                        EditorSetting.instance.ApplySettingsToEditorGUI(
                            edittingAvatar,
                            faceEmotionGUI);
                    }
                },
                    true,
                    GUILayout.MinWidth(50));
            }

            if (!isShowingToolInfo && !isShowingSetting)
            {
                using (new EditorGUILayout.VerticalScope())
                {
                    // アバター選択
                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
                        targetAvatarDescriptor = GatoGUILayout.ObjectField(
                            LocalizeText.instance.langPair.avatarLabel,
                            targetAvatarDescriptor);

                        if (check.changed)
                        {
                            // アバター変更時の処理
                            if (targetAvatarDescriptor != null)
                            {
                                OnChangedAvatar();
                            }
                        }
                    }

                    using (new EditorGUI.DisabledGroupScope(edittingAvatar.Descriptor == null))
                    {
                        // LayoutType: Default
                        if (layoutType == LayoutType.Default)
                        {
                            using (new EditorGUILayout.HorizontalScope())
                            {
                                needRepaint = avatarMonitorGUI.DrawGUI(null);
                                if (needRepaint)
                                {
                                    Repaint();
                                }
                                else
                                {
                                    animationsGUI.DrawGUI(layoutOptions[0]);
                                }
                            }

                            DrawToolSwitchTab();

                            selectedToolGUI.DrawGUI(null);
                        }
                        // LayoutType: Half
                        else
                        {
                            using (new EditorGUILayout.HorizontalScope())
                            {
                                needRepaint = avatarMonitorGUI.DrawGUI(null);
                                if (needRepaint)
                                {
                                    Repaint();
                                }

                                using (new EditorGUILayout.VerticalScope())
                                {
                                    DrawToolSwitchTab();

                                    if (CurrentTool == ToolFunc.AvatarInfo)
                                    {
                                        using (new EditorGUILayout.HorizontalScope())
                                        {
                                            if (!needRepaint)
                                            {
                                                animationsGUI.DrawGUI(layoutOptions[1]);
                                            }
                                        }

                                        // アバター情報
                                        avatarInfoGUI.DrawGUI(null);
                                    }
                                    else
                                    {
                                        selectedToolGUI.DrawGUI(null);
                                    }
                                }
                            }
                        }

                        EditorGUILayout.Space();

                        // ポーズ修正
                        GatoGUILayout.Button(
                            LocalizeText.instance.langPair.resetPoseButtonText,
                            () => {
                            HumanoidPose.ResetPose(edittingAvatar.Descriptor.gameObject);
                            HumanoidPose.ResetPose(originalAvatar.Descriptor.gameObject);
                        });

                        // アップロード
                        GatoGUILayout.Button(
                            LocalizeText.instance.langPair.uploadAvatarButtonText,
                            () => {
                            VRCSDKUtility.UploadAvatar(VRCSDKUtility.IsNewSDKUI());
                        });
                    }
                }
            }
            else if (isShowingToolInfo)
            {
                ToolInfoGUI();
            }
            else
            {
                SettingGUI();
            }

            EditorGUILayout.Space();
        }
示例#14
0
        private void ToolInfoGUI()
        {
            EditorGUILayout.LabelField("VRC Avatar Editor", EditorStyles.boldLabel);
            EditorGUILayout.LabelField(LocalizeText.instance.langPair.versionLabel, TOOL_VERSION);

            EditorGUILayout.Space();

            GatoGUILayout.Button(
                LocalizeText.instance.langPair.openOnlineManualButtonText,
                () => {
                Application.OpenURL(MANUAL_URL);
            });

            EditorGUILayout.Space();

            EditorGUILayout.LabelField(LocalizeText.instance.langPair.functionsLabel);
            using (new EditorGUI.IndentLevelScope())
            {
                foreach (var toolFunc in TOOL_FUNCS)
                {
                    EditorGUILayout.LabelField(toolFunc);
                }
            }

            EditorGUILayout.Space();

            EditorGUILayout.LabelField("Created by gatosyocora");
            using (new EditorGUI.IndentLevelScope())
            {
                using (new EditorGUILayout.HorizontalScope())
                {
                    EditorGUILayout.LabelField("Twitter", "@" + TWITTER_ID, GUILayout.Width(300));
                    GatoGUILayout.Button(
                        LocalizeText.instance.langPair.open,
                        () => {
                        Application.OpenURL("https://twitter.com/" + TWITTER_ID);
                    },
                        true,
                        GUILayout.Width(50));

                    GUILayout.FlexibleSpace();
                }
                EditorGUILayout.LabelField("Discord", DISCORD_ID);
                using (new EditorGUILayout.HorizontalScope())
                {
                    EditorGUILayout.LabelField("Booth", BOOTH_URL, GUILayout.Width(300));
                    GatoGUILayout.Button(
                        LocalizeText.instance.langPair.open,
                        () => {
                        Application.OpenURL(BOOTH_ITEM_URL);
                    },
                        true,
                        GUILayout.Width(50));

                    GUILayout.FlexibleSpace();
                }
            }

            EditorGUILayout.Space();

            isShowingReadme = EditorGUILayout.Foldout(isShowingReadme, LocalizeText.instance.langPair.readmeLabel);

            if (isShowingReadme)
            {
                readmeScrollPos = EditorGUILayout.BeginScrollView(readmeScrollPos, GUI.skin.box);
                {
                    using (new EditorGUI.IndentLevelScope())
                    {
                        EditorGUILayout.SelectableLabel(readmeText, GUILayout.Height(500));
                    }
                }
                EditorGUILayout.EndScrollView();
            }


            isShowingLicense = EditorGUILayout.Foldout(isShowingLicense, LocalizeText.instance.langPair.licenseLabel);

            if (isShowingLicense)
            {
                licenseScrollPos = EditorGUILayout.BeginScrollView(licenseScrollPos, GUI.skin.box);
                {
                    using (new EditorGUI.IndentLevelScope())
                    {
                        EditorGUILayout.SelectableLabel(licenseText, GUILayout.Height(500));
                    }
                }
                EditorGUILayout.EndScrollView();
            }

            isShowingUsingSoftwareLicense = EditorGUILayout.Foldout(isShowingUsingSoftwareLicense, LocalizeText.instance.langPair.usingSoftwareLicenseLabel);

            if (isShowingUsingSoftwareLicense)
            {
                usingSoftwareLicenseScrollPos = EditorGUILayout.BeginScrollView(usingSoftwareLicenseScrollPos, GUI.skin.box);
                {
                    using (new EditorGUI.IndentLevelScope())
                    {
                        EditorGUILayout.SelectableLabel(usingSoftwareLicenseText, GUILayout.Height(500));
                    }
                }
                EditorGUILayout.EndScrollView();
            }
        }
示例#15
0
        public bool DrawGUI(GUILayoutOption[] layoutOptions)
        {
            EditorGUILayout.LabelField(LocalizeText.instance.langPair.boundsTitle, EditorStyles.boldLabel);

            using (new EditorGUILayout.VerticalScope(GUI.skin.box))
            {
                using (new EditorGUILayout.HorizontalScope())
                {
                    GUILayout.FlexibleSpace();

                    GatoGUILayout.Button(
                        LocalizeText.instance.langPair.resetToBoundsToPrefabButtonText,
                        () => {
                        MeshBounds.RevertBounds(targetRenderers);
                    });
                }

                EditorGUILayout.Space();

                EditorGUILayout.LabelField(LocalizeText.instance.langPair.exclusions);

                using (new EditorGUI.IndentLevelScope())
                {
                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
                        var parentObject = GatoGUILayout.ObjectField <GameObject>(
                            LocalizeText.instance.langPair.childObjectsLabel,
                            null);

                        if (check.changed && parentObject != null && avatar != null)
                        {
                            var renderers = parentObject.GetComponentsInChildren <SkinnedMeshRenderer>();
                            foreach (var renderer in renderers)
                            {
                                exclusions.Add(renderer);
                            }
                            exclusions = exclusions.Distinct().ToList();

                            targetRenderers = MeshBounds.GetSkinnedMeshRenderersWithoutExclusions(
                                avatar.Animator.gameObject,
                                exclusions);
                        }
                    }

                    EditorGUILayout.Space();

                    using (new EditorGUILayout.HorizontalScope())
                    {
                        GUILayout.FlexibleSpace();

                        GatoGUILayout.Button(
                            "+",
                            () => {
                            exclusions.Add(null);
                        },
                            true,
                            GUILayout.MaxWidth(60));
                    }

                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
                        for (int i = 0; i < exclusions.Count; i++)
                        {
                            using (new EditorGUILayout.HorizontalScope())
                            {
                                exclusions[i] = GatoGUILayout.ObjectField(
                                    "Object " + (i + 1),
                                    exclusions[i]);

                                GatoGUILayout.Button(
                                    "x",
                                    () => {
                                    exclusions.RemoveAt(i);
                                },
                                    true,
                                    GUILayout.MaxWidth(30));
                            }
                        }

                        if (check.changed && avatar != null)
                        {
                            targetRenderers = MeshBounds.GetSkinnedMeshRenderersWithoutExclusions(
                                avatar.Animator.gameObject,
                                exclusions);
                        }
                    }

                    EditorGUILayout.Space();
                }
            }

            GatoGUILayout.Button(
                LocalizeText.instance.langPair.setBoundsButtonText,
                () => {
                MeshBounds.BoundsSetter(targetRenderers);
            });

            return(false);
        }
示例#16
0
        public bool DrawGUI(GUILayoutOption[] layoutOptions)
        {
            EditorGUILayout.LabelField(LocalizeText.instance.langPair.shaderTitle, EditorStyles.boldLabel);

            using (new EditorGUILayout.VerticalScope(GUI.skin.box))
            {
                using (new EditorGUILayout.HorizontalScope())
                {
                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
                        toggleAll = EditorGUILayout.ToggleLeft(LocalizeText.instance.langPair.toggleAll, toggleAll);
                        if (check.changed)
                        {
                            isTargets             = Enumerable.Range(0, edittingAvatar.Materials.Length).Select(b => toggleAll).ToArray();
                            currentShaderKindName = GetShaderKindName(edittingAvatar.Materials.Where((v, index) => isTargets[index]));
                            shaderKindIndex       = Array.IndexOf(shaderKindNames, currentShaderKindName);
                            Repaint();
                        }
                    }

                    GUILayout.FlexibleSpace();

                    GatoGUILayout.Button(
                        LocalizeText.instance.langPair.duplicateSelectedButtonText,
                        () => {
                        Undo.RegisterCompleteObjectUndo(originalAvatar.Animator.gameObject, "Replace All Materials");
                        var srcMaterials = edittingAvatar.Materials.Where((v, i) => isTargets[i]).ToArray();
                        var newMaterials = GatoUtility.DuplicateMaterials(srcMaterials);
                        for (int i = 0; i < newMaterials.Length; i++)
                        {
                            MaterialEdit.ReplaceMaterial(originalAvatar, srcMaterials[i], newMaterials[i]);
                            MaterialEdit.ReplaceMaterial(edittingAvatar, srcMaterials[i], newMaterials[i]);
                        }
                        Undo.SetCurrentGroupName("Replace All Materials");
                        Repaint();
                    });

                    GatoGUILayout.Button(
                        LocalizeText.instance.langPair.optimizeSelectedButtonText,
                        () => {
                        foreach (var mat in edittingAvatar.Materials.Where((v, i) => isTargets[i]).ToArray())
                        {
                            MaterialEdit.DeleteUnusedProperties(mat, AssetDatabase.GetAssetPath(mat));
                        }
                    });
                }

                EditorGUILayout.Space();

                using (var scrollView = new EditorGUILayout.ScrollViewScope(leftScrollPosShader))
                {
                    leftScrollPosShader = scrollView.scrollPosition;
                    if (edittingAvatar.Materials != null)
                    {
                        for (int i = 0; i < edittingAvatar.Materials.Length; i++)
                        {
                            var mat = edittingAvatar.Materials[i];
                            if (mat is null || mat.shader is null)
                            {
                                continue;
                            }

                            using (new EditorGUILayout.HorizontalScope())
                            {
                                using (var check = new EditorGUI.ChangeCheckScope())
                                {
                                    isTargets[i] = EditorGUILayout.ToggleLeft(string.Empty, isTargets[i], GUILayout.Width(30f));
                                    if (check.changed)
                                    {
                                        currentShaderKindName = GetShaderKindName(edittingAvatar.Materials.Where((v, index) => isTargets[index]));
                                        shaderKindIndex       = Array.IndexOf(shaderKindNames, currentShaderKindName);
                                        Repaint();
                                    }
                                }

                                using (var check = new EditorGUI.ChangeCheckScope())
                                {
                                    var material = GatoGUILayout.ObjectField(string.Empty, mat, true, GUILayout.Width(200f));

                                    if (check.changed && material != null)
                                    {
                                        MaterialEdit.ReplaceMaterial(edittingAvatar, mat, material);
                                        MaterialEdit.ReplaceMaterial(originalAvatar, mat, material);
                                        currentShaderKindName = GetShaderKindName(edittingAvatar.Materials.Where((v, index) => isTargets[index]));
                                        shaderKindIndex       = Array.IndexOf(shaderKindNames, currentShaderKindName);
                                        Repaint();
                                    }
                                }

                                int shaderIndex = Array.IndexOf(customShaders, mat.shader);
                                using (var check = new EditorGUI.ChangeCheckScope())
                                {
                                    shaderIndex = EditorGUILayout.Popup(shaderIndex, customShaderNames);
                                    if (check.changed)
                                    {
                                        mat.shader            = customShaders[shaderIndex];
                                        currentShaderKindName = GetShaderKindName(edittingAvatar.Materials.Where((v, index) => isTargets[index]));
                                        shaderKindIndex       = Array.IndexOf(shaderKindNames, currentShaderKindName);
                                        Repaint();
                                    }
                                }

                                GatoGUILayout.Button(
                                    LocalizeText.instance.langPair.edit,
                                    () => {
                                    Selection.activeObject = mat;
                                });
                            }
                        }
                    }
                }

                EditorGUILayout.Space();

                EditorGUILayout.HelpBox(LocalizeText.instance.langPair.useInspectorMessageText, MessageType.Info);

                EditorGUILayout.Space();

                using (new EditorGUILayout.HorizontalScope())
                {
                    EditorGUILayout.LabelField(LocalizeIfNeeded(currentShaderKindName));
                    GUILayout.Label("=>");
                    shaderKindIndex = EditorGUILayout.Popup(shaderKindIndex, shaderKindNames);

                    using (new EditorGUI.DisabledGroupScope(shaderKindIndex == -1 || currentShaderKindName == NOSELECTION || currentShaderKindName == shaderKindNames[shaderKindIndex]))
                    {
                        GatoGUILayout.Button(
                            LocalizeText.instance.langPair.replaceShaderButtonText,
                            () => {
                            var materials = edittingAvatar.Materials.Where((v, i) => isTargets[i]).ToArray();
                            var group     = shaderKindGroups[shaderKindIndex];
                            if (group.Count() == 1)
                            {
                                var dstShader = group.Single();
                                foreach (var mat in materials)
                                {
                                    mat.shader = dstShader;
                                }
                            }
                            else
                            {
                                var dstShaderGroup = shaderKindGroups[shaderKindIndex].Select(s => s).ToArray();
                                foreach (var mat in materials)
                                {
                                    var dstShader = MaterialEdit.CalculateSimilarShader(dstShaderGroup, mat.shader);
                                    mat.shader    = dstShader;
                                }
                            }

                            currentShaderKindName = shaderKindNames[shaderKindIndex];

                            Repaint();
                        });
                    }
                }
            }
            return(false);
        }
        public bool DrawGUI(GUILayoutOption[] layoutOptions)
        {
            EditorGUILayout.LabelField(LocalizeText.instance.langPair.probeAnchorTitle, EditorStyles.boldLabel);

            using (new EditorGUILayout.VerticalScope(GUI.skin.box))
            {
                // 設定するRendererの選択
                isGettingSkinnedMeshRenderer = EditorGUILayout.Toggle(LocalizeText.instance.langPair.setToSkinnedMeshRendererLabel, isGettingSkinnedMeshRenderer);
                isGettingMeshRenderer        = EditorGUILayout.Toggle(LocalizeText.instance.langPair.setToMeshRendererLabel, isGettingMeshRenderer);

                // ライティングの計算の基準とする位置を選択
                targetPos = (ProbeAnchor.TARGETPOS)EditorGUILayout.EnumPopup(LocalizeText.instance.langPair.targetPositionLabel, targetPos);

                // Rendererの一覧を表示
                if (avatar != null && avatar.Animator != null)
                {
                    isOpeningRendererList = EditorGUILayout.Foldout(isOpeningRendererList, LocalizeText.instance.langPair.rendererListLabel);

                    if (isOpeningRendererList)
                    {
                        using (var scrollView = new EditorGUILayout.ScrollViewScope(leftScrollPos))
                        {
                            leftScrollPos = scrollView.scrollPosition;

                            using (new EditorGUI.IndentLevelScope())
                            {
                                int index = 0;

                                if (isGettingSkinnedMeshRenderer && avatar.SkinnedMeshList != null && isSettingToSkinnedMesh != null)
                                {
                                    foreach (IProbeAnchorSkinnedMesh skinnedMesh in avatar.SkinnedMeshList)
                                    {
                                        if (skinnedMesh == null || skinnedMesh.Renderer == null)
                                        {
                                            continue;
                                        }

                                        using (new GUILayout.HorizontalScope())
                                        {
                                            isSettingToSkinnedMesh[index] = EditorGUILayout.Toggle(skinnedMesh.Obj.name, isSettingToSkinnedMesh[index]);
                                            GatoGUILayout.Button(LocalizeText.instance.langPair.select,
                                                                 () => {
                                                Selection.activeGameObject = skinnedMesh.Obj;
                                            });
                                        }

                                        index++;
                                    }
                                }

                                index = 0;

                                if (isGettingMeshRenderer && avatar.MeshRendererList != null && isSettingToMesh != null)
                                {
                                    foreach (var mesh in avatar.MeshRendererList)
                                    {
                                        if (mesh == null)
                                        {
                                            continue;
                                        }

                                        using (new GUILayout.HorizontalScope())
                                        {
                                            isSettingToMesh[index] = EditorGUILayout.Toggle(mesh.gameObject.name, isSettingToMesh[index]);
                                            GatoGUILayout.Button(LocalizeText.instance.langPair.select,
                                                                 () => {
                                                Selection.activeGameObject = mesh.gameObject;
                                            });
                                        }

                                        index++;
                                    }
                                }
                            }

                            EditorGUILayout.HelpBox(LocalizeText.instance.langPair.probeAnchorMessageText, MessageType.Info);
                        }
                    }
                }
            }

            GatoGUILayout.Button(LocalizeText.instance.langPair.setProbeAnchorButtonText,
                                 () => {
                GameObject anchorTarget = null;
                var result = ProbeAnchor.CreateAndSetProbeAnchorObject(avatar.Animator.gameObject, targetPos, ref anchorTarget);
                if (result && isGettingSkinnedMeshRenderer)
                {
                    ProbeAnchor.SetProbeAnchorToSkinnedMeshRenderers(ref anchorTarget, ref avatar, ref isSettingToSkinnedMesh);
                }
                if (result && isGettingMeshRenderer)
                {
                    ProbeAnchor.SetProbeAnchorToMeshRenderers(ref anchorTarget, ref avatar, ref isSettingToMesh);
                }
            });

            return(false);
        }
示例#18
0
        public bool DrawGUI(GUILayoutOption[] layoutOptions)
        {
            using (new EditorGUILayout.HorizontalScope())
            {
                using (new EditorGUILayout.VerticalScope())
                {
                    // アバター表示
                    using (new EditorGUILayout.HorizontalScope())
                    {
                        GUILayout.FlexibleSpace();

                        if (avatarMonitorField.Render(monitorSize, true, showEyePosition))
                        {
                            return(true);
                        }

                        GUILayout.FlexibleSpace();
                    }

                    // アバター回転
                    using (new EditorGUILayout.HorizontalScope())
                    {
                        if (GUILayout.Button("<"))
                        {
                            avatarMonitorField.RotateCamera(-CAMERA_ROTATE_ANGLE);
                            return(true);
                        }

                        if (GUILayout.Button(LocalizeText.instance.langPair.reset))
                        {
                            avatarMonitorField.ResetCameraTransform();
                            return(true);
                        }

                        if (GUILayout.Button(">"))
                        {
                            avatarMonitorField.RotateCamera(CAMERA_ROTATE_ANGLE);
                            return(true);
                        }
                    }

                    using (new GUILayout.HorizontalScope())
                        using (var check = new EditorGUI.ChangeCheckScope())
                        {
                            var zoomLevel = EditorGUILayout.Slider(avatarMonitorField.GetNormalizedSubOrthographicSize(), 0f, 1f);

                            if (check.changed)
                            {
                                avatarMonitorField.ZoomAvatarCam(zoomLevel);
                                return(true);
                            }
                        }
                }
            }

            using (new GUILayout.VerticalScope())
            {
                using (new GUILayout.HorizontalScope())
                {
                    GUILayout.FlexibleSpace();
                    var lightDelta = GatoGUILayout.LightRotater(50f, 50f, ref isLightPressing);

                    if (lightDelta != Vector2.zero)
                    {
                        avatarMonitorField.RotateLight(lightDelta);
                        return(true);
                    }
                    GUILayout.FlexibleSpace();
                }

                GUILayout.Space(20f);

                using (new GUILayout.HorizontalScope())
                {
                    GUILayout.FlexibleSpace();
                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
                        var normalizedCameraHeight = GatoGUILayout.VerticalSlider(upDownTexture, 30f, 150f, avatarMonitorField.GetNormalizedMonitorHeight(), 0, 1);
                        if (check.changed)
                        {
                            avatarMonitorField.MoveAvatarCamHeight(normalizedCameraHeight);
                            return(true);
                        }
                    }
                    GUILayout.FlexibleSpace();
                }
            }
            return(false);
        }
示例#19
0
        public override bool DrawGUI(GUILayoutOption[] layoutOptions)
        {
            using (new EditorGUILayout.VerticalScope(GUI.skin.box, layoutOptions))
            {
                if (originalAvatar != null)
                {
                    fxController = originalAvatar.FxController;
                }

                using (new EditorGUILayout.HorizontalScope())
                {
                    EditorGUILayout.LabelField("FX Layer", EditorStyles.boldLabel);

                    // TODO: Emote一覧に切り替えるボタン
                }

                EditorGUILayout.Space();

                // TODO: Emote一覧と切り替えられるように?
                if (fxController != null)
                {
                    var layerNames = fxController.layers.Select(l => l.name).ToArray();
                    editAvatar.TargetFxLayerIndex = EditorGUILayout.Popup("Layer", editAvatar.TargetFxLayerIndex, layerNames);
                    var states = fxController.layers[editAvatar.TargetFxLayerIndex]
                                 .stateMachine.states
                                 .Where(s => !(s.state.motion is BlendTree))
                                 .OrderBy(s => s.state.name)
                                 .ToArray();

                    GatoGUILayout.ErrorBox(LocalizeText.instance.langPair.haveNoAnimationClipMessageText, states.Any(), MessageType.Info);

                    AnimationClip anim;
                    for (int i = 0; i < states.Length; i++)
                    {
                        var stateName = states[i].state.name;
                        anim = states[i].state.motion as AnimationClip;

                        states[i].state.motion = EdittableAnimationField(
                            $"{i + 1}:{stateName}",
                            anim,
                            false,
                            anim != null && !anim.name.StartsWith("proxy_"),
                            () => {
                            if (vrcAvatarEditorGUI.CurrentTool != VRCAvatarEditorGUI.ToolFunc.FaceEmotion)
                            {
                                vrcAvatarEditorGUI.CurrentTool = VRCAvatarEditorGUI.ToolFunc.FaceEmotion;
                            }
                            FaceEmotion.ApplyAnimationProperties(anim, editAvatar);
                            ((FaceEmotionGUI3)faceEmotionGUI).ChangeSaveAnimationState(
                                anim.name,
                                i,
                                anim);
                        });
                    }
                }
                else
                {
                    EditorGUILayout.HelpBox(LocalizeText.instance.langPair.missingFxControllerMessageText, MessageType.Warning);

                    if (GUILayout.Button(LocalizeText.instance.langPair.createFxControllerText))
                    {
                        CreatePlayableLayerController(originalAvatar, editAvatar);
                        vrcAvatarEditorGUI.OnToolChanged();
                    }
                }
            }

            return(false);
        }
        protected override void DrawCreatedAnimationSettingsGUI()
        {
            base.DrawCreatedAnimationSettingsGUI();

            string[] stateNames;

            if (editAvatar.FxController != null)
            {
                var stateMachine = editAvatar.FxController.layers[editAvatar.TargetFxLayerIndex].stateMachine;
                states = stateMachine.states
                         .Where(s => !(s.state.motion is BlendTree))
                         .OrderBy(s => s.state.name)
                         .ToArray();
                stateNames = states.Select((s, i) => $"{i + 1}:{s.state.name}").ToArray();

                EditorGUILayout.LabelField("Layer", editAvatar.FxController.layers[editAvatar.TargetFxLayerIndex].name);

                // Stateがないとき、自動設定できない
                if (states.Any())
                {
                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
                        selectedStateIndex = EditorGUILayout.Popup(
                            "State",
                            selectedStateIndex,
                            stateNames);

                        if (check.changed)
                        {
                            // TODO: 手のアニメーションファイルを変更する?
                        }
                    }
                }
                else
                {
                    EditorGUILayout.HelpBox(LocalizeText.instance.langPair.createOnlyMessageText, MessageType.Info);
                }

                if (editAvatar.GestureController != null)
                {
                    ChildAnimatorState handState = default;
                    if (editAvatar.GestureController.layers.Length > editAvatar.TargetFxLayerIndex &&
                        states.Any())
                    {
                        handState = editAvatar.GestureController.layers[editAvatar.TargetFxLayerIndex]
                                    .stateMachine.states
                                    .Where(s => !(s.state.motion is BlendTree) &&
                                           s.state.name == states[selectedStateIndex].state.name)
                                    .SingleOrDefault();
                    }

                    // LayerまたはStateが見つからない時はGestureまわりは利用できない
                    if (handState.state != null)
                    {
                        handPoseAnim = handState.state.motion as AnimationClip;
                        using (var check = new EditorGUI.ChangeCheckScope())
                        {
                            handPoseAnim = GatoGUILayout.ObjectField(
                                LocalizeText.instance.langPair.handPoseAnimClipLabel,
                                handPoseAnim);

                            if (check.changed)
                            {
                                handState.state.motion = handPoseAnim;
                                EditorUtility.SetDirty(editAvatar.GestureController);
                            }
                        }
                    }
                    else
                    {
                        EditorGUILayout.HelpBox(LocalizeText.instance.langPair.handPoseChangeFailedMessageText, MessageType.Info);
                    }
                }
                else
                {
                    EditorGUILayout.HelpBox(LocalizeText.instance.langPair.missingGestureControllerMessageText, MessageType.Warning);

                    GatoGUILayout.Button(
                        LocalizeText.instance.langPair.createGestureControllerText,
                        () =>
                    {
                        AnimationsGUI.CreateGestureController(originalAvatar, editAvatar);
                        parentWindow.OnToolChanged();
                    });
                }

                setLeftAndRight = EditorGUILayout.ToggleLeft(LocalizeText.instance.langPair.setLeftAndRightHandLayerText, setLeftAndRight);
            }
            else
            {
                EditorGUILayout.HelpBox(LocalizeText.instance.langPair.missingFxControllerMessageText, MessageType.Error);

                GatoGUILayout.Button(
                    LocalizeText.instance.langPair.createFxControllerText,
                    () =>
                {
                    AnimationsGUI.CreatePlayableLayerController(originalAvatar, editAvatar);
                    parentWindow.OnToolChanged();
                });
            }
        }
示例#21
0
        public override bool DrawGUI(GUILayoutOption[] layoutOptions)
        {
            // 設定済みアニメーション一覧
            using (new EditorGUILayout.VerticalScope(GUI.skin.box, layoutOptions))
            {
                using (new EditorGUILayout.HorizontalScope())
                {
                    GUILayout.FlexibleSpace();
                    // タブを描画する
                    _tab = (Tab)GUILayout.Toolbar((int)_tab, LocalizeText.instance.animationTabTexts, "LargeButton", GUI.ToolbarButtonSize.Fixed);
                    GUILayout.FlexibleSpace();
                }
                if (_tab == Tab.Standing)
                {
                    titleText = LocalizeText.instance.langPair.standingTabText;
                    if (originalAvatar != null)
                    {
                        controller = originalAvatar.StandingAnimController;
                    }
                }
                else
                {
                    titleText = LocalizeText.instance.langPair.sittingTabText;
                    if (originalAvatar != null)
                    {
                        controller = originalAvatar.SittingAnimController;
                    }
                }

                using (new EditorGUILayout.HorizontalScope())
                {
                    EditorGUILayout.LabelField(titleText, EditorStyles.boldLabel);

                    string btnText;
                    if (!showEmoteAnimations)
                    {
                        btnText = LocalizeText.instance.langPair.emoteButtonText;
                    }
                    else
                    {
                        btnText = LocalizeText.instance.langPair.faceAndHandButtonText;
                    }

                    GatoGUILayout.Button(
                        btnText,
                        () =>
                    {
                        showEmoteAnimations = !showEmoteAnimations;
                    });
                }

                EditorGUILayout.Space();

                if (controller != null)
                {
                    if (!showEmoteAnimations)
                    {
                        AnimationClip anim;
                        for (int i = 0; i < HANDANIMS.Length; i++)
                        {
                            var handPoseName = HANDANIMS[i];
                            anim = handPoseName == controller[handPoseName].name ?
                                   null :
                                   controller[handPoseName];

                            controller[handPoseName] = EdittableAnimationField(
                                (i + 1) + ":" + handPoseName,
                                anim,
                                pathMissing[i],
                                anim != null,
                                () => {
                                if (vrcAvatarEditorGUI.CurrentTool != VRCAvatarEditorGUI.ToolFunc.FaceEmotion)
                                {
                                    vrcAvatarEditorGUI.CurrentTool = VRCAvatarEditorGUI.ToolFunc.FaceEmotion;
                                }
                                FaceEmotion.ApplyAnimationProperties(controller[handPoseName], editAvatar);
                                ((FaceEmotionGUI2)faceEmotionGUI).ChangeSaveAnimationState(controller[handPoseName].name,
                                                                                           (HandPose.HandPoseType)Enum.ToObject(typeof(HandPose.HandPoseType), i + 1),
                                                                                           controller[handPoseName]);
                            });
                        }
                    }
                    else
                    {
                        AnimationClip anim;
                        foreach (var emoteAnim in EMOTEANIMS)
                        {
                            anim = emoteAnim == controller[emoteAnim].name ?
                                   null :
                                   controller[emoteAnim];

                            controller[emoteAnim] = ValidatableAnimationField($" {emoteAnim}", anim, false);
                        }
                    }
                }
                else
                {
                    if (editAvatar.Descriptor == null)
                    {
                        EditorGUILayout.HelpBox(LocalizeText.instance.langPair.noAvatarMessageText, MessageType.Warning);
                    }
                    else
                    {
                        string notSettingMessage, createMessage;
                        if (_tab == Tab.Standing)
                        {
                            notSettingMessage = LocalizeText.instance.langPair.noCustomStandingAnimsMessageText;
                            createMessage     = LocalizeText.instance.langPair.createCustomStandingAnimsButtonText;
                        }
                        else
                        {
                            notSettingMessage = LocalizeText.instance.langPair.noCustomSittingAnimsMessageText;
                            createMessage     = LocalizeText.instance.langPair.createCustomSittingAnimsButtonText;
                        }
                        EditorGUILayout.HelpBox(notSettingMessage, MessageType.Warning);

                        GatoGUILayout.Button(
                            createMessage,
                            () => {
                            var fileName       = "CO_" + originalAvatar.Animator.gameObject.name + ".overrideController";
                            saveFolderPath     = "Assets/" + originalAvatar.Animator.gameObject.name + "/";
                            var fullFolderPath = Path.GetFullPath(saveFolderPath);
                            if (!Directory.Exists(fullFolderPath))
                            {
                                Directory.CreateDirectory(fullFolderPath);
                                AssetDatabase.Refresh();
                            }
                            var createdCustomOverrideController = InstantiateVrcCustomOverideController(saveFolderPath + fileName);

                            if (_tab == Tab.Standing)
                            {
                                originalAvatar.Descriptor.CustomStandingAnims = createdCustomOverrideController;
                                editAvatar.Descriptor.CustomStandingAnims     = createdCustomOverrideController;
                            }
                            else
                            {
                                originalAvatar.Descriptor.CustomSittingAnims = createdCustomOverrideController;
                                editAvatar.Descriptor.CustomSittingAnims     = createdCustomOverrideController;
                            }

                            originalAvatar.LoadAvatarInfo();
                            editAvatar.LoadAvatarInfo();

                            vrcAvatarEditorGUI.UpdateExclusitionBlendShapes();
                        });

                        if (_tab == Tab.Sitting)
                        {
                            GatoGUILayout.Button(
                                LocalizeText.instance.langPair.setToSameAsCustomStandingAnimsButtonText,
                                () => {
                                var customStandingAnimsController            = originalAvatar.Descriptor.CustomStandingAnims;
                                originalAvatar.Descriptor.CustomSittingAnims = customStandingAnimsController;
                                editAvatar.Descriptor.CustomSittingAnims     = customStandingAnimsController;
                                originalAvatar.LoadAvatarInfo();
                                editAvatar.LoadAvatarInfo();

                                vrcAvatarEditorGUI.UpdateExclusitionBlendShapes();
                            },
                                editAvatar.StandingAnimController != null);
                        }
                    }
                }

                if (pathMissing.Any(x => x))
                {
                    var warningMessage = (failedAutoFixMissingPath) ? LocalizeText.instance.langPair.failAutoFixMissingPathMessageText : LocalizeText.instance.langPair.existMissingPathMessageText;
                    EditorGUILayout.HelpBox(warningMessage, MessageType.Warning);
                    GatoGUILayout.Button(
                        LocalizeText.instance.langPair.autoFix,
                        () => {
                        failedAutoFixMissingPath = false;
                        for (int i = 0; i < pathMissing.Length; i++)
                        {
                            if (!pathMissing[i])
                            {
                                continue;
                            }
                            var result = GatoUtility.TryFixMissingPathInAnimationClip(
                                editAvatar.Animator,
                                editAvatar.StandingAnimController[HANDANIMS[i]]);
                            pathMissing[i]           = !result;
                            failedAutoFixMissingPath = !result;
                        }
                    },
                        !failedAutoFixMissingPath
                        );
                }
            }
            return(false);
        }
示例#22
0
        public bool DrawGUI(GUILayoutOption[] layoutOptions)
        {
            EditorGUILayout.LabelField(LocalizeText.instance.langPair.avatarInfoTitle, EditorStyles.boldLabel);

            if (originalAvatar != null && originalAvatar.Descriptor != null)
            {
                using (new EditorGUILayout.VerticalScope(GUI.skin.box))
                {
                    // 性別
                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
                        originalAvatar.Sex = (AnimationSet)EditorGUILayout.EnumPopup(LocalizeText.instance.langPair.genderLabel, originalAvatar.Sex);

                        if (check.changed)
                        {
                            originalAvatar.Descriptor.Animations = originalAvatar.Sex;
                            EditorUtility.SetDirty(originalAvatar.Descriptor);
                        }
                    }

                    // アップロード状態
                    EditorGUILayout.LabelField(LocalizeText.instance.langPair.uploadStatusLabel,
                                               (string.IsNullOrEmpty(originalAvatar.AvatarId)) ?
                                               LocalizeText.instance.langPair.newAvatarText :
                                               LocalizeText.instance.langPair.uploadedAvatarText);

                    // AnimatorOverrideController
                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
#if VRC_SDK_VRCSDK2
                        originalAvatar.StandingAnimController = GatoGUILayout.ObjectField(
                            LocalizeText.instance.langPair.customStandingAnimsLabel,
                            originalAvatar.StandingAnimController);

                        originalAvatar.SittingAnimController = GatoGUILayout.ObjectField(
                            LocalizeText.instance.langPair.customSittingAnimsLabel,
                            originalAvatar.SittingAnimController);
#elif VRC_SDK_VRCSDK3
                        originalAvatar.GestureController = GatoGUILayout.ObjectField(
                            "Gesture Layer",
                            originalAvatar.GestureController);

                        originalAvatar.FxController = GatoGUILayout.ObjectField(
                            "FX Layer",
                            originalAvatar.FxController);
#endif

                        if (check.changed)
                        {
#if VRC_SDK_VRCSDK2
                            originalAvatar.Descriptor.CustomStandingAnims = originalAvatar.StandingAnimController;
                            originalAvatar.Descriptor.CustomSittingAnims  = originalAvatar.SittingAnimController;
#elif VRC_SDK_VRCSDK3
                            originalAvatar.Descriptor.baseAnimationLayers[2].animatorController = originalAvatar.GestureController;
                            originalAvatar.Descriptor.baseAnimationLayers[4].animatorController = originalAvatar.FxController;
#endif
                            EditorUtility.SetDirty(originalAvatar.Descriptor);

                            originalAvatar.SetAnimSavedFolderPath();
                        }
                    }

                    // ポリゴン数
                    EditorGUILayout.LabelField(LocalizeText.instance.langPair.triangleCountLabel, originalAvatar.TriangleCount + "(" + (originalAvatar.TriangleCount + originalAvatar.TriangleCountInactive) + ")");

                    // 身長
                    EditorGUILayout.LabelField(LocalizeText.instance.langPair.heightLabel, $"{originalAvatar.Height:F2} m");

                    // View Position
                    using (new EditorGUILayout.HorizontalScope())
                    {
                        EditorGUILayout.LabelField(LocalizeText.instance.langPair.viewPositionLabel, GUILayout.Width(145f));
                        using (var check = new EditorGUI.ChangeCheckScope())
                        {
                            originalAvatar.EyePos = EditorGUILayout.Vector3Field(string.Empty, originalAvatar.EyePos);

                            if (check.changed)
                            {
                                originalAvatar.Descriptor.ViewPosition = originalAvatar.EyePos;
                                editAvatar.Descriptor.ViewPosition     = originalAvatar.EyePos;
                                editAvatar.EyePos = originalAvatar.EyePos;
                                EditorUtility.SetDirty(originalAvatar.Descriptor);

                                monitorGUI.showEyePosition = true;
                                monitorGUI.MoveAvatarCam(false, true);
                            }
                        }

                        monitorGUI.showEyePosition = GatoGUILayout.ToggleImage(
                            monitorGUI.showEyePosition,
                            showIconTexture,
                            hideIconTexture);
                    }

                    // faceMesh
                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
                        originalAvatar.FaceMesh = GatoGUILayout.ObjectField(
                            LocalizeText.instance.langPair.faceMeshLabel,
                            originalAvatar.FaceMesh);

                        if (check.changed)
                        {
                            originalAvatar.Descriptor.VisemeSkinnedMesh = originalAvatar.FaceMesh;
                            EditorUtility.SetDirty(originalAvatar.Descriptor);
                        }
                    }

                    /*
                     * using (new EditorGUILayout.HorizontalScope())
                     * using (new EditorGUI.DisabledGroupScope(avatar.faceMesh == null))
                     * {
                     *  GUILayout.FlexibleSpace();
                     *  if (GUILayout.Button("Auto Setting"))
                     *  {
                     *      avatar.eyePos = CalcAvatarViewPosition(avatar);
                     *      avatar.descriptor.ViewPosition = avatar.eyePos;
                     *  }
                     *
                     *  if (GUILayout.Button("Revert to Prefab"))
                     *  {
                     *      avatar.eyePos = RevertEyePosToPrefab(avatar.descriptor);
                     *  }
                     * }
                     * if (avatar.faceMesh == null)
                     * {
                     *  EditorGUILayout.HelpBox("ViewPositionを自動設定するためにはFaceMeshを設定する必要があります", MessageType.Warning);
                     * }
                     */

                    EditorGUILayout.Space();

                    // リップシンク
                    using (var check = new EditorGUI.ChangeCheckScope())
                    {
                        originalAvatar.LipSyncStyle = (LipSyncStyle)EditorGUILayout.EnumPopup(LocalizeText.instance.langPair.lipSyncTypeLabel, originalAvatar.LipSyncStyle);

                        if (check.changed)
                        {
                            originalAvatar.Descriptor.lipSync = originalAvatar.LipSyncStyle;
                        }
                    }
                    if (originalAvatar.LipSyncStyle == LipSyncStyle.VisemeBlendShape)
                    {
                        if (originalAvatar.FaceMesh != null)
                        {
                            isOpeningLipSync = EditorGUILayout.Foldout(isOpeningLipSync, LocalizeText.instance.langPair.lipSyncBlendShapesLabel);
                            if (isOpeningLipSync)
                            {
                                using (new EditorGUI.IndentLevelScope())
                                    using (var scrollView = new EditorGUILayout.ScrollViewScope(lipSyncScrollPos))
                                    {
                                        lipSyncScrollPos = scrollView.scrollPosition;

                                        for (int visemeIndex = 0; visemeIndex < LIPSYNC_SHYPEKEY_NUM; visemeIndex++)
                                        {
                                            EditorGUILayout.LabelField("Viseme:" + Enum.GetName(typeof(Viseme), visemeIndex), originalAvatar.Descriptor.VisemeBlendShapes[visemeIndex]);
                                        }
                                    }
                            }
                        }
                    }
                    if (originalAvatar.LipSyncStyle != LipSyncStyle.VisemeBlendShape || originalAvatar.FaceMesh == null)
                    {
                        EditorGUILayout.HelpBox(LocalizeText.instance.langPair.lipSyncWarningMessageText, MessageType.Warning);
                        GatoGUILayout.Button(
                            LocalizeText.instance.langPair.lipSyncBlendShapesAutoDetectButtonText,
                            () => {
                            originalAvatar.SetLipSyncToViseme();
                            EditorUtility.SetDirty(originalAvatar.Descriptor);
                        });
                    }
                }

                EditorGUILayout.Space();
            }
            return(false);
        }