private static void BackupMaterialWithTests(Material m)
{
string guid = UnityHelper.GetGUID(m);
string backedup_shader_name = FileHelper.LoadValueFromFile(guid, PATH.MATERIALS_BACKUP_FILE);
if (m == null)
{
return;
}
if (MaterialShaderBroken(m))
{
return;
}
if (backedup_shader_name == m.shader.name)
{
return;
}
string default_shader_name = ShaderHelper.getDefaultShaderName(m.shader.name);
if (default_shader_name.Equals(backedup_shader_name))
{
return;
}
FileHelper.SaveValueToFile(guid, default_shader_name, PATH.MATERIALS_BACKUP_FILE);
}
private static void BackupMaterial(Material m)
{
if (restoring_in_progress)
{
return;
}
if (!MaterialShaderBroken(m))
{
FileHelper.SaveValueToFile(UnityHelper.GetGUID(m), ShaderHelper.getDefaultShaderName(m.shader.name), PATH.MATERIALS_BACKUP_FILE);
}
}
public static void backupSingleMaterial(Material m)
{
if (restoring_in_progress)
{
return;
}
string[] mats = new string[0];
if (!File.Exists(PATH.MATERIALS_BACKUP_FILE))
{
File.CreateText(PATH.MATERIALS_BACKUP_FILE).Close();
}
else
{
mats = FileHelper.ReadFileIntoString(PATH.MATERIALS_BACKUP_FILE).Split(new string[] { "\n" }, System.StringSplitOptions.None);
}
bool updated = false;
string matGuid = AssetDatabase.AssetPathToGUID(AssetDatabase.GetAssetPath(m.GetInstanceID()));
string newString = "";
for (int mat = 0; mat < mats.Length; mat++)
{
if (mats[mat].Contains(matGuid))
{
updated = true;
newString += matGuid + ":" + ShaderHelper.getDefaultShaderName(m.shader.name) + ":" + m.renderQueue + "\r\n";
}
else
{
newString += mats[mat] + "\n";
}
}
if (!updated)
{
newString += matGuid + ":" + ShaderHelper.getDefaultShaderName(m.shader.name) + ":" + m.renderQueue;
}
else
{
newString = newString.Substring(0, newString.LastIndexOf("\n"));
}
FileHelper.WriteStringToFile(newString, PATH.MATERIALS_BACKUP_FILE);
}
public static void BackupAllMaterials()
{
if (restoring_in_progress)
{
return;
}
EditorUtility.DisplayProgressBar("Backup materials", "", 0);
Dictionary <string, string> materials_to_backup = new Dictionary <string, string>();
string[] materialGuids = AssetDatabase.FindAssets("t:material");
for (int mG = 0; mG < materialGuids.Length; mG++)
{
Material material = AssetDatabase.LoadAssetAtPath <Material>(AssetDatabase.GUIDToAssetPath(materialGuids[mG]));
if (!MaterialShaderBroken(material))
{
materials_to_backup[materialGuids[mG]] = ShaderHelper.getDefaultShaderName(material.shader.name);
}
EditorUtility.DisplayProgressBar("Backup materials", material.name, (float)(mG + 1) / materialGuids.Length);
}
FileHelper.SaveDictionaryToFile(PATH.MATERIALS_BACKUP_FILE, materials_to_backup);
EditorUtility.ClearProgressBar();
}
//save mats
public static void backupAllMaterials()
{
if (restoring_in_progress)
{
return;
}
if (!File.Exists(PATH.MATERIALS_BACKUP_FILE))
{
File.CreateText(PATH.MATERIALS_BACKUP_FILE).Close();
}
EditorUtility.DisplayProgressBar("Backup materials", "", 0);
StreamWriter writer = new StreamWriter(PATH.MATERIALS_BACKUP_FILE, false);
string[] materialGuids = AssetDatabase.FindAssets("t:material");
for (int mG = 0; mG < materialGuids.Length; mG++)
{
Material material = AssetDatabase.LoadAssetAtPath <Material>(AssetDatabase.GUIDToAssetPath(materialGuids[mG]));
writer.WriteLine(materialGuids[mG] + ":" + ShaderHelper.getDefaultShaderName(material.shader.name) + ":" + material.renderQueue);
EditorUtility.DisplayProgressBar("Backup materials", "", (float)(mG + 1) / materialGuids.Length);
}
writer.Close();
EditorUtility.ClearProgressBar();
}
void OnGUI()
{
scrollPos = GUILayout.BeginScrollView(scrollPos);
bool init = false;
if (paths == null)
{
paths = new List <string>();
shaders = new List <Shader>();
differentQueueShaderPaths = new Dictionary <string, List <string> >();
string[] shaderGuids = AssetDatabase.FindAssets("t:shader");
for (int sguid = 0; sguid < shaderGuids.Length; sguid++)
{
string path = AssetDatabase.GUIDToAssetPath(shaderGuids[sguid]);
Shader shader = AssetDatabase.LoadAssetAtPath <Shader>(path);
if (!path.Contains("_differentQueues/"))
{
paths.Add(path);
shaders.Add(shader);
}
else
{
List <string> differentQueueShaderPaths;
this.differentQueueShaderPaths.TryGetValue(ShaderHelper.getDefaultShaderName(shader.name), out differentQueueShaderPaths);
if (differentQueueShaderPaths == null)
{
differentQueueShaderPaths = new List <string>();
this.differentQueueShaderPaths.Add(ShaderHelper.getDefaultShaderName(shader.name), differentQueueShaderPaths);
}
differentQueueShaderPaths.Add(path);
}
}
if (setEditor == null || setEditor.Length != shaderGuids.Length)
{
setEditor = new bool[paths.Count];
wasEditor = new bool[paths.Count];
}
init = true;
}
for (int p = 0; p < paths.Count; p++)
{
if (init)
{
EditorUtility.DisplayProgressBar("Load all shaders...", "", (float)p / paths.Count);
setEditor[p] = ShaderHelper.IsShaderUsingThryEditor(shaders[p]);
wasEditor[p] = setEditor[p];
}
setEditor[p] = GUILayout.Toggle(setEditor[p], shaders[p].name);
}
if (init)
{
EditorUtility.ClearProgressBar();
}
GUILayout.EndScrollView();
if (GUILayout.Button("Apply"))
{
for (int i = 0; i < paths.Count; i++)
{
if (wasEditor[i] != setEditor[i])
{
string path = paths[i];
ShaderImportFixer.scriptImportedAssetPaths.Add(path);
if (setEditor[i])
{
addThryEditor(path);
}
else
{
removeThryEditor(path);
}
List <string> differentQueueShaderPaths;
this.differentQueueShaderPaths.TryGetValue(shaders[i].name, out differentQueueShaderPaths);
if (differentQueueShaderPaths != null)
{
foreach (string queueShaderPath in differentQueueShaderPaths)
{
ShaderImportFixer.scriptImportedAssetPaths.Add(queueShaderPath);
if (setEditor[i])
{
addThryEditor(queueShaderPath);
}
else
{
removeThryEditor(queueShaderPath);
}
}
}
}
wasEditor[i] = setEditor[i];
}
AssetDatabase.Refresh();
ThryEditor.repaint();
}
}
private void OnGUI()
{
if (poiShaders == null || reload)
{
string[] shaderGuids = AssetDatabase.FindAssets("t:shader");
List <string> poiShaders = new List <string>();
foreach (string g in shaderGuids)
{
Shader shader = AssetDatabase.LoadAssetAtPath <Shader>(AssetDatabase.GUIDToAssetPath(g));
if (ShaderHelper.IsShaderUsingThryEditor(shader))
{
string defaultShaderName = ShaderHelper.getDefaultShaderName(shader.name);
if (!poiShaders.Contains(defaultShaderName))
{
poiShaders.Add(defaultShaderName);
}
}
}
this.poiShaders = new string[poiShaders.Count + 1];
for (int i = 0; i < poiShaders.Count; i++)
{
this.poiShaders[i + 1] = poiShaders[i];
}
}
GUILayout.Label("With thry editor the render queue selection in the material editor creates copies of the shader with different queues to make it work in vrchat. \n With this tool you can pre create those shader files so you don't have to wait.");
Shader activeShader = Mediator.active_shader;
if (activeShader != null)
{
poiShaders[0] = ShaderHelper.getDefaultShaderName(activeShader.name);
}
else
{
poiShaders[0] = "None";
}
int newSelectShader = EditorGUILayout.Popup(0, poiShaders, GUILayout.MaxWidth(200));
if (newSelectShader != selectedShader)
{
selectedShader = newSelectShader;
activeShader = Shader.Find(poiShaders[newSelectShader]);
Mediator.SetActiveShader(activeShader);
}
if (activeShader != null)
{
string defaultShaderName = ShaderHelper.getDefaultShaderName(activeShader.name);;
Shader defaultShader = Shader.Find(defaultShaderName);
GUIStyle style = new GUIStyle(GUI.skin.label);
style.richText = true;
EditorGUILayout.LabelField("<size=16>" + defaultShaderName + "</size>", style, GUILayout.MinHeight(18));
GUILayout.Label("Generate Render Queue Shaders", EditorStyles.boldLabel);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Generate All Queues", GUILayout.MaxWidth(200)))
{
for (int i = createShadersFrom; i <= createShadersTo; i++)
{
ShaderHelper.createRenderQueueShaderIfNotExists(defaultShader, i, false);
}
AssetDatabase.Refresh();
}
GUILayout.Label("from", GUILayout.MaxWidth(30));
createShadersFrom = EditorGUILayout.IntField(createShadersFrom, GUILayout.MaxWidth(50));
GUILayout.Label("to", GUILayout.MaxWidth(15));
createShadersTo = EditorGUILayout.IntField(createShadersTo, GUILayout.MaxWidth(50));
GUILayout.EndHorizontal();
if (GUILayout.Button("Generate most common Queues", GUILayout.MaxWidth(200)))
{
foreach (int i in COMMON_QUEUES)
{
ShaderHelper.createRenderQueueShaderIfNotExists(defaultShader, i, false);
}
AssetDatabase.Refresh();
}
}
}
