CM3D2.YASD.Plugin

/*
 * CM3D2.YASD.Plugin (Yet Another Soft Demosaic Plugin)
 *
 * モザイクのON/OFFを切り替えたりボディのテクスチャを変更できるUnityInjectorのプラグインです。
 *
 * モザイクはF4でメイド|メイドとおもちゃ|全部|消さないを切り替えます。
 * iniファイルを書き換えるとキーや切り替えの有効無効、モザイクを消す対象を変更できます。
 * 切り替えを無効にしてもiniで指定されたモザイクは消えます。
 * 切り替え機能がいらなければOFFにすると無駄な処理が減る分ちょっとだけ軽くなるかも。
 *
 * テクスチャ変更はメイドのボディ限定でTranslation Loaderと同じような処理をします。
 * Translation Loaderと違いReiPatcherでパッチを当てる必要がないのが強みです。
 * メイドのボディ以外のテクスチャも変更したい場合は素直にTranslation Loaderを使ってください。
 * プラグインを導入して一度ゲームを起動するとUnityInjector\Configに
 * YASD.iniファイルとYASDフォルダが作成されるのでYASDフォルダの中にテクスチャファイルを
 * コピーしてください。
 * テクスチャはpng形式のみに対応しています。
 * メイドが表示されているときにF3を押すとメイドに反映されます。
 * F3を押さずに自動で変更することもできますがデフォルトで無効になっています。
 * 自動で変更する場合はiniファイルの[ChangeTexture]セクションの[AutoChange]を
 * Trueに書き換えてください。
 *
 * 自動変更モードの仕様
 * テクスチャはゲーム起動時にリストが作成されてその中の物のみが反映されます。
 * テクスチャ変更時に何らかの理由で読み込みに失敗したファイルはリストから消去されます。
 * また、一度変更したテクスチャはファイルを入れ替えても即時反映されません。
 * ゲーム内のエディットで肌を変更後元の肌戻すと最新のファイルを読み込みます。
 * また、自動変更中にF3を押すとリストを更新し最新のファイルを強制的に適用します。
 * 要はゲーム中にテクスチャを入れ替えたらF3を押してください。
 *
 *
 * SofrDemosaic.iniの内容
 * [DeMosaic]セクション
 * ChangeMode={True, False}
 *      キーボードでの切り替えの有効無効を設定します。
 *      True=有効　False=無効
 *
 * Target={None, Maid, MaidAndItem, All}
 * 　   モザイクを消す対象を指定。
 * 　   キーボード切り替えが有効な場合は押す度に切り替わります。
 * 　   無効の場合はiniで指定した値で固定されます。
 * 　        None=消さない
 * 　        Maid＝女性のみ
 * 　        MaidAndItem=女性とおもちゃ
 * 　        All=全て(女性、おもちゃ、男性)
 *
 * HotKey
 *      モザイクモード切替キーの設定。デフォルトはF4。
 *      指定するコードは下記URL参照。
 *      http://docs.unity3d.com/jp/current/ScriptReference/KeyCode.html
 *
 *
 * [ChangeTexture]セクション
 * AutoChange={True, False}
 *      テクスチャ自動変更機能の有効無効を設定します。
 *      True=有効　False=無効
 *
 * HotKey
 *      テクスチャリスト再読み込みキーの設定。デフォルトはF3
 *      自動更新が無効の場合はテクスチャリスト読み込みとテクスチャの変更を行います。
 *      指定するコードはDeMosaicセクションのURL参照。
 *
 *
 * コンパイル時の参照設定
 * /r:UnityEngine.dll /r:UnityInjector.dll /r:Assembly-CSharp.dll /r:Assembly-CSharp-firstpass.dll /r:ExINI.dll
 *
*/

using ExIni;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using UnityEngine;
using UnityInjector;
using UnityInjector.Attributes;

