Gameframework资源管理适配其他资源管理方案

已于 2024-06-09 22:26:19 修改
阅读量740 收藏 3
点赞数 4
CC 4.0 BY-SA版权
文章标签： unity
于 2024-05-25 23:15:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zweiluan/article/details/139205338

在做之前，我们需要研究一下，常用的几款资源管理方案。
1、unity editor
Resources.Load()
构建assetbundle，使用assetBundle.LoadAsset()进行加载。
assetBundle.unload()进行卸载

2、addressable
每次构建时，都会生成唯一的版本。缺陷是，发布同一版本不同版本，比如内部测试版，和正式版时。两个版本由于是单独构建的，因此无法实现一次打包，两个版本互用的情况。
需要使用分支来管理。即通过切换分支，保证对应的build正确。

Addressables.Load(“AssetAddress”);

第一次加载Addressable的API是，会自动初始化。也可以自己调用Addressables.InitializeAsync
初始化，
1、会设置ResourceManager和ResourceLocators。
2、加载Addressale在StreamingAssets中的配置数据
3、执行任意对象的初始化操作
4、加载内容目录。默认情况下，会检查更新，然后下载可用的新目录
按地址加载
handle = Addressables.LoadAssetAsync(address); handle.Completed += Handle_Completed;
释放资源
Addressables.Release(handle);

3、yooasset
同样分为初始化、资源更新。加载

在资源管理方案中，通常的接口为
1、loadAsset
2、unloadAsset
3、loadscene
4、unloadScene
5、init
6、updata

我们专门定义一个接口ICustomResourceManager，来适配这些常用的资源管理方案
然后写一个继承自IResourceManager来调用这个接口

    /// <summary>
    /// 资源加载适配器
    /// </summary>
    public class GFAdapterResourceManager : IResourceManager
    {
        public static GFAdapterResourceManager instance = new GFAdapterResourceManager();
        public ICustomResourceManager CustomResourceManager;

        #region 暂不需要实现的功能
        


        #endregion
        
        public HasAssetResult HasAsset(string assetName)
        {
            throw new NotImplementedException();
        }

        public void LoadAsset(string assetName, LoadAssetCallbacks loadAssetCallbacks)
        {
            LoadAsset(assetName, null, 0, loadAssetCallbacks, null);
        }

        public void LoadAsset(string assetName, Type assetType, LoadAssetCallbacks loadAssetCallbacks)
        {
            LoadAsset(assetName, assetType, 0, loadAssetCallbacks, null);
        }

        public void LoadAsset(string assetName, int priority, LoadAssetCallbacks loadAssetCallbacks)
        {
            LoadAsset(assetName, null, priority, loadAssetCallbacks, null);
        }

        public void LoadAsset(string assetName, LoadAssetCallbacks loadAssetCallbacks, object userData)
        {
            LoadAsset(assetName, null, 0, loadAssetCallbacks, userData);
        }

        public void LoadAsset(string assetName, Type assetType, int priority, LoadAssetCallbacks loadAssetCallbacks)
        {
            LoadAsset(assetName, assetType, priority, loadAssetCallbacks, null);
        }

        public void LoadAsset(string assetName, Type assetType, LoadAssetCallbacks loadAssetCallbacks, object userData)
        {
            LoadAsset(assetName, assetType, 0, loadAssetCallbacks, userData);
        }

        public void LoadAsset(string assetName, int priority, LoadAssetCallbacks loadAssetCallbacks, object userData)
        {
            LoadAsset(assetName, null, priority, loadAssetCallbacks, userData);
        }

        public void LoadAsset(string assetName, Type assetType, int priority, LoadAssetCallbacks loadAssetCallbacks, object userData)
        {
            CustomResourceManager.ToLoadAsset(assetName,assetType,priority,loadAssetCallbacks,userData);
        }

        public void UnloadAsset(object asset)
        {
            CustomResourceManager.ToUnloadAsset(asset);
        }

        public void LoadScene(string sceneAssetName, LoadSceneCallbacks loadSceneCallbacks)
        {
            LoadScene(sceneAssetName,0,loadSceneCallbacks, null);
        }

        public void LoadScene(string sceneAssetName, int priority, LoadSceneCallbacks loadSceneCallbacks)
        {
            LoadScene(sceneAssetName,priority,loadSceneCallbacks, null);
        }

        public void LoadScene(string sceneAssetName, LoadSceneCallbacks loadSceneCallbacks, object userData)
        {
            LoadScene(sceneAssetName, 0,loadSceneCallbacks, userData);
        }

        public void LoadScene(string sceneAssetName, int priority, LoadSceneCallbacks loadSceneCallbacks, object userData)
        {
            CustomResourceManager.ToLoadScene(sceneAssetName,loadSceneCallbacks,priority,userData);
        }

        public void UnloadScene(string sceneAssetName, UnloadSceneCallbacks unloadSceneCallbacks)
        {
            UnloadScene(sceneAssetName, unloadSceneCallbacks, null);
        }

        public void UnloadScene(string sceneAssetName, UnloadSceneCallbacks unloadSceneCallbacks, object userData)
        {
            CustomResourceManager.ToUnloadScene(sceneAssetName,unloadSceneCallbacks,userData);
        }

        public void InitResources(InitResourcesCompleteCallback initResourcesCompleteCallback)
        {
            CustomResourceManager.ToInitResources(initResourcesCompleteCallback);
        }
        public void UpdateResources(UpdateResourcesCompleteCallback updateResourcesCompleteCallback)
        {
            CustomResourceManager.ToUpdateResources(updateResourcesCompleteCallback);
        }
    }

}

