root/plugin-library
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

UI更新

Browse Source
This commit is contained in:
张铮
2025-06-25 15:47:51 +08:00
parent a160595baf
commit a6bd4dce81
9 changed files with 546 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
Assets/00.StaryEvo/Editor/MarkAdressable/MarkAdressable.cs
View File

@@ -170,6 +170,7 @@ namespace Stary.Evo.Editor
AssetDatabase.LoadAssetAtPath<DomainConfig>(configPath);
packageName = domainConfig.domain;
Mark();
CollectSVC();
CreateRes(packageName,
$"{DomainRoot}/{BuildAssetWindow.GetBuildPackageName()}/AddressableRes",
@@ -251,6 +252,8 @@ namespace Stary.Evo.Editor
YooAsset.Editor.AssetBundleCollectorSettingData.SaveFile();
// CreateRes();
Debug.Log("MarkAsset Successful");
}
@@ -453,37 +456,6 @@ namespace Stary.Evo.Editor
#endregion
// /// <summary>
// /// 标记是否有打包报错信息
// /// </summary>
// private static bool _isBuildSuccess = true;
//
// [MenuItem("Evo/BuildTools/BuildAdressable")]
// private static void BuildByStatus()
// {
// InitAssetData();
// _isBuildSuccess = true;
// //BuildTools.ClearConsole();
// Application.logMessageReceived += OnLogMessage;
//
// AssetDatabase.Refresh();
// AssetDatabase.Refresh();
// MarkStatus();
// //SetMD5Info();
// AssetDatabase.Refresh();
// Application.logMessageReceived -= OnLogMessage;
// if (!_isBuildSuccess)
// {
// if (EditorUtility.DisplayDialog("打包失败", "请检测报错信息", "确定"))
// {
// // EditorUtility.RevealInFinder(BuildTools.OutPath);
// // BuildTools.OutPath = string.Empty;
// }
// }
// }
/// <summary>
/// 标记为资源分组
/// </summary>
@@ -509,61 +481,54 @@ namespace Stary.Evo.Editor
}
}
// private static Dictionary<string, MD5Info> _md5Files = new Dictionary<string, MD5Info>();
//
// private static void SetMD5Info()
// {
// _md5Files.Clear();
//
// string path = Application.dataPath.Replace("Assets",
// $"ServerData/{Application.platform}/Release");
// if (Directory.Exists(path))
// {
// DirectoryInfo dir = new DirectoryInfo(path);
// MD5File(dir);
// }
//
// AssetDatabase.Refresh();
// }
//
// private static void MD5File(DirectoryInfo info)
// {
// FileInfo[] files = info.GetFiles();
// if (files.Length > 0)
// {
// for (int i = 0; i < files.Length; i++)
// {
// var file = files[i];
// if (file == null || file.Extension == ".meta")
// {
// continue;
// }
//
// string filePath = file.FullName.Replace(@"\", "/");
// MD5Info md5 = new MD5Info();
// md5.AssetPath = filePath;
// md5.MD5 = FilesUtils.CalculateMD5(file.FullName);
// _md5Files.Add(md5.AssetPath, md5);
// }
// }
//
// DirectoryInfo[] dirs = info.GetDirectories();
// if (dirs != null && dirs.Length > 0)
// {
// for (int i = 0; i < dirs.Length; i++)
// {
// MD5File(dirs[i]);
// }
// }
// }
public static void CollectSVC()
{
string remotedRoot = $"{DomainRoot}/{packageName}/AddressableRes";
remotedRoot += $"/ShaderVariants/{BuildAssetWindow.GetBuildPackageName()}.shadervariants";
// private static void OnLogMessage(string condition, string stackTrace, LogType type)
// {
// if (type == LogType.Error)
// {
// if (condition != "EndLayoutGroup: BeginLayoutGroup must be called first.")
// _isBuildSuccess = false;
// }
// }
string localSavePath = FilesUtils.AbsoluteToRelativePath("Assets", remotedRoot); //Asset到文件的路径
System.Action completedCallback = () =>
{
ShaderVariantCollection collection =
AssetDatabase.LoadAssetAtPath<ShaderVariantCollection>(localSavePath);
if (collection != null)
{
Debug.Log($"UnityEvo:【{BuildAssetWindow.GetBuildPackageName()}】ShaderCount : {collection.shaderCount}");
Debug.Log($"UnityEvo:【{BuildAssetWindow.GetBuildPackageName()}】VariantCount : {collection.variantCount}");
string groupname = "ShaderVariants";
AssetBundleCollectorGroup collectorGroup = null;
if (collectorGroupDic.ContainsKey(groupname))
{
collectorGroupDic[groupname].Collectors.Clear();
collectorGroup = collectorGroupDic[groupname];
}
else
{
collectorGroup =
YooAsset.Editor.AssetBundleCollectorSettingData.CreateGroup(package, "ShaderVariants");
}
var guid = AssetDatabase.AssetPathToGUID(localSavePath);
AssetBundleCollector collector = new AssetBundleCollector()
{
CollectPath = localSavePath,
CollectorGUID = guid,
CollectorType = ECollectorType.MainAssetCollector,
AddressRuleName = nameof(AddressByFolderAndFileName),
PackRuleName = nameof(PackShaderVariants),
FilterRuleName = nameof(CollectShaderVariants),
AssetTags = groupname,
};
YooAsset.Editor.AssetBundleCollectorSettingData.CreateCollector(collectorGroup, collector);
YooAsset.Editor.AssetBundleCollectorSettingData.SaveFile();
}
else
{
throw new Exception("Failed to Collect shader Variants.");
}
};
ShaderVariantCollector.Run(localSavePath,BuildAssetWindow.GetBuildPackageName(),1000, completedCallback);
}
}
}