namespace CM3D2.YetAnotherSoftDemosaic.Plugin
{
    [PluginFilter("CM3D2x64"),
    PluginFilter("CM3D2x86"),
    PluginFilter("CM3D2VRx64"),
    PluginName("Yet Another Soft DeMosaic"),
    PluginVersion("2.0.0.0")]
    public class YASD : PluginBase
    {
        private Coroutine deMosaicCoroutine;
        private Coroutine[] changeTextureCoroutine = new Coroutine[2];
        private bool runningCoroutine = false;

        private bool allowChangeMosaic = true;
        private KeyCode deMosaicHotKey = KeyCode.F4;

        private bool allowAutoChangeTexture = false;
        private KeyCode loadTextureKey = KeyCode.F3;

        //1fで1秒
        private const float WAIT_SECOND_DEMOSAIC = 0.5f;

        private const float WAIT_SECOND_CHANGE_TEXTURE = 1f;

        /// <summary>
        /// CM3D2のシーンリスト
        /// </summary>
        private enum Scene
        {
            /// <summary>メイド選択（夜伽、品評会の前など）</summary>
            SceneCharacterSelect = 1,

            /// <summary>品評会</summary>
            SceneCompetitiveShow = 2,

            /// <summary>昼夜メニュー、仕事結果</summary>
            SceneDaily = 3,

            /// <summary>ダンス1</summary>
            SceneDance_DDFL = 4,

            /// <summary>メイドエディット</summary>
            SceneEdit = 5,

            /// <summary>メーカーロゴ</summary>
            SceneLogo = 6,

            /// <summary>メイド管理</summary>
            SceneMaidManagement = 7,

            /// <summary>ショップ</summary>
            SceneShop = 8,

            /// <summary>タイトル画面</summary>
            SceneTitle = 9,

            /// <summary>トロフィー閲覧</summary>
            SceneTrophy = 10,

            /// <summary>？？？</summary>
            SceneTryInfo = 11,

            /// <summary>主人公エディット</summary>
            SceneUserEdit = 12,

            /// <summary>起動時警告画面</summary>
            SceneWarning = 13,

            /// <summary>夜伽</summary>
            SceneYotogi = 14,

            /// <summary>ADVパート(kgスクリプト処理）</summary>
            SceneADV = 15,

            /// <summary>日付画面</summary>
            SceneStartDaily = 16,

            /// <summary>タイトルに戻る</summary>
            SceneToTitle = 17,

            /// <summary>MVP</summary>
            SceneSingleEffect = 18,

            /// <summary>スタッフロール</summary>
            SceneStaffRoll = 19,

            /// <summary>ダンス2</summary>
            SceneDance_ETYL = 20
        }

        /// <summary>
        /// 3Dキャラが描画されるレベル
        /// </summary>
        private enum EnableLevel
        {
            /// <summary>品評会</summary>
            SceneCompetitiveShow = 2,

            /// <summary>ダンス1</summary>
            SceneDance_DDFL = 4,

            /// <summary>メイドエディット</summary>
            SceneEdit = 5,

            /// <summary>ショップ</summary>
            SceneShop = 8,

            /// <summary>夜伽</summary>
            SceneYotogi = 14,

            /// <summary>ADVパート(kgスクリプト処理）</summary>
            SceneADV = 15,

            /// <summary>MVP</summary>
            SceneSingleEffect = 18,

            /// <summary>ダンス2</summary>
            SceneDance_ETYL = 20
        }

        /// <summary>
        /// 男キャラやおもちゃが出現するレベル
        /// </summary>
        private enum ShowMenOrToysLevel
        {
            /// <summary>夜伽</summary>
            SceneYotogi = 14,

            /// <summary>ADVパート(kgスクリプト処理）</summary>
            SceneADV = 15
        }

        /// <summary>
        /// メイドが出現するがキャラ変更や着替えを行わないレベル
        /// </summary>
        private enum NotChangeMaidsLevel
        {
            /// <summary>品評会</summary>
            SceneCompetitiveShow = 2,

            /// <summary>ダンス1</summary>
            SceneDance_DDFL = 4,

            /// <summary>MVP</summary>
            SceneSingleEffect = 18,