此处的接口是按照ugf的接口进行提出的，方便适配

在这里插入代码片
    /// <summary>
    /// 使用Resource组件时，请按照该组件的接口进行调用。
    /// </summary>
    public interface ICustomResourceManager
    {
        void ToLoadScene(string sceneAssetName, LoadSceneCallbacks loadSceneCallbacks, int priority, object userData);
        void ToUnloadScene(string sceneAssetName, UnloadSceneCallbacks unloadSceneCallbacks, object userData);

        void ToLoadAsset(string assetName, Type assetType, int priority,
            GameFramework.Resource.LoadAssetCallbacks loadAssetCallbacks, object userData);

        void ToUnloadAsset(object asset);

        /// <summary>
        /// 组件初始化
        /// </summary>
        void ToInitResources(InitResourcesCompleteCallback initResourcesCompleteCallback);

        /// <summary>
        /// 更新资源
        /// </summary>
        void ToUpdateResources(UpdateResourcesCompleteCallback updateResourcesCompleteCallback);
    }

使用mono来实现这个接口，在启动应用的时候注册到GFAdapterResourceManager 中，操作和ufg的editor资源加载方案相似。

在这里插入代码片
    public abstract class CustomResourceManagerBase : MonoBehaviour,ICustomResourceManager
    {
        public abstract void ToLoadScene(string sceneAssetName, LoadSceneCallbacks loadSceneCallbacks, int priority,
            object userData);

        public abstract void ToUnloadScene(string sceneAssetName, UnloadSceneCallbacks unloadSceneCallbacks,
            object userData);

        public abstract void ToLoadAsset(string assetName, Type assetType, int priority,
            LoadAssetCallbacks loadAssetCallbacks,
            object userData);

        public abstract void ToUnloadAsset(object asset);
        public abstract void ToInitResources(InitResourcesCompleteCallback initResourcesCompleteCallback);

        public abstract void ToUpdateResources(UpdateResourcesCompleteCallback updateResourcesCompleteCallback);

        public virtual void Awake()
        {
            GFAdapterResourceManager.instance.CustomResourceManager = this;
        }
    }