3
Assets/00.StaryEvo/Editor/YooAsset.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 3b3295425e4e4793bb7c48e08326eb5f
timeCreated: 1750745208

38
Assets/00.StaryEvo/Editor/YooAsset/ShaderVariantCollectionHelper.cs Normal file
View File

@@ -0,0 +1,38 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEditor;
using YooAsset.Editor;
public static class ShaderVariantCollectionHelper
{
public static void ClearCurrentShaderVariantCollection()
{
EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "ClearCurrentShaderVariantCollection");
}
public static void SaveCurrentShaderVariantCollection(string savePath)
{
EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "SaveCurrentShaderVariantCollection", savePath);
}
public static int GetCurrentShaderVariantCollectionShaderCount()
{
return (int)EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "GetCurrentShaderVariantCollectionShaderCount");
}
public static int GetCurrentShaderVariantCollectionVariantCount()
{
return (int)EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "GetCurrentShaderVariantCollectionVariantCount");
}
/// <summary>
/// 获取着色器的变种总数量
/// </summary>
public static string GetShaderVariantCount(string assetPath)
{
Shader shader = AssetDatabase.LoadAssetAtPath<Shader>(assetPath);
var variantCount = EditorTools.InvokeNonPublicStaticMethod(typeof(ShaderUtil), "GetVariantCount", shader, true);
return variantCount.ToString();
}
}

3
Assets/00.StaryEvo/Editor/YooAsset/ShaderVariantCollectionHelper.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: bc2e7d30082b47ddba18c2a8ea2b95e4
timeCreated: 1750745226

190
Assets/00.StaryEvo/Editor/YooAsset/ShaderVariantCollectionManifest.cs Normal file
View File