            /// <summary>ダンス2</summary>
            SceneDance_ETYL = 20
        }

        private ChangeBodyTexture changeBodyTexture = new ChangeBodyTexture();
        private DeMosaic deMosaic = new DeMosaic();

        private void LoadConfig()
        {
            IniKey changeMosaic = Preferences["DeMosaic"]["ChangeMode"];
            IniKey target = Preferences["DeMosaic"]["Target"];
            IniKey changeMosaicKey = Preferences["DeMosaic"]["HotKey"];
            IniKey changeTex = Preferences["ChangeTexture"]["AutoChange"];
            IniKey changeTexKey = Preferences["ChangeTexture"]["HotKey"];

            if (changeMosaic == null || string.IsNullOrEmpty(changeMosaic.Value))
            {
                changeMosaic.Value = allowChangeMosaic.ToString();
                SaveConfig();
            }
            else
            {
                if (!bool.TryParse(changeMosaic.Value, out allowChangeMosaic))
                {
                    changeMosaic.Value = allowChangeMosaic.ToString();
                    SaveConfig();
                }
            }

            if (target == null || string.IsNullOrEmpty(target.Value))
            {
                target.Value = deMosaic.Target.ToString();
                SaveConfig();
            }
            else
            {
                if (Enum.IsDefined(typeof(DeMosaic.Switch), target.Value))
                {
                    deMosaic.Target = (DeMosaic.Switch)Enum.Parse(typeof(DeMosaic.Switch), target.Value, true);
                }
                else
                {
                    target.Value = deMosaic.Target.ToString();
                    SaveConfig();
                }
            }

            if (changeMosaicKey == null || string.IsNullOrEmpty(changeMosaicKey.Value))
            {
                changeMosaicKey.Value = deMosaicHotKey.ToString();
                SaveConfig();
            }
            else
            {
                if (Enum.IsDefined(typeof(KeyCode), changeMosaicKey.Value))
                {
                    deMosaicHotKey = (KeyCode)Enum.Parse(typeof(KeyCode), changeMosaicKey.Value, true);
                }
                else
                {
                    changeMosaicKey.Value = deMosaicHotKey.ToString();
                    SaveConfig();
                }
            }

            if (changeTex == null || string.IsNullOrEmpty(changeTex.Value))
            {
                changeTex.Value = allowAutoChangeTexture.ToString();
                SaveConfig();
            }
            else
            {
                if (!bool.TryParse(changeTex.Value, out allowAutoChangeTexture))
                {
                    changeTex.Value = allowAutoChangeTexture.ToString();
                    SaveConfig();
                }
            }

            if (changeTexKey == null || string.IsNullOrEmpty(changeTexKey.Value))
            {
                changeTexKey.Value = loadTextureKey.ToString();
                SaveConfig();
            }
            else
            {
                if (Enum.IsDefined(typeof(KeyCode), changeTexKey.Value))
                {
                    loadTextureKey = (KeyCode)Enum.Parse(typeof(KeyCode), changeTexKey.Value, true);
                }
                else
                {
                    changeTexKey.Value = loadTextureKey.ToString();
                    SaveConfig();
                }
            }
        }

        private void Awake()
        {
            GameObject.DontDestroyOnLoad(this);
            System.Diagnostics.Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));

            LoadConfig();