实现CustomResourceManagerBase，简单的把ugf中的editor的加载方案移植过来。这里就是写其他资源管理方案的地方。

 public class EditorResourceManager: CustomResourceManagerBase
    {
        
        private static readonly int AssetsStringLength = "Assets".Length;
        
        public override void ToLoadScene(string sceneAssetName, LoadSceneCallbacks loadSceneCallbacks, int priority, object userData)
        {
            AsyncOperation asyncOperation = SceneManager.LoadSceneAsync(sceneAssetName, LoadSceneMode.Additive);
            if(asyncOperation==null) return;
            asyncOperation.completed += (operation) =>
            {
                if(loadSceneCallbacks==null) return;
                if (operation.allowSceneActivation)
                {
                    loadSceneCallbacks.LoadSceneSuccessCallback(sceneAssetName, 0, userData);
                }
                else
                {
                    loadSceneCallbacks.LoadSceneFailureCallback(sceneAssetName,LoadResourceStatus.NotReady,"未知错误",userData);
                }
            };
        }

        public override void ToUnloadScene(string sceneAssetName, UnloadSceneCallbacks unloadSceneCallbacks, object userData)
        {
            AsyncOperation asyncOperation = SceneManager.UnloadSceneAsync(sceneAssetName);
            if (asyncOperation == null)
            {
                return;
            }
            asyncOperation.completed += (operation) =>
            {
                if(unloadSceneCallbacks==null) return;
                
                if (operation.isDone)
                {
                    unloadSceneCallbacks.UnloadSceneSuccessCallback(sceneAssetName, userData);
                }
                else
                {
                    unloadSceneCallbacks.UnloadSceneFailureCallback(sceneAssetName, userData);
                }
            };
        }

        public override void ToLoadAsset(string assetName, Type assetType, int priority, LoadAssetCallbacks loadAssetCallbacks,
            object userData)
        {
            if (loadAssetCallbacks == null)
            {
                Log.Error("Load asset callbacks is invalid.");
                return;
            }

            if (string.IsNullOrEmpty(assetName))
            {
                if (loadAssetCallbacks.LoadAssetFailureCallback != null)
                {
                    loadAssetCallbacks.LoadAssetFailureCallback(assetName, LoadResourceStatus.NotExist, "Asset name is invalid.", userData);
                }

                return;
            }

            if (!assetName.StartsWith("Assets/", StringComparison.Ordinal))
            {
                if (loadAssetCallbacks.LoadAssetFailureCallback != null)
                {
                    loadAssetCallbacks.LoadAssetFailureCallback(assetName, LoadResourceStatus.NotExist, Utility.Text.Format("Asset name '{0}' is invalid.", assetName), userData);
                }

                return;
            }

            if (!HasFile(assetName))
            {
                if (loadAssetCallbacks.LoadAssetFailureCallback != null)
                {
                    loadAssetCallbacks.LoadAssetFailureCallback(assetName, LoadResourceStatus.NotExist, Utility.Text.Format("Asset '{0}' is not exist.", assetName), userData);
                }

                return;
            }
#if UNITY_EDITOR
            if (assetType != null)
            {
                var asset = UnityEditor.AssetDatabase.LoadAssetAtPath(assetName, assetType);
            }
            else
            {
               var  asset = UnityEditor.AssetDatabase.LoadMainAssetAtPath(assetName);
            }
#endif            
           
        }

        public override void ToUnloadAsset(object asset)
        {
            return;
        }

        public override void ToInitResources(InitResourcesCompleteCallback initResourcesCompleteCallback)
        {
            initResourcesCompleteCallback?.Invoke();
        }

        public override void ToUpdateResources(UpdateResourcesCompleteCallback updateResourcesCompleteCallback)
        {
            updateResourcesCompleteCallback?.Invoke(null,true);
        }
        private bool HasFile(string assetName)
        {
            if (string.IsNullOrEmpty(assetName))
            {
                return false;
            }

            if (HasCachedAsset(assetName))
            {
                return true;
            }

            string assetFullName = Application.dataPath.Substring(0, Application.dataPath.Length - AssetsStringLength) + assetName;
            if (string.IsNullOrEmpty(assetFullName))
            {
                return false;
            }

            string[] splitedAssetFullName = assetFullName.Split('/');
            string currentPath = Path.GetPathRoot(assetFullName);
            for (int i = 1; i < splitedAssetFullName.Length - 1; i++)
            {
                string[] directoryNames = Directory.GetDirectories(currentPath, splitedAssetFullName[i]);
                if (directoryNames.Length != 1)
                {
                    return false;
                }

                currentPath = directoryNames[0];
            }

            string[] fileNames = Directory.GetFiles(currentPath, splitedAssetFullName[splitedAssetFullName.Length - 1]);
            if (fileNames.Length != 1)
            {
                return false;
            }

            string fileFullName = Utility.Path.GetRegularPath(fileNames[0]);
            if (fileFullName == null)
            {
                return false;
            }

            if (assetFullName != fileFullName)
            {
                if (assetFullName.ToLowerInvariant() == fileFullName.ToLowerInvariant())
                {
                    Log.Warning("The real path of the specific asset '{0}' is '{1}'. Check the case of letters in the path.", assetName, "Assets" + fileFullName.Substring(Application.dataPath.Length));
                }

                return false;
            }

            return true;
        }
        private bool HasCachedAsset(string assetName)
        {
            return false;
        }
    }

最后注册到ResourceComponent中。需要修改ResourceComponent的代码。
只需要 m_ResourceManager = m_EditorResourceMode ? baseComponent.EditorResourceHelper : GameFrameworkEntry.GetModule();这一行前额外加一个判断。由于我们实际使用的过程中只会使用上面定义的接口，所以可以直接return了。