@@ -0,0 +1,190 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEditor;
[Serializable]
public class ShaderVariantCollectionManifest
{
[Serializable]
public class ShaderVariantElement : IComparable<ShaderVariantElement>
{
public string SortValue { private set; get; }
/// <summary>
/// Pass type to use in this variant.
/// </summary>
public PassType PassType;
/// <summary>
/// Array of shader keywords to use in this variant.
/// </summary>
public string[] Keywords;
public void MakeSortValue()
{
string combineKeyword = string.Empty;
for (int i = 0; i < Keywords.Length; i++)
{
if (i == 0)
combineKeyword = Keywords[0];
else
combineKeyword = $"{combineKeyword}+{Keywords[0]}";
}
SortValue = $"{PassType}+{combineKeyword}";
}
public int CompareTo(ShaderVariantElement other)
{
return SortValue.CompareTo(other.SortValue);
}
}
[Serializable]
public class ShaderVariantInfo : IComparable<ShaderVariantInfo>
{
public string SortValue { private set; get; }
/// <summary>
/// 着色器资源路径.
/// </summary>
public string AssetPath;
/// <summary>
/// 着色器名称
/// </summary>
public string ShaderName;
/// <summary>
/// 着色器变种总数
/// </summary>
public int ShaderVariantCount = 0;
/// <summary>
/// 着色器变种列表
/// </summary>
public List<ShaderVariantElement> ShaderVariantElements = new List<ShaderVariantElement>(1000);
public void MakeSortValue()
{
SortValue = AssetPath + "+" + ShaderName;
}
public int CompareTo(ShaderVariantInfo other)
{
return SortValue.CompareTo(other.SortValue);
}
}
/// <summary>
/// Number of shaders in this collection
/// </summary>
public int ShaderTotalCount;
/// <summary>
/// Number of total varians in this collection
/// </summary>
public int VariantTotalCount;
/// <summary>
/// Shader variants info list.
/// </summary>
public List<ShaderVariantInfo> ShaderVariantInfos = new List<ShaderVariantInfo>(1000);
/// <summary>
/// 添加着色器变种信息
/// </summary>
public void AddShaderVariant(string assetPath, string shaderName, PassType passType, string[] keywords)
{
// 排序Keyword列表
List<string> temper = new List<string>(keywords);
temper.Sort();
var info = GetOrCreateShaderVariantInfo(assetPath, shaderName);
ShaderVariantElement element = new ShaderVariantElement();
element.PassType = passType;
element.Keywords = temper.ToArray();
element.MakeSortValue();
info.ShaderVariantElements.Add(element);
info.ShaderVariantCount++;
}
private ShaderVariantInfo GetOrCreateShaderVariantInfo(string assetPath, string shaderName)
{
var selectList = ShaderVariantInfos.Where(t => t.ShaderName == shaderName && t.AssetPath == assetPath).ToList();
if (selectList.Count == 0)
{
ShaderVariantInfo newInfo = new ShaderVariantInfo();
newInfo.AssetPath = assetPath;
newInfo.ShaderName = shaderName;
newInfo.MakeSortValue();
ShaderVariantInfos.Add(newInfo);
return newInfo;
}
if (selectList.Count != 1)
throw new Exception("Should never get here !");
return selectList[0];
}
/// <summary>
/// 解析SVC文件并将数据写入到清单
/// </summary>
public static ShaderVariantCollectionManifest Extract(ShaderVariantCollection svc)
{
var manifest = new ShaderVariantCollectionManifest();
manifest.ShaderTotalCount = ShaderVariantCollectionHelper.GetCurrentShaderVariantCollectionShaderCount();
manifest.VariantTotalCount = ShaderVariantCollectionHelper.GetCurrentShaderVariantCollectionVariantCount();
using (var so = new SerializedObject(svc))
{
var shaderArray = so.FindProperty("m_Shaders.Array");
if (shaderArray != null && shaderArray.isArray)
{
for (int i = 0; i < shaderArray.arraySize; ++i)
{
var shaderRef = shaderArray.FindPropertyRelative($"data[{i}].first");
var shaderVariantsArray = shaderArray.FindPropertyRelative($"data[{i}].second.variants");
if (shaderRef != null && shaderRef.propertyType == SerializedPropertyType.ObjectReference && shaderVariantsArray != null && shaderVariantsArray.isArray)
{
var shader = shaderRef.objectReferenceValue as Shader;
if (shader == null)
{
throw new Exception("Invalid shader in ShaderVariantCollection file.");
}
string shaderAssetPath = AssetDatabase.GetAssetPath(shader);
string shaderName = shader.name;
// 添加变种信息
for (int j = 0; j < shaderVariantsArray.arraySize; ++j)
{
var propKeywords = shaderVariantsArray.FindPropertyRelative($"Array.data[{j}].keywords");
var propPassType = shaderVariantsArray.FindPropertyRelative($"Array.data[{j}].passType");
if (propKeywords != null && propPassType != null && propKeywords.propertyType == SerializedPropertyType.String)
{
string[] keywords = propKeywords.stringValue.Split(' ');
PassType pathType = (PassType)propPassType.intValue;
manifest.AddShaderVariant(shaderAssetPath, shaderName, pathType, keywords);
}
}
}
}
}
}
// 重新排序
manifest.ShaderVariantInfos.Sort();
foreach (var shaderVariantInfo in manifest.ShaderVariantInfos)
{
shaderVariantInfo.ShaderVariantElements.Sort();
}
return manifest;
}
}

