public static string[] FindAssetsInMods(string part, bool in_mod_link)
{
List <string> results = new List <string>();
foreach (var package in CapsPackageEditor.Packages.Keys)
{
var root = "Packages/" + package + "/";
var src = root + part;
if (System.IO.File.Exists(src))
{
results.Add(src);
}
}
var mods = CapsModEditor.GetAllMods();
for (int i = 0; i < mods.Length; ++i)
{
var root = "Assets/Mods/" + mods[i];
if (in_mod_link)
{
root += "/Link/";
}
else
{
root += "/";
}
var src = root + part;
if (System.IO.File.Exists(src))
{
results.Add(src);
}
}
return(results.ToArray());
}
public void SaveDistributeFlags()
{
var old = ResManager.PreRuntimeDFlags;
bool changed = old.Count != DistributeFlagOrder.Count;
if (!changed)
{
int index = 0;
foreach (var flag in DistributeFlagOrder)
{
if (old[index++] != flag)
{
changed = true;
break;
}
}
}
if (changed)
{
AssetDatabase.SaveAssets();
System.Text.StringBuilder sbflags = new System.Text.StringBuilder();
foreach (var oflag in DistributeFlagOrder)
{
sbflags.Append("<");
sbflags.Append(oflag);
}
var path = CapsDistributeEditor.GetDistributeFlagsFilePath();
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(path));
System.IO.File.WriteAllText(path, sbflags.ToString());
AssetDatabase.ImportAsset(CapsModEditor.GetAssetNameFromPath(path));
ResManager.PreRuntimeDFlags = new List <string>(DistributeFlagOrder);
CapsDistributeEditor.FireOnDistributeFlagsChanged();
}
}
public static string GetAssetNameFromPath(string path)
{
var file = path;
var package = CapsModEditor.GetPackageNameFromPath(file);
if (string.IsNullOrEmpty(package))
{
var rootdir = System.Environment.CurrentDirectory;
if (file.StartsWith(rootdir, System.StringComparison.InvariantCultureIgnoreCase))
{
file = file.Substring(rootdir.Length).TrimStart('/', '\\');
}
else
{
return(null);
}
//var iassets = file.IndexOf("Assets/");
//if (iassets > 0)
//{
// file = file.Substring(iassets);
//}
file = file.Replace('\\', '/');
return(file);
}
else
{
var rootdir = CapsModEditor.GetPackageRoot(package);
file = file.Substring(rootdir.Length).TrimStart('/', '\\');
file = file.Replace('\\', '/');
file = "Packages/" + package + "/" + file;
return(file);
}
}
private static Dictionary <string, Dictionary <string, FontReplacement> > GetFontReplacementDMFDict(string fname)
{
// dist -> mod -> FontReplacement
Dictionary <string, Dictionary <string, FontReplacement> > dmfr = new Dictionary <string, Dictionary <string, FontReplacement> >();
List <FontReplacement> list;
if (_FontReplacements.TryGetValue(fname, out list))
{
for (int i = 0; i < list.Count; ++i)
{
var info = list[i];
var mod = info.Mod ?? "";
var dist = info.Dist ?? "";
// check critical mod
var moddesc = ResManager.GetDistributeDesc(mod);
var inPackage = (info.DescAssetPath ?? "").StartsWith("Packages/");
bool isMainPackage = inPackage && !CapsModEditor.ShouldTreatPackageAsMod(CapsModEditor.GetPackageName(mod));
if (moddesc == null || !moddesc.IsOptional || isMainPackage)
{
mod = "";
}
Dictionary <string, FontReplacement> mdict;
if (!dmfr.TryGetValue(dist, out mdict))
{
mdict = new Dictionary <string, FontReplacement>();
dmfr[dist] = mdict;
}
mdict[mod] = info;
}
}
return(dmfr);
}
public static List <string> ParseHotFixList()
{
List <string> list = new List <string>();
var prelists = CapsModEditor.FindAssetsInMods("LuaHotFix/MemberList.txt");
foreach (var listfile in prelists)
{
using (var sr = PlatDependant.OpenReadText(listfile))
{
while (true)
{
var line = sr.ReadLine();
if (line == null)
{
break;
}
if (!string.IsNullOrEmpty(line))
{
if (line.StartsWith("--"))
{
}
else
{
list.Add(line);
}
}
}
}
}
return(list);
}
public static string[] GetAllDistributes()
{
List <string> dflags = new List <string>();
HashSet <string> setflags = new HashSet <string>();
var subflags = GetDistributesInMod("");
for (int j = 0; j < subflags.Length; ++j)
{
var subflag = subflags[j];
if (setflags.Add(subflag))
{
dflags.Add(subflag);
}
}
var mods = CapsModEditor.GetAllModsOrPackages();
for (int i = 0; i < mods.Length; ++i)
{
subflags = GetDistributesInMod(mods[i]);
for (int j = 0; j < subflags.Length; ++j)
{
var subflag = subflags[j];
if (setflags.Add(subflag))
{
dflags.Add(subflag);
}
}
}
return(dflags.ToArray());
}
public static string[] GetOptionalDistributes()
{
HashSet <string> flags = new HashSet <string>(GetAllDistributes());
flags.UnionWith(CapsModEditor.GetOptionalMods());
var arrflags = flags.ToArray();
Array.Sort(arrflags);
return(arrflags);
}
public CapsEditorInitializer_ResManager()
{
ResManagerEditorEntry.ShouldAlreadyInit();
CapsModEditor.ShouldAlreadyInit();
CapsPackageEditor.OnPackagesChanged += OnPackagesChanged;
CapsDistributeEditor.OnDistributeFlagsChanged += OnDistributeFlagsChanged;
//CapsDistributeEditor.OnDistributeFlagsChanged += CapsModEditor.CheckModsVisibility;
//CapsDistributeEditor.OnDistributeFlagsChanged += UnityEngineEx.ResManager.RebuildRuntimeResCache;
}
public static void UpdateFix()
{
EditorApplication.LockReloadAssemblies();
// Update all package...
foreach (var mod in CapsModEditor.GetAllModsInPackage())
{
var pname = CapsModEditor.GetPackageName(mod);
AssetDatabase.ImportAsset("Packages/" + pname, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ImportRecursive);
}
EditorApplication.UnlockReloadAssemblies();
}
public static void CheckDefaultSelectedDistributeFlags()
{
var path = GetDistributeFlagsFilePath();
if (!System.IO.File.Exists(path))
{
var src = CapsModEditor.FindAssetInMods("DefaultDistributeFlags.txt", true);
if (src != null && System.IO.File.Exists(src))
{
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(path));
System.IO.File.Copy(src, path);
AssetDatabase.ImportAsset(path);
return;
}
}
}
void OnGUI()
{
GUILayout.BeginVertical();
GUILayout.Label("Which precompiler symbol would you like to define?");
_Symbol = GUILayout.TextField(_Symbol);
if (GUILayout.Button("OK"))
{
if (string.IsNullOrEmpty(_Symbol))
{
EditorUtility.DisplayDialog("Error", "Empty Symbol!", "OK");
}
else if (_Symbol.EndsWith("_"))
{
EditorUtility.DisplayDialog("Error", "Symbol should not end with _", "OK");
}
else
{
if (System.IO.Directory.Exists("Assets/Mods/" + _Symbol))
{
EditorUtility.DisplayDialog("Warning", "It seems that the mod has been already created.", "OK");
}
else
{
var descdir = "Assets/Mods/" + _Symbol + "/Resources";
System.IO.Directory.CreateDirectory(descdir);
AssetDatabase.ImportAsset(descdir);
var desc = ScriptableObject.CreateInstance <CapsModDesc>();
desc.Mod = _Symbol;
AssetDatabase.CreateAsset(desc, "Assets/Mods/" + _Symbol + "/Resources/resdesc.asset");
var sympath = "Assets/Mods/" + _Symbol + "/Link/mcs.rsp";
using (var sw = PlatDependant.OpenWriteText(sympath))
{
sw.Write("-define:");
sw.WriteLine(_Symbol);
}
CapsModEditor.CheckModsVisibility();
DistributeSelectWindow.Init();
}
Close();
}
}
GUILayout.EndVertical();
}
public static string[] GetDistributesInMod(string mod)
{
List <string> dflags = new List <string>();
HashSet <string> setflags = new HashSet <string>();
Action <string> checkDir = pathc =>
{
if (System.IO.Directory.Exists(pathc))
{
var dirs = System.IO.Directory.GetDirectories(pathc);
foreach (var dir in dirs)
{
var path = System.IO.Path.GetFileName(dir);
if (setflags.Add(path))
{
dflags.Add(path);
}
}
}
};
Action <string> checkSub = sub =>
{
if (string.IsNullOrEmpty(mod))
{
checkDir("Assets" + sub);
}
else
{
var proot = CapsModEditor.GetModRootInPackage(mod);
if (!string.IsNullOrEmpty(proot))
{
checkDir(proot + sub);
}
checkDir("Assets/Mods/" + mod + sub);
}
};
checkSub("/CapsRes/dist/");
checkSub("/CapsSpt/dist/");
checkSub("/Resources/dist/");
return(dflags.ToArray());
}
static CapsPHFontEditor()
{
if (PlatDependant.IsFileExist("EditorOutput/Runtime/phfont.txt"))
{
ParseCachedPHFonts();
if (CheckCachedPHFonts())
{
SaveCachedPHFonts();
}
}
else
{
CheckAllPHFonts();
SaveCachedPHFonts();
}
CapsModEditor.ShouldAlreadyInit();
CapsPackageEditor.OnPackagesChanged += () =>
{
if (PlatDependant.IsFileExist("EditorOutput/Runtime/rfont.txt"))
{
if (LoadCachedReplacement())
{
SaveCachedReplacement();
}
}
else
{
CheckAllReplacements();
SaveCachedReplacement();
}
ReplaceRuntimePHFonts();
};
CapsDistributeEditor.OnDistributeFlagsChanged += ReplaceRuntimePHFonts;
}
public EditorWorkProgressShowerInConsole()
{
#if UNITY_EDITOR_WIN
var pipeName = System.DateTime.Now.ToString("yyMMddHHmmss");
var pipeout = new System.IO.Pipes.NamedPipeServerStream("ProgressShowerInConsole" + pipeName, System.IO.Pipes.PipeDirection.Out);
var pipein = new System.IO.Pipes.NamedPipeServerStream("ProgressShowerInConsoleControl" + pipeName, System.IO.Pipes.PipeDirection.In);
var arout = pipeout.BeginWaitForConnection(null, null);
var arin = pipein.BeginWaitForConnection(null, null);
var dir = Application.dataPath + "/../";
var tooldir = CapsModEditor.GetPackageOrModRoot(CapsEditorUtils.__MOD__) + "/~Tools~/";
System.Diagnostics.ProcessStartInfo si = new System.Diagnostics.ProcessStartInfo(tooldir + "ProgressShowerInConsole.exe", pipeName);
si.WorkingDirectory = tooldir;
_ExProc = System.Diagnostics.Process.Start(si);
var thd_Write = new System.Threading.Thread(() =>
{
try
{
pipeout.EndWaitForConnection(arout);
var sw = new System.IO.StreamWriter(pipeout);
while (_MessageReady.WaitOne())
{
_MessageReady.Reset();
lock (_MessageQueue)
{
foreach (var line in _MessageQueue)
{
sw.WriteLine(line);
}
sw.Flush();
_MessageQueue.Clear();
}
}
}
finally
{
pipeout.Dispose();
}
});
thd_Write.Start();
var thd_Read = new System.Threading.Thread(() =>
{
try
{
pipein.EndWaitForConnection(arin);
var sr = new System.IO.StreamReader(pipein);
while (!_ExProc.HasExited)
{
var line = sr.ReadLine();
if (line != null)
{
if (line == "\uEE05Quit")
{
break;
}
}
}
}
finally
{
_ShouldQuit = true;
thd_Write.Abort();
_MessageReady.Set();
pipein.Dispose();
}
});
thd_Read.Start();
#endif
}
public static IEnumerator GenerateBuildWorkAsync(Dictionary <string, CapsResBuildWork> result, IList <string> assets, IEditorWorkProgressShower winprog, IList <IResBuilderEx> runOnceExBuilder)
{
var logger = new EditorWorkProgressLogger()
{
Shower = winprog
};
logger.Log("(Start) Generate Build Work.");
if (winprog != null && AsyncWorkTimer.Check())
{
yield return(null);
}
if (result == null)
{
logger.Log("(Error) You have to provide container to retrive the result.");
yield break;
}
result.Clear();
if (assets == null)
{
logger.Log("(Option) Get All Assets.");
assets = AssetDatabase.GetAllAssetPaths();
if (winprog != null && AsyncWorkTimer.Check())
{
yield return(null);
}
}
if (assets != null)
{
List <IResBuilderEx> allExBuilders = new List <IResBuilderEx>(ResBuilderEx);
if (runOnceExBuilder != null)
{
allExBuilders.AddRange(runOnceExBuilder);
}
Dictionary <string, Dictionary <string, List <string> > > mod2build = new Dictionary <string, Dictionary <string, List <string> > >();
Dictionary <string, Dictionary <string, CapsResManifest> > mod2mani = new Dictionary <string, Dictionary <string, CapsResManifest> >();
for (int i = 0; i < assets.Count; ++i)
{
if (winprog != null && AsyncWorkTimer.Check())
{
yield return(null);
}
var asset = assets[i];
logger.Log(asset);
if (string.IsNullOrEmpty(asset))
{
logger.Log("Empty Path.");
continue;
}
if (System.IO.Directory.Exists(asset))
{
logger.Log("Folder.");
continue;
}
if (CapsResInfoEditor.IsAssetScript(asset))
{
logger.Log("Script.");
continue;
}
string mod = null;
string opmod = null;
string dist = null;
string norm = asset;
bool inPackage = false;
if (asset.StartsWith("Assets/Mods/") || (inPackage = asset.StartsWith("Packages/")))
{
string sub;
if (inPackage)
{
sub = asset.Substring("Packages/".Length);
}
else
{
sub = asset.Substring("Assets/Mods/".Length);
}
var index = sub.IndexOf('/');
if (index < 0)
{
logger.Log("Cannot Parse Module.");
continue;
}
mod = sub.Substring(0, index);
if (inPackage)
{
mod = CapsModEditor.GetPackageModName(mod);
}
if (string.IsNullOrEmpty(mod))
{
logger.Log("Empty Module.");
continue;
}
sub = sub.Substring(index + 1);
if (!sub.StartsWith("CapsRes/"))
{
logger.Log("Should Ignore This Asset.");
continue;
}
var moddesc = ResManager.GetDistributeDesc(mod);
bool isMainPackage = inPackage && !CapsModEditor.ShouldTreatPackageAsMod(CapsModEditor.GetPackageName(mod));
if (moddesc == null || moddesc.InMain || isMainPackage)
{
mod = "";
if (moddesc != null && moddesc.IsOptional && !isMainPackage)
{
opmod = moddesc.Mod;
}
}
sub = sub.Substring("CapsRes/".Length);
norm = sub;
if (sub.StartsWith("dist/"))
{
sub = sub.Substring("dist/".Length);
index = sub.IndexOf('/');
if (index > 0)
{
dist = sub.Substring(0, index);
norm = sub.Substring(index + 1);
}
}
}
else
{
if (asset.StartsWith("Assets/CapsRes/"))
{
mod = "";
var sub = asset.Substring("Assets/CapsRes/".Length);
norm = sub;
if (sub.StartsWith("dist/"))
{
sub = sub.Substring("dist/".Length);
var index = sub.IndexOf('/');
if (index > 0)
{
dist = sub.Substring(0, index);
norm = sub.Substring(index + 1);
}
}
}
else
{
logger.Log("Should Ignore This Asset.");
continue;
}
}
if (string.IsNullOrEmpty(norm))
{
logger.Log("Normallized Path Empty.");
continue;
}
mod = mod ?? "";
dist = dist ?? "";
logger.Log("Mod " + mod + "; Dist " + dist + "; Norm " + norm);
Dictionary <string, List <string> > builds;
if (!mod2build.TryGetValue(mod, out builds))
{
builds = new Dictionary <string, List <string> >();
mod2build[mod] = builds;
}
Dictionary <string, CapsResManifest> manis;
if (!mod2mani.TryGetValue(opmod ?? mod, out manis))
{
manis = new Dictionary <string, CapsResManifest>();
mod2mani[opmod ?? mod] = manis;
}
CapsResManifest mani;
if (!manis.TryGetValue(dist, out mani))
{
mani = new CapsResManifest();
mani.MFlag = opmod ?? mod;
mani.DFlag = dist;
if (opmod != null)
{
mani.InMain = true;
}
manis[dist] = mani;
}
string bundle = null;
bool shouldWriteBRef = false;
for (int j = 0; j < allExBuilders.Count; ++j)
{
bundle = allExBuilders[j].FormatBundleName(asset, opmod ?? mod, dist, norm);
if (bundle != null)
{
break;
}
}
if (bundle == null)
{
bundle = FormatBundleName(asset, opmod ?? mod, dist, norm);
}
else
{
shouldWriteBRef = true;
}
List <string> build;
if (!builds.TryGetValue(bundle, out build))
{
build = new List <string>();
builds[bundle] = build;
}
build.Add(asset);
var node = mani.AddOrGetItem(asset);
for (int j = 0; j < allExBuilders.Count; ++j)
{
if (allExBuilders[j].CreateItem(node))
{
break;
}
}
if (node.Item == null)
{
var item = new CapsResManifestItem(node);
if (asset.EndsWith(".prefab"))
{
item.Type = (int)CapsResManifestItemType.Prefab;
}
else if (asset.EndsWith(".unity"))
{
item.Type = (int)CapsResManifestItemType.Scene;
}
else
{
item.Type = (int)CapsResManifestItemType.Normal;
}
if (shouldWriteBRef)
{
item.BRef = bundle;
}
node.Item = item;
}
for (int j = 0; j < allExBuilders.Count; ++j)
{
allExBuilders[j].ModifyItem(node.Item);
}
}
if (winprog != null && AsyncWorkTimer.Check())
{
yield return(null);
}
logger.Log("(Phase) Combine the final result.");
foreach (var kvpbuild in mod2build)
{
var mod = kvpbuild.Key;
var builds = kvpbuild.Value;
CapsResBuildWork work = new CapsResBuildWork();
if (mod == "")
{
List <CapsResManifest> manis = new List <CapsResManifest>(mod2mani[mod].Values);
foreach (var kvpmm in mod2mani)
{
if (!mod2build.ContainsKey(kvpmm.Key))
{
manis.AddRange(kvpmm.Value.Values);
}
}
work.Manifests = manis.ToArray();
}
else
{
work.Manifests = mod2mani[mod].Values.ToArray();
}
work.ABs = new AssetBundleBuild[builds.Count];
int index = 0;
foreach (var kvpbundle in builds)
{
var bundleName = kvpbundle.Key;
var bundleAssets = kvpbundle.Value;
AssetBundleBuild build = new AssetBundleBuild();
build.assetBundleName = kvpbundle.Key;
build.assetNames = kvpbundle.Value.ToArray();
for (int j = 0; j < allExBuilders.Count; ++j)
{
allExBuilders[j].GenerateBuildWork(bundleName, bundleAssets, ref build, work, index);
}
work.ABs[index++] = build;
}
result[mod] = work;
}
}
logger.Log("(Done) Generate Build Work.");
}
public static void CheckRes(string output)
{
// generate build work
List <CapsResBuilder.IResBuilderEx> allExBuilders = CapsResBuilder.ResBuilderEx;
for (int i = 0; i < allExBuilders.Count; ++i)
{
allExBuilders[i].Prepare(null);
}
Dictionary <string, CapsResBuilder.CapsResBuildWork> buildwork = new Dictionary <string, CapsResBuilder.CapsResBuildWork>();
var gwork = CapsResBuilder.GenerateBuildWorkAsync(buildwork, null, null);
while (gwork.MoveNext())
{
;
}
for (int i = 0; i < allExBuilders.Count; ++i)
{
allExBuilders[i].Cleanup();
}
// parse asset list in each reskey (m-XXX-d-YYY)
Dictionary <string, List <string> > reskey2assetlist = new Dictionary <string, List <string> >();
Dictionary <string, string> asset2reskey = new Dictionary <string, string>();
HashSet <string> nodepassets = new HashSet <string>();
foreach (var buildmodwork in buildwork)
{
var mod = buildmodwork.Key;
var work = buildmodwork.Value;
var manifests = work.Manifests;
for (int i = 0; i < manifests.Length; ++i)
{
var mani = manifests[i];
var opmod = mani.MFlag;
var dist = mani.DFlag ?? "";
var reskey = "m-" + opmod + "-d-" + dist;
List <string> list;
if (!reskey2assetlist.TryGetValue(reskey, out list))
{
list = new List <string>();
reskey2assetlist[reskey] = list;
}
for (int j = 0; j < work.ABs.Length; ++j)
{
var abinfo = work.ABs[j];
var abname = abinfo.assetBundleName;
if (abname.EndsWith(".=.ab"))
{
for (int k = 0; k < abinfo.assetNames.Length; ++k)
{
var asset = abinfo.assetNames[k];
nodepassets.Add(asset);
}
continue;
}
if (!string.IsNullOrEmpty(abinfo.assetBundleVariant))
{
abname += "." + abinfo.assetBundleVariant;
}
if (CapsResBuilder.IsBundleInModAndDist(abname, opmod, dist))
{
list.AddRange(abinfo.assetNames);
for (int k = 0; k < abinfo.assetNames.Length; ++k)
{
var asset = abinfo.assetNames[k];
asset2reskey[asset] = reskey;
}
}
}
}
}
// parse dep and ref
Dictionary <string, HashSet <string> > resdep = new Dictionary <string, HashSet <string> >();
Dictionary <string, HashSet <string> > resref = new Dictionary <string, HashSet <string> >();
foreach (var kvpassetreskey in asset2reskey)
{
var asset = kvpassetreskey.Key;
//var reskey = kvpassetreskey.Value;
HashSet <string> deplist;
if (!resdep.TryGetValue(asset, out deplist))
{
deplist = new HashSet <string>();
resdep[asset] = deplist;
}
var deps = GetDependencies(asset);
for (int i = 0; i < deps.Length; ++i)
{
var dep = deps[i];
deplist.Add(dep);
HashSet <string> reflist;
if (!resref.TryGetValue(dep, out reflist))
{
reflist = new HashSet <string>();
resref[dep] = reflist;
}
reflist.Add(asset);
}
}
using (var sw = PlatDependant.OpenWriteText(output))
{
// check cross mod/dist ref
bool crossdepfound = false;
foreach (var kvpdep in resdep)
{
var asset = kvpdep.Key;
var deps = kvpdep.Value;
var assetkey = asset2reskey[asset];
foreach (var dep in deps)
{
if (!asset2reskey.ContainsKey(dep))
{
continue; // not in build? check later.
}
var depkey = asset2reskey[dep];
if (assetkey == depkey)
{
continue; // the same package
}
else if (depkey == "m--d-")
{
continue; // any asset can refer the assets in main package.
}
else if (depkey.EndsWith("-d-") && assetkey.StartsWith(depkey))
{
continue; // the dist package refer non-dist package.
}
else if (depkey.StartsWith("m--d-") && assetkey.EndsWith(depkey.Substring(2)))
{
continue; // the mod package refer non-mod package.
}
else
{
if (!crossdepfound)
{
crossdepfound = true;
sw.WriteLine("Cross mod/dist reference found! See below:");
}
sw.Write(asset);
sw.Write(" (");
sw.Write(assetkey);
sw.Write(") -> ");
sw.Write(dep);
sw.Write(" (");
sw.Write(depkey);
sw.Write(")");
sw.WriteLine();
}
}
}
if (!crossdepfound)
{
sw.WriteLine("No cross mod/dist reference found.");
}
// check non build dep
sw.WriteLine();
bool nonbuilddepfound = false;
foreach (var kvpdep in resdep)
{
var asset = kvpdep.Key;
var deps = kvpdep.Value;
foreach (var dep in deps)
{
if (!asset2reskey.ContainsKey(dep) && !nodepassets.Contains(dep))
{
if (dep.StartsWith("Assets/") || dep.StartsWith("Packages/") && !string.IsNullOrEmpty(CapsModEditor.GetAssetModName(dep)))
{
if (!nonbuilddepfound)
{
nonbuilddepfound = true;
sw.WriteLine("Non build dependency found! See below:");
}
sw.Write(asset);
sw.Write(" -> ");
sw.Write(dep);
sw.WriteLine();
}
}
}
}
if (!nonbuilddepfound)
{
sw.WriteLine("No non build dependency found.");
}
}
EditorUtility.OpenWithDefaultApp(output);
}
private static void OnDistributeFlagsChanged()
{
CapsModEditor.CheckModsVisibility();
UnityEngineEx.ResManager.RebuildRuntimeResCache();
}
private static void OnPackagesChanged()
{
CapsDistributeEditor.CheckDefaultSelectedDistributeFlags();
CapsModEditor.CheckModsAndMakeLink();
UnityEngineEx.ResManager.RebuildRuntimeResCache();
}
public static void CreatePlaceHolderFont()
{
var srcpath = CapsModEditor.GetPackageOrModRoot(CapsEditorUtils.__MOD__);
srcpath += "/~Tools~/CapstonesPlaceHolder.otf";
if (PlatDependant.IsFileExist(srcpath))
{
var sids = Selection.instanceIDs;
if (sids != null && sids.Length > 0)
{
bool found = false;
int fid = 0;
for (int i = sids.Length - 1; i >= 0; --i)
{
var sid = sids[i];
if (ProjectWindowUtil.IsFolder(sid))
{
fid = sid;
found = true;
break;
}
}
string folder;
if (!found)
{
folder = ProjectWindowUtil.GetContainingFolder(AssetDatabase.GetAssetPath(EditorUtility.InstanceIDToObject(sids[0])));
}
else
{
folder = AssetDatabase.GetAssetPath(EditorUtility.InstanceIDToObject(fid));
}
var asset = folder;
folder = CapsModEditor.GetAssetPath(folder); // this seems to be useless. Unity's System.IO lib can handle path like Packages/cn.capstones.phfont/xxx
string fontName = "";
string fileName;
for (int i = 1; i <= 99999; ++i)
{
fontName = "CapstonesPHFont" + i.ToString("00000");
if (!_PHFontNameToAssetName.ContainsKey(fontName))
{
break;
}
}
fileName = fontName;
if (PlatDependant.IsFileExist(folder + "/" + fileName + ".otf"))
{
for (int i = 0; ; ++i)
{
fileName = fontName + "_" + i;
if (!PlatDependant.IsFileExist(folder + "/" + fileName + ".otf"))
{
break;
}
}
}
PlatDependant.CopyFile(srcpath, folder + "/" + fileName + ".otf");
// Modify the otf file.
using (var stream = PlatDependant.OpenAppend(folder + "/" + fileName + ".otf"))
{
stream.Seek(0x3cc, System.IO.SeekOrigin.Begin);
var buffer = System.Text.Encoding.ASCII.GetBytes(fontName);
stream.Write(buffer, 0, buffer.Length);
stream.Seek(0x4d0, System.IO.SeekOrigin.Begin);
buffer = System.Text.Encoding.BigEndianUnicode.GetBytes(fontName);
stream.Write(buffer, 0, buffer.Length);
}
AssetDatabase.ImportAsset(asset + "/" + fileName + ".otf");
PlatDependant.CopyFile(asset + "/" + fileName + ".otf", asset + "/" + fileName + ".otf.~");
PlatDependant.CopyFile(asset + "/" + fileName + ".otf.meta", asset + "/" + fileName + ".otf.meta.~");
AssetDatabase.CreateAsset(ScriptableObject.CreateInstance <CapsPHFontDesc>(), asset + "/" + fileName + ".phf.asset");
AssetDatabase.ImportAsset(asset + "/" + fileName + ".phf.asset");
AddPHFont(asset + "/" + fileName + ".phf.asset");
SaveCachedPHFonts();
}
}
}
public static void CreateFontReplacement()
{
var sids = Selection.instanceIDs;
if (sids != null && sids.Length > 0)
{
bool found = false;
Font selectedFont = null;
int fid = 0;
for (int i = sids.Length - 1; i >= 0; --i)
{
var sid = sids[i];
var obj = EditorUtility.InstanceIDToObject(sid);
if (obj is Font)
{
var font = obj as Font;
try
{
var fi = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(font)) as TrueTypeFontImporter;
if (fi != null)
{
if (!_PHFontNameToAssetName.ContainsKey(fi.fontTTFName))
{
selectedFont = font;
break;
}
}
}
catch { }
}
}
for (int i = sids.Length - 1; i >= 0; --i)
{
var sid = sids[i];
if (ProjectWindowUtil.IsFolder(sid))
{
fid = sid;
found = true;
break;
}
}
string folder;
if (!found)
{
folder = ProjectWindowUtil.GetContainingFolder(AssetDatabase.GetAssetPath(EditorUtility.InstanceIDToObject(sids[0])));
}
else
{
folder = AssetDatabase.GetAssetPath(EditorUtility.InstanceIDToObject(fid));
}
var asset = folder;
folder = CapsModEditor.GetAssetPath(folder); // this seems to be useless. Unity's System.IO lib can handle path like Packages/cn.capstones.phfont/xxx
var desc = ScriptableObject.CreateInstance <CapsFontReplacement>();
desc.PlaceHolderFontName = GetFontReplacementPHFontName(asset) ?? "CapstonesPHFont00000";
desc.SubstituteFont = selectedFont;
var fileName = "FontReplacement";
if (PlatDependant.IsFileExist(folder + "/" + fileName + ".fr.asset"))
{
for (int i = 0; ; ++i)
{
fileName = "FontReplacement" + i;
if (!PlatDependant.IsFileExist(folder + "/" + fileName + ".fr.asset"))
{
break;
}
}
}
AssetDatabase.CreateAsset(desc, asset + "/" + fileName + ".fr.asset");
AssetDatabase.ImportAsset(asset + "/" + fileName + ".fr.asset");
}
}
public static void SetCurrentAtlasProperties(string profile)
{
var path = CapsModEditor.FindAssetInMods("AtlasTemplate_" + profile + ".spriteatlas");
if (path != null)
{
var template = AssetDatabase.LoadAssetAtPath <UnityEngine.U2D.SpriteAtlas>(path);
if (template != null)
{
var selections = Selection.assetGUIDs;
if (selections != null)
{
for (int i = 0; i < selections.Length; ++i)
{
var sel = selections[i];
var atlaspath = AssetDatabase.GUIDToAssetPath(sel);
if (atlaspath != null)
{
var atlas = AssetDatabase.LoadAssetAtPath <UnityEngine.U2D.SpriteAtlas>(atlaspath);
if (atlas)
{
UnityEditor.U2D.SpriteAtlasExtensions.SetIncludeInBuild(atlas, false);
UnityEditor.U2D.SpriteAtlasExtensions.SetPackingSettings(atlas, UnityEditor.U2D.SpriteAtlasExtensions.GetPackingSettings(template));
UnityEditor.U2D.SpriteAtlasExtensions.SetTextureSettings(atlas, UnityEditor.U2D.SpriteAtlasExtensions.GetTextureSettings(template));
UnityEditor.U2D.SpriteAtlasExtensions.SetPlatformSettings(atlas, UnityEditor.U2D.SpriteAtlasExtensions.GetPlatformSettings(template, "DefaultTexturePlatform"));
var buildTargetNames = Enum.GetNames(typeof(BuildTargetGroup));
for (int j = 0; j < buildTargetNames.Length; ++j)
{
var platsettings = UnityEditor.U2D.SpriteAtlasExtensions.GetPlatformSettings(template, buildTargetNames[j]);
if (platsettings != null && platsettings.overridden)
{
UnityEditor.U2D.SpriteAtlasExtensions.SetPlatformSettings(atlas, platsettings);
BuildTargetGroup bgroup;
Enum.TryParse(buildTargetNames[j], out bgroup);
for (int k = 0; k < buildTargetNames.Length; ++k)
{
BuildTargetGroup bgroupcur;
Enum.TryParse(buildTargetNames[k], out bgroupcur);
if (bgroup == bgroupcur)
{
BuildTarget btar;
if (Enum.TryParse(buildTargetNames[k], out btar))
{
Debug.LogFormat("Now packing {0} on {1}.", atlas.name, btar);
UnityEditor.U2D.SpriteAtlasUtility.PackAtlases(new UnityEngine.U2D.SpriteAtlas[] { atlas }, btar, false);
Debug.LogFormat("Packing done {0} on {1}.", atlas.name, btar);
}
}
}
}
}
RenameAtlasName(atlaspath);
}
}
}
}
}
}
else
{
Debug.LogError("Please create AtlasTemplate_" + profile + ".spriteatlas in any mod folder.");
}
}