在这里插入代码片
private void Start()
        {
            BaseComponent baseComponent = GameEntry.GetComponent<BaseComponent>();
            if (baseComponent == null)
            {
                Log.Fatal("Base component is invalid.");
                return;
            }

            m_EventComponent = GameEntry.GetComponent<EventComponent>();
            if (m_EventComponent == null)
            {
                Log.Fatal("Event component is invalid.");
                return;
            }

            m_EditorResourceMode = baseComponent.EditorResourceMode;
            ///如果使用自定义，则使用自定义，否则按照原来的方案执行
#region 存在修改的代码
            if (GFAdapterResourceManager.instance.CustomResourceManager!=null)
            {
                m_ResourceManager = GFAdapterResourceManager.instance;
                return;
            }
            else
            {
            //原来的代码
                m_ResourceManager = m_EditorResourceMode ? baseComponent.EditorResourceHelper : GameFrameworkEntry.GetModule<IResourceManager>();
            }
 #endregion

这样我们就完成了resourceManager的改造。
但是在使用ui、scene、sound、entity这些组件功能时，依旧会调用原生的resourcemanager，也就是GF中的资源加载方案。这个时候需要在对应的代码中，将资源管理器替换掉。
下面是个简单的例子UIComponent

private void Start()
        {
            BaseComponent baseComponent = GameEntry.GetComponent<BaseComponent>();
            if (baseComponent == null)
            {
                Log.Fatal("Base component is invalid.");
                return;
            }

            m_EventComponent = GameEntry.GetComponent<EventComponent>();
            if (m_EventComponent == null)
            {
                Log.Fatal("Event component is invalid.");
                return;
            }
#region 增加的代码
            if (GFAdapterResourceManager.instance.CustomResourceManager != null)
            {
                m_UIManager.SetResourceManager(GFAdapterResourceManager.instance);
            }
            else
            {
            
				//原来的代码
                if (baseComponent.EditorResourceMode)
                {
                    m_UIManager.SetResourceManager(baseComponent.EditorResourceHelper);
                }
                else
                {
                    
                    m_UIManager.SetResourceManager(GameFrameworkEntry.GetModule<IResourceManager>());
                }
#endregion             
            }
            ....省略其他代码

最后我简单接入了yooasset分享一下接入方案

绝大数代码是从yooasset的案例里copy的。
YooAssetResourceManager.cs

using System;
using System.Collections.Generic;
using GameFramework.Resource;
using UnityEngine;
using UnityEngine.SceneManagement;
using YooAsset;
using Object = UnityEngine.Object;

namespace GameFrameworkExtension
{

    public partial class YooAssetResourceManager : CustomResourceManagerBase
    {
        [SerializeField]
        public EPlayMode Mode;

        private ResourcePackage package;
        
        /// <summary>
        /// 记录对应handler
        /// </summary>
        private Dictionary<string, Queue<AssetHandle>> assetHandleNameMap;
        private Dictionary<int, string> assetInstanceIdNameMap;
        
        private Dictionary<string, SceneHandle> sceneHandles;
        public override void ToLoadScene(string sceneAssetName, LoadSceneCallbacks loadSceneCallbacks, int priority, object userData)
        {
            var handler= package.LoadSceneAsync(sceneAssetName, LoadSceneMode.Additive,true,(uint)priority);
          
            float time = Time.realtimeSinceStartup;
            handler.Completed += (handler) =>
            {
                if (handler.SceneObject != null)
                {
                    loadSceneCallbacks.LoadSceneSuccessCallback.Invoke(sceneAssetName,Time.realtimeSinceStartup-time,userData);
                    sceneHandles.Add(sceneAssetName,handler);
                }
                else
                {
                    loadSceneCallbacks.LoadSceneFailureCallback.Invoke(sceneAssetName,LoadResourceStatus.NotExist,handler.LastError,userData);
                }
               
            };

        }

        public override void ToUnloadScene(string sceneAssetName, UnloadSceneCallbacks unloadSceneCallbacks, object userData)
        {
            SceneHandle handler= sceneHandles[sceneAssetName];
            handler.UnloadAsync();
            sceneHandles.Remove(sceneAssetName);

        }

        public override void ToLoadAsset(string assetName, Type assetType, int priority, LoadAssetCallbacks loadAssetCallbacks,
            object userData)
        {
            if (!assetHandleNameMap.ContainsKey(assetName))
            {
                assetHandleNameMap.Add(assetName,new Queue<AssetHandle>());
            }
            // package.GetAssetInfo(assetName).
            ///如果是同一个资产，那么就会找到对应的引用。返回同一个对象。但是handler却是新的
            /// handler仅仅只是句柄，对应引用的是同一个。因此可以维持一个dic<name,list<handler>>,卸载对象时，从list中取出。再去一个dic<instanceid,name>作为映射
            var handler= package.LoadAssetAsync(assetName, assetType,(uint)priority);
            float time = Time.realtimeSinceStartup;
            assetHandleNameMap[assetName].Enqueue(handler);
            handler.Completed += (handler) =>
            {
                if (handler.AssetObject != null)
                {
                    loadAssetCallbacks.LoadAssetSuccessCallback.Invoke(assetName,handler.AssetObject,Time.realtimeSinceStartup-time,userData);
                    int instanceId = handler.AssetObject.GetInstanceID();
                    if (!assetInstanceIdNameMap.ContainsKey(instanceId))
                    {
                        assetInstanceIdNameMap.Add(instanceId,assetName);
                    }
                }
                else
                {
                    loadAssetCallbacks.LoadAssetFailureCallback.Invoke(assetName,LoadResourceStatus.NotExist,handler.LastError,userData);
                }
               
            };
        }

        public override void ToUnloadAsset(object asset)
        {
            int instanceID = (asset as Object).GetInstanceID();
            if (assetInstanceIdNameMap.ContainsKey(instanceID))
            {
                string name = assetInstanceIdNameMap[instanceID];
                if (assetHandleNameMap[name].Count > 0)
                {
                    var handler = assetHandleNameMap[name].Dequeue();
                    handler.Release();
                }
            }
           
        }

        public override void ToInitResources(InitResourcesCompleteCallback initResourcesCompleteCallback)
        {

            assetHandleNameMap = new Dictionary<string, Queue<AssetHandle>>();
            assetInstanceIdNameMap = new Dictionary<int, string>();
            sceneHandles = new Dictionary<string, SceneHandle>();
            // 初始化资源系统
            YooAssets.Initialize();
            // 创建默认的资源包
            package = YooAssets.CreatePackage("DefaultPackage");
            // 设置该资源包为默认的资源包，可以使用YooAssets相关加载接口加载该资源包内容。
            YooAssets.SetDefaultPackage(package);
            switch (Mode)
            {
                case EPlayMode.EditorSimulateMode:
                    StartCoroutine(EditorModeInit(initResourcesCompleteCallback));
                    break;
                case EPlayMode.HostPlayMode:
                    StartCoroutine(HostPlayModeModeInit(initResourcesCompleteCallback));
                    break;
                case EPlayMode.OfflinePlayMode:
                    StartCoroutine(OfflineModeInit(initResourcesCompleteCallback));
                    break;
                case EPlayMode.WebPlayMode:
                    StartCoroutine(WebPlayModeInit(initResourcesCompleteCallback));
                    break;
            }
        }

        public override void ToUpdateResources(UpdateResourcesCompleteCallback updateResourcesCompleteCallback)
        {
            StartCoroutine(UpdateResources(updateResourcesCompleteCallback));
        }
    }

}

YooAssetResourceManager.Definition.cs

using System.IO;
using UnityEngine;
using YooAsset;

namespace GameFrameworkExtension
{

    public partial class YooAssetResourceManager
    {
                private string GetHostServerURL()
        {
            //string hostServerIP = "http://10.0.2.2"; //安卓模拟器地址
            string hostServerIP = "http://127.0.0.1";
            string appVersion = "v1.0";

#if UNITY_EDITOR
            if (UnityEditor.EditorUserBuildSettings.activeBuildTarget == UnityEditor.BuildTarget.Android)
                return $"{hostServerIP}/CDN/Android/{appVersion}";
            else if (UnityEditor.EditorUserBuildSettings.activeBuildTarget == UnityEditor.BuildTarget.iOS)
                return $"{hostServerIP}/CDN/IPhone/{appVersion}";
            else if (UnityEditor.EditorUserBuildSettings.activeBuildTarget == UnityEditor.BuildTarget.WebGL)
                return $"{hostServerIP}/CDN/WebGL/{appVersion}";
            else
                return $"{hostServerIP}/CDN/PC/{appVersion}";
#else
        if (Application.platform == RuntimePlatform.Android)
            return $"{hostServerIP}/CDN/Android/{appVersion}";
        else if (Application.platform == RuntimePlatform.IPhonePlayer)
            return $"{hostServerIP}/CDN/IPhone/{appVersion}";
        else if (Application.platform == RuntimePlatform.WebGLPlayer)
            return $"{hostServerIP}/CDN/WebGL/{appVersion}";
        else
            return $"{hostServerIP}/CDN/PC/{appVersion}";
#endif
        }
        /// <summary>
        /// 远端资源地址查询服务类
        /// </summary>
        private class RemoteServices : IRemoteServices
        {
            private readonly string _defaultHostServer;
            private readonly string _fallbackHostServer;

            public RemoteServices(string defaultHostServer, string fallbackHostServer)
            {
                _defaultHostServer = defaultHostServer;
                _fallbackHostServer = fallbackHostServer;
            }
            string IRemoteServices.GetRemoteMainURL(string fileName)
            {
                return $"{_defaultHostServer}/{fileName}";
            }
            string IRemoteServices.GetRemoteFallbackURL(string fileName)
            {
                return $"{_fallbackHostServer}/{fileName}";
            }
        }
        /// <summary>
        /// 资源文件流加载解密类
        /// </summary>
        private class FileStreamDecryption : IDecryptionServices
        {
            /// <summary>
            /// 同步方式获取解密的资源包对象
            /// 注意：加载流对象在资源包对象释放的时候会自动释放
            /// </summary>
            AssetBundle IDecryptionServices.LoadAssetBundle(DecryptFileInfo fileInfo, out Stream managedStream)
            {
                BundleStream bundleStream = new BundleStream(fileInfo.FileLoadPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                managedStream = bundleStream;
                return AssetBundle.LoadFromStream(bundleStream, fileInfo.ConentCRC, GetManagedReadBufferSize());
            }

            /// <summary>
            /// 异步方式获取解密的资源包对象
            /// 注意：加载流对象在资源包对象释放的时候会自动释放
            /// </summary>
            AssetBundleCreateRequest IDecryptionServices.LoadAssetBundleAsync(DecryptFileInfo fileInfo, out Stream managedStream)
            {
                BundleStream bundleStream = new BundleStream(fileInfo.FileLoadPath, FileMode.Open, FileAccess.Read, FileShare.Read);
                managedStream = bundleStream;
                return AssetBundle.LoadFromStreamAsync(bundleStream, fileInfo.ConentCRC, GetManagedReadBufferSize());
            }

            private static uint GetManagedReadBufferSize()
            {
                return 1024;
            }
        }
        /// <summary>
        /// 资源文件偏移加载解密类
        /// </summary>
        private class FileOffsetDecryption : IDecryptionServices
        {
            /// <summary>
            /// 同步方式获取解密的资源包对象
            /// 注意：加载流对象在资源包对象释放的时候会自动释放
            /// </summary>
            AssetBundle IDecryptionServices.LoadAssetBundle(DecryptFileInfo fileInfo, out Stream managedStream)
            {
                managedStream = null;
                return AssetBundle.LoadFromFile(fileInfo.FileLoadPath, fileInfo.ConentCRC, GetFileOffset());
            }

            /// <summary>
            /// 异步方式获取解密的资源包对象
            /// 注意：加载流对象在资源包对象释放的时候会自动释放
            /// </summary>
            AssetBundleCreateRequest IDecryptionServices.LoadAssetBundleAsync(DecryptFileInfo fileInfo, out Stream managedStream)
            {
                managedStream = null;
                return AssetBundle.LoadFromFileAsync(fileInfo.FileLoadPath, fileInfo.ConentCRC, GetFileOffset());
            }

            private static ulong GetFileOffset()
            {
                return 32;
            }
        }
    }
    /// <summary>
    /// 资源文件解密流
    /// </summary>
    public class BundleStream : FileStream
    {
        public const byte KEY = 64;

        public BundleStream(string path, FileMode mode, FileAccess access, FileShare share) : base(path, mode, access, share)
        {
        }
        public BundleStream(string path, FileMode mode) : base(path, mode)
        {
        }

        public override int Read(byte[] array, int offset, int count)
        {
            var index = base.Read(array, offset, count);
            for (int i = 0; i < array.Length; i++)
            {
                array[i] ^= KEY;
            }
            return index;
        }
    }
}

YooAssetResourceManager.Init.cs

using System.Collections;
using System.IO;
using GameFramework.Resource;
using UnityEngine;
using YooAsset;

namespace GameFrameworkExtension
{

    public partial class YooAssetResourceManager
    {
        IEnumerator EditorModeInit(InitResourcesCompleteCallback initResourcesCompleteCallback)
        {
            var initParameters = new EditorSimulateModeParameters();
            var simulateManifestFilePath = EditorSimulateModeHelper.SimulateBuild(EDefaultBuildPipeline.BuiltinBuildPipeline, "DefaultPackage");
            initParameters.SimulateManifestFilePath  = simulateManifestFilePath;
            yield return package.InitializeAsync(initParameters);
            initResourcesCompleteCallback.Invoke();
        }

        IEnumerator OfflineModeInit(InitResourcesCompleteCallback initResourcesCompleteCallback)
        {
            var initParameters = new OfflinePlayModeParameters();
            yield return package.InitializeAsync(initParameters);
            initResourcesCompleteCallback.Invoke();
        }

        IEnumerator HostPlayModeModeInit(InitResourcesCompleteCallback initResourcesCompleteCallback)
        {
            // 注意：GameQueryServices.cs 太空战机的脚本类，详细见StreamingAssetsHelper.cs
            string defaultHostServer = "http://127.0.0.1/CDN/Android/v1.0";
            string fallbackHostServer = "http://127.0.0.1/CDN/Android/v1.0";
            var initParameters = new HostPlayModeParameters();
            initParameters.BuildinQueryServices = new GameQueryServices(); 
            initParameters.DecryptionServices = new FileOffsetDecryption();
            initParameters.RemoteServices = new RemoteServices(defaultHostServer, fallbackHostServer);
            var initOperation = package.InitializeAsync(initParameters);
            yield return initOperation;
        
            if(initOperation.Status == EOperationStatus.Succeed)
            {
                Debug.Log("资源包初始化成功！");
                initResourcesCompleteCallback.Invoke();
            }
            else 
            {
                Debug.LogError($"资源包初始化失败：{initOperation.Error}");
            }
        }
        
        IEnumerator WebPlayModeInit(InitResourcesCompleteCallback initResourcesCompleteCallback)
        {
            // 注意：GameQueryServices.cs 太空战机的脚本类，详细见StreamingAssetsHelper.cs
            string defaultHostServer = "http://127.0.0.1/CDN/WebGL/v1.0";
            string fallbackHostServer = "http://127.0.0.1/CDN/WebGL/v1.0";
            var initParameters = new WebPlayModeParameters();
            initParameters.BuildinQueryServices = new GameQueryServices();
            initParameters.RemoteServices = new RemoteServices(defaultHostServer, fallbackHostServer);
            var initOperation = package.InitializeAsync(initParameters);
            yield return initOperation;
        
            if(initOperation.Status == EOperationStatus.Succeed)
            {
                Debug.Log("资源包初始化成功！");
                initResourcesCompleteCallback.Invoke();
            }
            else 
            {
                Debug.LogError($"资源包初始化失败：{initOperation.Error}");
            }
        }


    }





}

YooAssetResourceManager.Update.cs


using System.Collections;
using GameFramework.Resource;
using UnityEngine;
using YooAsset;

namespace GameFrameworkExtension
{

    public partial class YooAssetResourceManager
    {
        private string packageVersion;

        IEnumerator UpdateResources(UpdateResourcesCompleteCallback updateResourcesCompleteCallback)
        {
            yield return StartCoroutine(UpdatePackageVersion(updateResourcesCompleteCallback));
            if (packageVersion != null)
            {
                yield return StartCoroutine(UpdatePackageManifest(updateResourcesCompleteCallback));
            }
        }
        private IEnumerator UpdatePackageVersion(UpdateResourcesCompleteCallback updateResourcesCompleteCallback)
        {
            var package = YooAssets.GetPackage("DefaultPackage");
            var operation = package.UpdatePackageVersionAsync();
            yield return operation;

            if (operation.Status == EOperationStatus.Succeed)
            {
                //更新成功
                packageVersion = operation.PackageVersion;
                Debug.Log($"Updated package Version : {packageVersion}");
            }
            else
            {
                updateResourcesCompleteCallback.Invoke(null,false);
                //更新失败
                Debug.LogError(operation.Error);
            }
        }
        private IEnumerator UpdatePackageManifest(UpdateResourcesCompleteCallback updateResourcesCompleteCallback)
        {
            // 更新成功后自动保存版本号，作为下次初始化的版本。
            // 也可以通过operation.SavePackageVersion()方法保存。
            bool savePackageVersion = true;
            var package = YooAssets.GetPackage("DefaultPackage");
            var operation = package.UpdatePackageManifestAsync(packageVersion, savePackageVersion);
            yield return operation;

            if (operation.Status == EOperationStatus.Succeed)
            {
                //更新成功
                updateResourcesCompleteCallback.Invoke(null,true);
            }
            else
            {
                updateResourcesCompleteCallback.Invoke(null,false);
                //更新失败
                Debug.LogError(operation.Error);
            }
        }
    }

}
zweiluan
关注
GameFramework框架详解之 Resource资源管理器
TxNet
11-14 6504
资源加载 前言 Game Framework 使用了一套异步资源加载体系，因此只提供了异步加载资源的接口。不论简单的数据表、本地化字典，还是复杂的实体、场景、界面，都将使用异步加载。同时，Game Framework 提供了默认的内存管理策略（当然，你也可以定义自己的内存管理策略）。 资源类型定义 Game Framework 中有两个关于资源的定义，在使用过程中需要注意区分。Game Framework 设计的所有方法都是面向 Asset 的，Resource 隐藏在内部，不对外公开，以降低使用的复杂度。
GameFramework框架详解之 资源打包和热更新流程
TxNet
04-02 2611
GameFramework 是一个非常出色开源游戏框架，框架中自带了资源，UI，对象池，状态机等等很多模块，可以让我们更加高效和方便的开发游戏。当然毋庸置疑，它也支持热更新。今天我们就来详解一下GameFramework如何实现热更新。
Unity3d：GameFramework解析：实体，对象池，资源管理，获取计数，引用计数，自动释放
Have a nice day.
08-24 1468
1.GF万物基于引用池IReference2.ObjectBase : IReference类的m_Target持有unity中Mono，资源，GameObejct3.AssetObject : ObjectBase类m_Target持有Assetbundle中的Asset，具有获取，引用两个计数管理释放4.ResourceObject : ObjectBase类m_Target持有Assetbundle，具有获取，引用两个计数管理释放。
Game Framework 设计思想研究(七) ResourseManager(资源管理器)
tianma0042的博客
07-31 482
GF里非要重要的一部分，所有资源都可以通过资源管理加载，内部维护了一个内存管理策略，可以让上层无需管理资源释放的问题。 资源模式分为三种：Package（单机模式）、Updatable（预下载的可更新模式）、UpdatableWhilePlaying（使用时下载的可更新模式）。 待续。。。 ...
【无标题】GameFrameWork框架接入Adressable,CatAsset,YooAsset,X-asset资源管理方案
weixin_43838912的博客
05-04 3103
GameFrameWork框架完美接入Adressable,CatAsset,YooAsset,X-asset
GameFramework：StarForce资源讲解
weixin_39081932的博客
09-07 1560
StarForce，资源的初始化，资源加载，资源卸载。
高效资源管理：GameFrameWork框架的多方案集成
最新发布
gitblog_09710的博客
09-07 553
高效资源管理：GameFrameWork框架的多方案集成 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 在游戏开发过程中，资源管理是一个至关重要的环节。为了帮助开发者更高效地管理游戏资源，我们推出了GameFrameWork框架接入资源管理方案源码项目。该项目集成了多种流行的资源管理工具，包括Unity官方的Adressable、轻量级的CatAsset、功能强大的Y...
一个简单的游戏框架：资源管理方案
weixin_46700547的博客
03-31 460
1、Resources加载 Resources加载主要分为同步和异步两种方式，Resources文件夹下资源过多，游戏启动会变慢，另外又无法热更新，所以这种加载方式是不推荐的。（调Resources.LoadAsync加载的同一帧,调Resources.Load加载同一资源会报错） 2、AssetBundle加载 AssetBundle加载主要分为同步和异步两种方式。 AssetBundle加载完...
GameFrameWork框架接入Adressable,CatAsset,YooAsset,X-asset资管管理方案的相关源码
05-04
GameFrameWork是一个广泛应用于游戏开发的开源框架，它提供了一整套的游戏开发解决方案，包括场景管理、UI系统、网络同步、资源管理等。通过这个框架，开发者可以快速构建游戏项目，减少重复工作，提高开发效率。 ...
GameFrameWork框架整合资产管理方案源码详解
- **GFAdapterResourceManager.cs**：该源码文件很可能是自定义的资源管理器适配器，用于将GameFrameWork框架与不同的资产管理方案集成，实现统一的资源管理接口。 - **ToAddressableManager.cs**：该文件应该是将...
游戏完整框架FrameWork
05-29
完整游戏框架：事件系统，状态机，对象池，场景管理，声音管理，资源管理，网络通信，资源更新，等等，完善的框架
【GameFramework扩展应用】6-1、接入热更新框架HybridCLR
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
07-09 1119
是一款基于Unity的通用游戏框架。提供了游戏开发中常用的框架基础模块，将基础模型进行了封装，在资源管理和资源更新方面比较完善，可以大大加大开发进程，加快开发速度，并且还在在此此处上保证产品质量。HybridCLR是一款特性完整、零成本、高性能、低内存的近乎完美的C#热更新方案。这篇文章就来介绍一下的示例项目StarForce是如何接入HybridCLR热更新框架的。*注意：这篇文章的重点是接入HybridCLR热更新框架，将不过多介绍HybridCLR热更新框架是如何实现热更新流程的，对于。
【GameFramework框架】7-1、GameFramework框架深入分析
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
09-06 869
在开始之前啰嗦一下。在最初写这个专栏的时候，就有规划这篇文章，叫做框架深入分析，就是想着将这个框架的所有内容刨根问底，追根溯源，分析到底是如何实现的。后来，写完了所有的GameFramework模块后发现，框架的内容真的博大精深，如果就着某点深入分析，分析完再进入下一个功能点，很容易就进入了牛角尖。站在花丛中，不识此山风景。跳出框架，掌握整体，见微知著，谋而定全局。框架是项目的骨架，它的力学结构决定了项目代码规模、人员规模以及系统和资源规模等方面的上限。
GameFramework：Resource加载，资源加载，依赖加载，任务池，对象池，引用计数
Have a nice day.
07-15 5431
ResourceManager持有某个功能例如ResourceLoader（资源加载），ResourceLoader持有TaskPool，TaskPool持有agent，agent持有helper，真正执行操作的方法是存在helper中。
探索高效资源管理：GameFramework.ResourceRuleEditor
gitblog_00063的博客
06-04 378
探索高效资源管理：GameFramework.ResourceRuleEditor 1、项目介绍 在游戏开发中，资源管理和优化是至关重要的环节。GameFramework.ResourceRuleEditor 是一个专为Unity开发者设计的强大工具，它基于GameFramework框架，提供了一个可视化的资源包（AssetBundle）规则编辑器，可以帮助您自定义资源配置规则，避免繁琐的手动配置...
Unity GameFramework框架笔记-资源管理之资源加载
lin0205的专栏
12-14 2850
Unity GameFramework加载资源流程： 加载资源（LoadAsset） 检查资源（CheckAsset） AssetInfo是资源信息，ResourceInfo是资源对应的AB包信息，在单机包初始化资源或热更包下载前检查资源时，会根据本地的version.dat或服务端的version.dat、Packed的list.dat、根据已下载资源的信息本地生成的list.dat...
Unity GameFramework框架笔记-资源处理之热更流程
lin0205的专栏
01-21 2081
参考范例Starforce 1、进入ProcedureCheckVersion，下载资源信息，地址：https://gameframework.cn//version.txt version.txt内容： {"ForceGameUpdate": false, "LatestGameVersion": "0.1.0", "InternalGameVersion": 1, "Inte...
Unity GameFramework框架笔记-资源管理之AssetBundleEditor
lin0205的专栏
11-23 748
AssetBundleEditor： 编辑资源和AssetBundle 大致流程： 加载AssetBundleEditor.xml 根据配置的路径和筛选条件，选出满足条件的文件、抽象成SourceFolder、SourceAsset类，用于显示在编辑器的右侧列表：待加入ab的资源 这里筛选使用HashSet，它可以用于高性能集运算，适用于这里筛选处理 加载AssetBund...
Unity GameFramework框架笔记-资源管理之AssetBundleCollection
lin0205的专栏
11-23 1349
Unity GameFramework提供一套完整的asset bundle编辑、构建、分析工具，以及资源加载、使用、销毁等处理。 工具主要分为 AssetBundleEditor：ab包编辑 AssetBundleBuilder：ab包构建 AssetBundleAnalyzer：ab分析，包括资源缺失、循环引用检测 AssetBundleCollection： 抽象出项目各种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值