3
Assets/00.StaryEvo/Editor/YooAsset/ShaderVariantCollectionManifest.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 290ed59b3dc24595ad73be97451fd3bb
timeCreated: 1750745226

251
Assets/00.StaryEvo/Editor/YooAsset/ShaderVariantCollector.cs Normal file
View File

@@ -0,0 +1,251 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.IO;
using UnityEngine;
using UnityEditor;
using UnityEditor.SceneManagement;
using YooAsset.Editor;
public static class ShaderVariantCollector
{
private enum ESteps
{
None,
Prepare,
CollectAllMaterial,
CollectVariants,
CollectSleeping,
WaitingDone,
}
private const float WaitMilliseconds = 3000f;
private const float SleepMilliseconds = 3000f;
private static string _savePath;
private static string _packageName;
private static int _processMaxNum;
private static Action _completedCallback;
private static ESteps _steps = ESteps.None;
private static Stopwatch _elapsedTime;
private static List<string> _allMaterials;
private static List<GameObject> _allSpheres = new List<GameObject>(1000);
/// <summary>
/// 开始收集
/// </summary>
public static void Run(string savePath, string packageName, int processMaxNum, Action completedCallback)
{
if (_steps != ESteps.None)
return;
if (Path.HasExtension(savePath) == false)
savePath = $"{savePath}.shadervariants";
if (Path.GetExtension(savePath) != ".shadervariants")
throw new System.Exception("Shader variant file extension is invalid.");
if (string.IsNullOrEmpty(packageName))
throw new System.Exception("Package name is null or empty !");
// 注意：先删除再保存，否则ShaderVariantCollection内容将无法及时刷新
AssetDatabase.DeleteAsset(savePath);
EditorTools.CreateFileDirectory(savePath);
_savePath = savePath;
_packageName = packageName;
_processMaxNum = processMaxNum;
_completedCallback = completedCallback;
// 聚焦到游戏窗口
EditorTools.FocusUnityGameWindow();
// 创建临时测试场景
CreateTempScene();
_steps = ESteps.Prepare;
EditorApplication.update += EditorUpdate;
}
private static void EditorUpdate()
{
if (_steps == ESteps.None)
return;
if (_steps == ESteps.Prepare)
{
ShaderVariantCollectionHelper.ClearCurrentShaderVariantCollection();
_steps = ESteps.CollectAllMaterial;
return; //等待一帧
}
if (_steps == ESteps.CollectAllMaterial)
{
_allMaterials = GetAllMaterials();
_steps = ESteps.CollectVariants;
return; //等待一帧
}
if (_steps == ESteps.CollectVariants)
{
int count = Mathf.Min(_processMaxNum, _allMaterials.Count);
List<string> range = _allMaterials.GetRange(0, count);
_allMaterials.RemoveRange(0, count);
CollectVariants(range);
if (_allMaterials.Count > 0)
{
_elapsedTime = Stopwatch.StartNew();
_steps = ESteps.CollectSleeping;
}
else
{
_elapsedTime = Stopwatch.StartNew();
_steps = ESteps.WaitingDone;
}
}
if (_steps == ESteps.CollectSleeping)
{
if (_elapsedTime.ElapsedMilliseconds > SleepMilliseconds)
{
DestroyAllSpheres();
_elapsedTime.Stop();
_steps = ESteps.CollectVariants;
}
}
if (_steps == ESteps.WaitingDone)
{
// 注意：一定要延迟保存才会起效
if (_elapsedTime.ElapsedMilliseconds > WaitMilliseconds)
{
_elapsedTime.Stop();
_steps = ESteps.None;
// 保存结果并创建清单
ShaderVariantCollectionHelper.SaveCurrentShaderVariantCollection(_savePath);
CreateManifest();
UnityEngine.Debug.Log($"搜集SVC完毕！");
EditorApplication.update -= EditorUpdate;
_completedCallback?.Invoke();
}
}
}
private static void CreateTempScene()
{
EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects);
}
private static List<string> GetAllMaterials()
{
// 获取所有打包的资源
CollectResult collectResult = AssetBundleCollectorSettingData.Setting.BeginCollect(_packageName, false, false);
// 搜集所有材质球
int progressValue = 0;
HashSet<string> result = new HashSet<string>();
foreach (var collectAssetInfo in collectResult.CollectAssets)
{
if (collectAssetInfo.AssetInfo.AssetType == typeof(UnityEngine.Material))
{
string assetPath = collectAssetInfo.AssetInfo.AssetPath;
if (result.Contains(assetPath) == false)
result.Add(assetPath);
}
foreach(var dependAssetInfo in collectAssetInfo.DependAssets)
{
if (dependAssetInfo.AssetType == typeof(UnityEngine.Material))
{
string assetPath = dependAssetInfo.AssetPath;
if (result.Contains(assetPath) == false)
result.Add(assetPath);
}
}
EditorTools.DisplayProgressBar("搜集所有材质球", ++progressValue, collectResult.CollectAssets.Count);
}
EditorTools.ClearProgressBar();
// 返回结果
return result.ToList();
}
private static void CollectVariants(List<string> materials)
{
Camera camera = Camera.main;
if (camera == null)
throw new System.Exception("Not found main camera.");
// 设置主相机
float aspect = camera.aspect;
int totalMaterials = materials.Count;
float height = Mathf.Sqrt(totalMaterials / aspect) + 1;
float width = Mathf.Sqrt(totalMaterials / aspect) * aspect + 1;
float halfHeight = Mathf.CeilToInt(height / 2f);
float halfWidth = Mathf.CeilToInt(width / 2f);
camera.orthographic = true;
camera.orthographicSize = halfHeight;
camera.transform.position = new Vector3(0f, 0f, -10f);
// 创建测试球体
int xMax = (int)(width - 1);
int x = 0, y = 0;
int progressValue = 0;
for (int i = 0; i < materials.Count; i++)
{
var material = materials[i];
var position = new Vector3(x - halfWidth + 1f, y - halfHeight + 1f, 0f);
var go = CreateSphere(material, position, i);
if (go != null)
_allSpheres.Add(go);
if (x == xMax)
{
x = 0;
y++;
}
else
{
x++;
}
EditorTools.DisplayProgressBar("照射所有材质球", ++progressValue, materials.Count);
}
EditorTools.ClearProgressBar();
}
private static GameObject CreateSphere(string assetPath, Vector3 position, int index)
{
var material = AssetDatabase.LoadAssetAtPath<Material>(assetPath);
var shader = material.shader;
if (shader == null)
return null;
var go = GameObject.CreatePrimitive(PrimitiveType.Sphere);
go.GetComponent<Renderer>().sharedMaterial = material;
go.transform.position = position;
go.name = $"Sphere_{index} | {material.name}";
return go;
}
private static void DestroyAllSpheres()
{
foreach (var go in _allSpheres)
{
GameObject.DestroyImmediate(go);
}
_allSpheres.Clear();
// 尝试释放编辑器加载的资源
EditorUtility.UnloadUnusedAssetsImmediate(true);
}
private static void CreateManifest()
{
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
ShaderVariantCollection svc = AssetDatabase.LoadAssetAtPath<ShaderVariantCollection>(_savePath);
if (svc != null)
{
var wrapper = ShaderVariantCollectionManifest.Extract(svc);
string jsonData = JsonUtility.ToJson(wrapper, true);
string savePath = _savePath.Replace(".shadervariants", ".json");
File.WriteAllText(savePath, jsonData);
}
AssetDatabase.Refresh(ImportAssetOptions.ForceUpdate);
}
}

3
Assets/00.StaryEvo/Editor/YooAsset/ShaderVariantCollector.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 82d87cc411ac4ac2b8951dffeb0b8655
timeCreated: 1750745226

2
Assets/00.StaryEvo/package.json
View File

@@ -1,6 +1,6 @@
{
"name": "com.staryevo.main",
"version": "1.3.2",
"version": "1.3.8",
"displayName": "00.StaryEvo",
"description": "This is an Framework package(后台服务器版本，端口9527)",
"unity": "2021.3",