            StartCoroutine(GetKeyInput());
        }

        private void OnLevelWasLoaded(int level)
        {
            if (runningCoroutine)
            {
                System.Diagnostics.Debug.WriteLine("Demosaic Coroutine stop.");
                StopCoroutine(deMosaicCoroutine);
                StopCoroutine(changeTextureCoroutine[0]);
                if (allowAutoChangeTexture)
                {
                    StopCoroutine(changeTextureCoroutine[1]);
                }
                runningCoroutine = false;
            }
            if (Enum.IsDefined(typeof(EnableLevel), level))
            {
                System.Diagnostics.Debug.WriteLine("Demosaic Coroutine start.");
                deMosaicCoroutine = StartCoroutine(DeMosaicCoroutine(level));
                changeTextureCoroutine[0] = StartCoroutine(GetKeyInputForTextureChanger());
                if (allowAutoChangeTexture)
                {
                    changeTextureCoroutine[1] = StartCoroutine(AutoTextureChangerCoroutine());
                }
                runningCoroutine = true;
            }
        }

        private IEnumerator AutoTextureChangerCoroutine()
        {
            while (true)
            {
                yield return new WaitForSeconds(WAIT_SECOND_CHANGE_TEXTURE);
                changeBodyTexture.ChangeTexture(false);
            }
        }

        private IEnumerator GetKeyInputForTextureChanger()
        {
            while (true)
            {
                if (Input.GetKeyDown(loadTextureKey))
                {
                    ChangeBodyTexture.LoadTextureList(ChangeBodyTexture.textureList);
                    changeBodyTexture.ChangeTexture(true);
                }
                yield return null;
            }
        }

        private IEnumerator GetKeyInput()
        {
            while (true)
            {
                if (Input.GetKeyDown(deMosaicHotKey) && allowChangeMosaic)
                {
                    deMosaic.Target++;
                    Console.WriteLine("YADSM Target:{0}", deMosaic.Target.ToString());
                }
                yield return null;
            }
        }

        private IEnumerator DeMosaicCoroutine(int level)
        {
            while (true)
            {
                bool result = deMosaic.DeMosaicMaids();

                if (result && !allowChangeMosaic && Enum.IsDefined(typeof(NotChangeMaidsLevel), level))
                {
                    System.Diagnostics.Debug.WriteLine("DeMosaic Coroutine Break.");
                    runningCoroutine = false;
                    yield break;
                }
                yield return null;

                if (Enum.IsDefined(typeof(ShowMenOrToysLevel), level))
                {
                    deMosaic.DeMosaicToys();
                    yield return null;

                    deMosaic.DeMosaicMen();
                }
                //System.Diagnostics.Debug.WriteLine("DeMosaic Coroutine Continue.");
                yield return new WaitForSeconds(WAIT_SECOND_DEMOSAIC);
            }
        }

        public void OnApplicationQuit()
        {
            Preferences["DeMosaic"]["Target"].Value = deMosaic.Target.ToString();
            SaveConfig();
        }
    }

    public class DeMosaic
    {
        public enum Switch
        {
            None,
            Maid,
            MaidAndItem,
            All,
            Max
        }

        private Switch _target = Switch.All;

        public Switch Target
        {
            get { return _target; }
            set { _target = value == Switch.Max ? Switch.None : value; }
        }

        private Shader shaderTransparent = Shader.Find("CM3D2/Toony_Lighted_Trans");
        private Shader shaderMosaic = Shader.Find("CM3D2/Mosaic");

        private string getHiraerchy(Transform t)
        {
            string hiraerchy = "/" + t.name;
            while (t.parent)
            {
                t = t.parent;
                hiraerchy = "/" + t.name + hiraerchy;
            }

            return hiraerchy;
        }

        private Renderer[] GetMosaicRenderer(string type)
        {
            GameObject alloffset = GameObject.Find("__GameMain__/Character/Active/AllOffset");
            if (!alloffset)
            {
                return null;
            }
            Renderer[] mosaic = alloffset.GetComponentsInChildren<Renderer>(true)
                .Where(_ => _.materials.Any(m => m.name.Contains("moza")))
                .ToArray();

            string s;

            if (type.Equals("toy"))
            {
                return mosaic
                    .Where(_ => _.materials.Any(m => m.name != "moza"))
                    .ToArray();
            }
            else if (type.Equals("man"))
            {
                s = "Man[";
            }
            else if (type.Equals("maid"))
            {
                s = "Maid[";
            }
            else
            {
                Console.WriteLine("YASD.GetMosaicRenderer: Argument error.");
                return null;
            }

            return mosaic
                .Where(_ => _.name.Equals("moza"))
                .Where(_ => getHiraerchy(_.transform).Contains(s))
                .ToArray();
        }

        private Renderer[] GetMaidsMosaicRenderer()
        {
            return GetMosaicRenderer("maid");
        }

        private Renderer[] GetMenMosaicRenderer()
        {
            return GetMosaicRenderer("man");
        }

        private Renderer[] GetToysMosaicRenderer()
        {
            return GetMosaicRenderer("toy");
        }

        public bool DeMosaicMaids()
        {
            bool result = false;
            Renderer[] maidsMosaicList = GetMaidsMosaicRenderer();

            if (maidsMosaicList != null)
            {
                result = HumanMosaicSwitcher(maidsMosaicList, (Target == DeMosaic.Switch.None));
            }
            return result;
        }

        public void DeMosaicMen()
        {
            Renderer[] menMosaicList = GetMenMosaicRenderer();

            if (menMosaicList != null)
            {
                HumanMosaicSwitcher(menMosaicList, (Target != DeMosaic.Switch.All));
            }
        }

        private bool HumanMosaicSwitcher(Renderer[] mosaic, bool enableMosaic)
        {
            bool result = false;
            if (mosaic == null)
            {
                return result;
            }
            mosaic.Where(_ => _.enabled == !enableMosaic).ForEach(_ =>
            {
                _.enabled = enableMosaic;
                System.Diagnostics.Debug.WriteLine(string.Format("{0}'s Mosaic Enable:{1}", _.name, enableMosaic));
                result = true;
            });

            return result;
        }

        public void DeMosaicToys()
        {
            Renderer[] rs = GetToysMosaicRenderer();
            if (rs != null)
            {
                foreach (Renderer r in rs)
                {
                    ToyMaterialChanger(r);
                }
            }
        }

        private void ToyMaterialChanger(Renderer mosaic)
        {
            if (mosaic.materials.Length == 1)
            {
                return;
            }
            bool mosaicDisable = Target >= DeMosaic.Switch.MaidAndItem;
            mosaic.materials
                .Where(_ => mosaicDisable ? _.shader.Equals(shaderMosaic) : _.shader.Equals(shaderTransparent))
                .ForEach(_ =>
                {
                    _.shader = mosaicDisable ? shaderTransparent : shaderMosaic;
                    _.color += mosaicDisable ? new Color(0f, 0f, 0f, -1f) : new Color(0f, 0f, 0f, 1f);
                });
        }
    }

    public class ChangeBodyTexture
    {
        public static List<string> textureList;
            public static readonly string path = Path.Combine(
                UnityInjector.Extensions.UserDataPath,
                "YASD"
                );

        public ChangeBodyTexture()
        {
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }

            textureList = new List<string>();
            LoadTextureList(textureList);
#if DEBUG
            foreach (var item in textureList)
            {
                System.Diagnostics.Debug.WriteLine(item);
            }
#endif
        }

        public class TextureSet
        {

            private const string diffuseType = "_MainTex";
            private const string toonType = "_ToonRamp";
            private const string shadowType = "_ShadowTex";
            private const string shadowRateToonType = "_ShadowRateToon";

            public Tex MainTex;
            public Tex Toon;
            public Tex Shadow;
            public Tex ShadowRateToon;

            public TextureSet(Material material, bool force)
            {
                MainTex = new Tex(diffuseType, material);
                if (!MainTex.IsReplaced || force)
                {
                    Toon = new Tex(toonType, material);
                    Shadow = new Tex(shadowType, material);
                    ShadowRateToon = new Tex(shadowRateToonType, material);
                }
            }

            public class Tex
            {
                private readonly Regex rx = new Regex(@"(?<name>[^:]+)\.tex");

                private Material material;

                private string _type;

                public string Type
                {
                    get { return _type; }
                }

                private Texture _texture;

                public Texture Texture
                {
                    get { return _texture; }
                }

                private string _name;

                public string Name
                {
                    get
                    {
                        return _name;
                    }
                }

                public string FullPath
                {
                    get { return Path.Combine(path, Name); }
                }

                public bool IsReplaced
                {
                    get { return Path.GetExtension(Texture.name).Equals(".png", System.StringComparison.OrdinalIgnoreCase); }
                }

                public Tex(String textureType, Material mate)
                {
                    this.material = mate;
                    _type = textureType;
                    _texture = material.GetTexture(Type);
                    Match m = rx.Match(this._texture.name);
                    if (m.Success)
                    {
                        _name = m.Groups["name"].Value + ".png";
                    }
                    else
                    {
                        _name = Texture.name;
                    }
                }

                public void ReplaceTex()
                {
                    System.Diagnostics.Debug.WriteLine(string.Format("YASD.ReplaceTex: Texture Name {0}", Texture.name));
                    if (!textureList.Any(_ => _.Equals(Name, StringComparison.OrdinalIgnoreCase)))
                    {
                        System.Diagnostics.Debug.WriteLine("YASD.ReplaceTex: FileName not Found in FileList");
                        return;
                    }
                    if (!Texture)
                    {
                        System.Diagnostics.Debug.WriteLine("YASD.ReplaceTex: Texture is NULL.");

                        return;
                    }
                    if (string.IsNullOrEmpty(Name))
                    {
                        System.Diagnostics.Debug.WriteLine("YASD.ReplaceTex: Texture's Name is NULL or Empty.");
                        return;
                    }

                    try
                    {
                        if (!File.Exists(FullPath))
                        {
                            textureList.Remove(Name);
                            return;
                        }
                        System.Diagnostics.Debug.WriteLine(string.Format("YASD.ReplaceTex: {0} found.", Name));

                        using (BinaryReader br = new BinaryReader(File.OpenRead(FullPath)))
                        {
                            byte[] b = br.ReadBytes((int)br.BaseStream.Length);

                            Texture2D t = new Texture2D(1, 1, TextureFormat.RGBA32, false);

                            if (t.LoadImage(b))
                            {
                                t.name = Name;
                                material.SetTexture(Type, t);
                                System.Diagnostics.Debug.WriteLine(string.Format("YASD.ReplaceTex: {0} Replaced.", Name));
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("YASD.ReplaceTex: Texture Replace Fail!{0} ({1})", Name, ex);
                        textureList.Remove(Name);
                    }
                }
            }

            public void ReplaceTexture(bool force)
            {
                if (!MainTex.IsReplaced || force)
                {
                    MainTex.ReplaceTex();
                    Toon.ReplaceTex();
                    Shadow.ReplaceTex();
                    ShadowRateToon.ReplaceTex();
                }
            }

        }
            public static void LoadTextureList(List<string> list)
            {
                list.Clear();
                list.AddRange(Directory.GetFiles(path, "*.png").Select(_ => Path.GetFileName(_)));

                Console.WriteLine("YASD: {0} Texture(s) found.", list.Count);
            }

        public void ChangeTexture(bool force)
        {
            GameObject maid = GameMain.Instance.CharacterMgr.GetMaid(0).gameObject;
            GameObject body = maid.transform.Find("Offset/_BO_body001/_SM_body001/body").gameObject;
            Material[] materials = body.renderer.materials;

            ////GetMaterialsの方がゲーム内で使われている手法に近くて汎用性が高いが1.5倍ぐらい遅い
            //Maid md = GameMain.Instance.CharacterMgr.GetMaid(0);
            //Material[] materials = GetMaterials(md, "body");

            foreach (var material in materials)
            {
                TextureSet tex = new TextureSet(material, force);

                if (Directory.Exists(path))
                {
                    tex.ReplaceTexture(force);
                }
            }
        }

        public Material[] GetMaterials(Maid maid, string slotname)
        {
            TBody tbody = maid.body0;
            TBodySkin skin = tbody.goSlot[(int)TBody.hashSlotName[slotname]];
            GameObject go = skin.obj;

            Renderer[] renderers = go.transform.GetComponentsInChildren<Renderer>(true);

            return renderers.Where(_ => _ != null || _.sharedMaterials != null).SelectMany(_ => _.materials).ToArray();
        }
    }
}