资源更新

最新推荐文章于 2020-11-12 14:22:03 发布
最新推荐文章于 2020-11-12 14:22:03 发布
阅读量209 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woshispl/article/details/50394114
版权 
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Reflection;

public class ResourcesUpdate : MonoBehaviour
{
    private static ResourcesUpdate instance;

    public static ResourcesUpdate GetInstance ()
    {
        return instance;
    }
    //本地存储版本号，在第一次装包时使用，以后都和persistent目录下的版本号对比
    public static readonly string LOCAL_VERSION_FILE = "/LocalVersion.txt";
    //本地URL下载地址，在assestStream目录下
    public static string LOCAL_RES_URL = "";

    #region 服务器版本号、资源bundle、Codebundle
    //服务器URL下载地址
    public static string SERVER_RES_URL = "http://192.168.1.248:80/ymres/android/";
    //服务器上的版本文件
    public static string SERVER_VERSION_FILE = "/ServerVersion.txt";
    //服务器上资源文件夹名字
    public static string SERVER_ALl_PREFAB = "/ServerResources/ALL.assetbundle";
    //服务器上Code dll名字
    public static string SERVER_CODE_DLL = "/CoinRunner_dll.assetbundle";
    //服务器上XML配置
    public static string SERVER_XMLCONFIG = "/xmlConfig.zip";
    #endregion

    #region 本地persistent版本号、资源bundle、Codebundle
    //服务器下载下来保存到本地永久目录的版本号文件名
    public static readonly string LOCAL_PERSISTENT_VERSION_FILE = "/LOCAL_Version.txt";
    //服务器下载下来保存到本地的Code dll 名字
    public static readonly string LOCAL_CODE_PERSISTENT_DLL = "/CoinRunner_dll.assetbundle";
    //服务器下载下来保存到本地的资源 dll 名字
    public static readonly string LOCAL_ALl_PERSISTENT_PREFAB = "/LOCAL_ALL.assetbundle";

    //本地资源永久路径，保存手机persistent
    public static string LOCAL_RES_PERSISTENT_PATH = "";
    //本地Code永久路径，保存手机persistent
    public static string LOCAL_CODE_PERSISTENT_PATH = "";

    #endregion

    private string codeDllName = "CoinRunner_dll";

    private List<string> LocalResVersion;
    private List<string> ServerResVersion;

    public delegate void HandleFinishDownload (WWW www);

    public delegate void DownloadFinishResources ();

    public DownloadFinishResources finishResources;
    public DownloadFinishResources finishCode;

    public AssetBundle bundle;

    private bool isNeedUpdateRes = false;
    private bool isNeedUpdateCode = false;

    #region 本地和服务器版本号对比
    private int localCodeVersion;
    private int serverCodeVersion;
    private int localPlatformType;

    private int localResVersion;
    private int serverResVersion;
    private int serverPlatformType;
    #endregion

    public bool isLoadingResources = false;
    public bool isLoadingCode = false;

    public bool isServer = false;


    public GameObject child;
    public GameObject root;

    private string platformPath = "";
    private string platformValidateNumber = "";

    void Awake ()
    {
        instance = this;
        isServer = false;
        CheckNetWorkType ();
        InitURLPath ();
    }

    /// <summary>
    /// 等到资源、代码加载完毕之后，再调用该方法
    /// </summary>
    void OpenGameObject(){
        child.SetActive (true);
        root.SetActive (true);
    }

    void CheckNetWorkType(){
        switch (CheckNetWork ()) {
        case 1://运行商网络
//          CommonMesgTips.GetInstance ().ShowTipsMsg ("正在使用运行商流量...");
            break;
        case 2://Wifi
//          CommonMesgTips.GetInstance ().ShowTipsMsg ("Wifi");
//          GLogger.LogError ("233333333333333333WifiWifiWifiWifiWifiWifiWifiWifi33333333333333333333333333");
            break;
        case -1://无网络连接
            CommonMesgTips.GetInstance ().ShowTipsMsg ("网络未连接，请检查网络!");
            break;
        default:
            break;
        }
    }

    /// <summary>
    /// //NotReachable  网络不可达
    //ReachableViaCarrierDataNetwork  网络通过运营商数据网络是可达的。
    //ReachableViaLocalAreaNetwork   网络通过WiFi或有线网络是可达的。
    /// </summary>
    /// <returns>The net work.</returns>
    public int CheckNetWork ()
    {
        if (Application.internetReachability == NetworkReachability.ReachableViaCarrierDataNetwork) {
            return 1;   
        }  else if (Application.internetReachability == NetworkReachability.ReachableViaLocalAreaNetwork) {
            return 2;   
        }  else {
            return -1;
        }
    }


    /// <summary>
    /// 1、得到本地持久化目录路径
    /// 2、得到本地StreamingAsset目录
    /// 3、初始化服务器下载路径
    /// </summary>
    void InitURLPath (){
        //保存到本地持久化目录
        LOCAL_RES_PERSISTENT_PATH = GameUtils.GetDocumentsPath ();// + "/"
        LOCAL_CODE_PERSISTENT_PATH = GameUtils.GetDocumentsPath ();

        LOCAL_RES_URL = GameUtils.GetStreamingAssetsPath ();
        //PlatformConfig
//      platformPath = "http://xian.ruanko.com/ymres/android/PlatformType.txt";
        platformPath = GameUtils.GetStreamingAssetsPath () + "/PlatformConfig.txt";
        platformValidateNumber = GameUtils.GetStreamingAssetsPath () + "/PayValidateConfig.txt";



        if (isServer) {

            GLogger.LogError (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>从服务器下载...");

//          SERVER_RES_URL = "http://192.168.1.248:80/ymres/android/";
            SERVER_RES_URL = "http://xian.ruanko.com/ymres/android/";

            SERVER_VERSION_FILE = "/ServerVersion.txt";
            //服务器上资源文件夹名字
            SERVER_ALl_PREFAB = "/ALL.assetbundle";
            //服务器上Code dll名字
            SERVER_CODE_DLL = "/CoinRunner_dll.assetbundle";

            SERVER_XMLCONFIG = "/xmlConfig.zip";
        } else {

            SERVER_RES_URL = GameUtils.GetStreamingAssetsPath ();

            SERVER_VERSION_FILE = "/ServerVersion.txt";
            //服务器上资源文件夹名字
            SERVER_ALl_PREFAB = "/ServerResources/ALL.assetbundle";
            //服务器上Code dll名字
            SERVER_CODE_DLL = "/CoinRunner_dll.assetbundle";

            SERVER_XMLCONFIG = "/xmlConfig.zip";
        }

    }

    void Start ()
    {

        LocalResVersion = new List<string> ();  
        ServerResVersion = new List<string> (); 



        if (bundle != null) {
            return;
        } else {
            LoadLocalVersion ();
        }
    }


    public void LoadLocalVersion ()
    {

        StartCoroutine (DownLoad (platformPath, delegate(WWW platformContent) { 
            ParsePlatformType(platformContent.text);
        }));

        StartCoroutine (DownLoad (platformValidateNumber, delegate(WWW PayValidateConfig) { 
            ParsePlatformValidate(PayValidateConfig.text);
        }));

        //加载本地version配置  SERVER_VERSION_FILE
        StartCoroutine (DownLoad (GetLocalVersionFile (), delegate(WWW localVersion) {  
            //保存本地的version  
            ParseLocalVersionFile (localVersion.text);  
            //加载服务端version配置  
            StartCoroutine (this.DownLoad (SERVER_RES_URL + SERVER_VERSION_FILE, delegate(WWW serverVersion) {  
                //保存服务端version  
                ParseServerVersionFile (serverVersion.text);  
                CamparePlatformType();
                //是否需要重新加载资源  
                CompareResVersion ();
                //是否需要重新加载Code
                CampareCodeVersion();
            }));  

        }));  
    } 

    void ParsePlatformType(string _content){

        int platformType = int.Parse(_content);
        PlatformUserInfos.GetInstance ().currentPlatformType = platformType;
//      int isChange = int.Parse(_content);
//      PlatformUserInfos.GetInstance ().validateChinaMobile = isChange;


//      GLogger.LogError (">>>>>>>>>>>>>isChange " + isChange);
//      GLogger.LogError (">>>>>>>>>>>>>PlatformUserInfos.GetInstance ().isTest " + PlatformUserInfos.GetInstance ().isTest);
    }

    void ParsePlatformValidate(string _content){

        int platformValidateType = int.Parse(_content);
//      PlatformUserInfos.GetInstance ().currentPlatformType = platformValidateType;
        if (platformValidateType == 1) {
            PlatformUserInfos.GetInstance ().validateNumber = PlatformPayValidateStatus.FormalValidate;
        } else if (platformValidateType == 2) {
            PlatformUserInfos.GetInstance ().validateNumber = PlatformPayValidateStatus.TestValidate;
        } else if (platformValidateType == 3) {
            PlatformUserInfos.GetInstance ().validateNumber = PlatformPayValidateStatus.DevelopValidate;
        }

        GLogger.LogError (">>>>>>>>>>>>>>>>PlatformUserInfos.GetInstance ().validateNumber " + (int)PlatformUserInfos.GetInstance ().validateNumber);

    }

    string GetLocalVersionFile ()
    {
        string filePath = null;
        if (File.Exists (LOCAL_RES_PERSISTENT_PATH.Replace("file://", "") + LOCAL_PERSISTENT_VERSION_FILE)) {
            filePath = LOCAL_RES_PERSISTENT_PATH + LOCAL_PERSISTENT_VERSION_FILE;
        } else {
            filePath = LOCAL_RES_URL + LOCAL_VERSION_FILE;
        }
        return filePath;
    }

    /// <summary>
    /// 读取streamingAssetsPath下的Version文件到PersistentDataPath下
    /// </summary>
    void SaveVersionToPersistentDataPath (string localVersion)
    {

        FileStream stream;
        string filePath = LOCAL_RES_PERSISTENT_PATH.Replace ("file://", "") + LOCAL_PERSISTENT_VERSION_FILE;
        if (File.Exists (filePath)) {
            stream = new FileStream (filePath, FileMode.Create);
        } else {
            CreateDic (filePath);
            stream = File.Create (filePath);
        }
        byte[] data = Encoding.UTF8.GetBytes (localVersion);  
        stream.Write (data, 0, data.Length);  
        stream.Flush ();  
        stream.Close (); 
    }

    private IEnumerator DownLoad (string url, HandleFinishDownload finishFun)
    {  
        WWW www = new WWW (url); 
        yield return www;  
        if (www.isDone) {
            if (finishFun != null) {  
                finishFun (www);  
            }  
        }
        www.Dispose ();  
    }

    private void ParseLocalVersionFile (string content)
    {  
        if (content == null || content.Length == 0) {  
            return;  
        }  

        string[] items = content.Split (new char[] { '\n' });  
        foreach (string item in items) {   
            LocalResVersion.Add (item);
        } 

        ParseVersion.GetInstance ().LoadVersion (content);
        localResVersion = ParseVersion.GetInstance ().GetResVersionNum ();
        localCodeVersion = ParseVersion.GetInstance ().GetCodeVersionNum ();
        localPlatformType = ParseVersion.GetInstance ().GetPlatformType ();
//      PlatformUserInfos.GetInstance().currentPlatformType = ParseVersion.GetInstance ().GetPlatformType ();
    }

    private void ParseServerVersionFile (string content)
    {  
        if (content == null || content.Length == 0) {  
            return;  
        }  

        string[] items = content.Split (new char[] { '\n' });  
        foreach (string item in items) {   
            ServerResVersion.Add (item);
        } 

        ParseVersion.GetInstance ().LoadVersion (content);
        serverResVersion = ParseVersion.GetInstance ().GetResVersionNum ();
        serverCodeVersion = ParseVersion.GetInstance ().GetCodeVersionNum ();
        serverPlatformType = ParseVersion.GetInstance ().GetPlatformType ();
        PlatformUserInfos.GetInstance().validateChinaMobile = ParseVersion.GetInstance ().GetPlatformType ();

    }

    private void CompareResVersion ()
    {   
        if (localResVersion != serverResVersion) {
            GLogger.LogWarning (">>>>>>>>>>>>>>资源版本不相等！！！");
            isNeedUpdateRes = true;
            //加载需要更新的资源
            DownLoadRes ();  
        } else {
            isNeedUpdateRes = false;
            GLogger.LogWarning (">>>>>>>资源版本相等！！！");
            DownLoadRes ();
        }
    }

    private void CampareCodeVersion(){
        if (localCodeVersion != serverCodeVersion) {
            GLogger.LogWarning (">>>>>>>>>>>>>>代码版本不相等！！！" + " localCodeVersion: " + localCodeVersion + " serverCodeVersion: " + serverCodeVersion);
            isNeedUpdateCode = true;
            DownLoadCode ();
        } else {
            GLogger.LogWarning (">>>>>>>>代码版本相等！！！");
            isNeedUpdateCode = false;
            DownLoadCode ();
        }
    }


    private void CamparePlatformType(){

        GLogger.LogError (">>>> 当前SDK ID >>>>>>：" + PlatformUserInfos.GetInstance ().currentPlatformType);

    }

    //依次加载需要更新的资源
    private void DownLoadRes ()
    {  
        if (!isNeedUpdateRes) {  
            //加载XML
            LoadAndShowAssetBundle ();

            return;  
        } else {
//          if(isServer){
                LoadXML ();
//          }
        }

        UpdateLocalVersionFile ();  
        StartCoroutine (this.DownLoad (SERVER_RES_URL + SERVER_ALl_PREFAB, delegate(WWW w) {  
            //将下载的资源替换本地旧的资源  
            ReplaceLocalRes (LOCAL_ALl_PERSISTENT_PREFAB, w.bytes); 
            isNeedUpdateRes = false;
            DownLoadRes ();
        }));  
    }

    void LoadXML(){
        string inputPath = null;
        if (isServer) {
            inputPath = SERVER_RES_URL + SERVER_XMLCONFIG;
        } else {
            inputPath = GameUtils.GetAssetPath () + "/xmlConfig.zip";
        }
        StartCoroutine (DownLoad(inputPath,DecompressXMLConfig));
    }

    void DecompressXMLConfig(WWW www){
        string inputPath = GameUtils.GetDocumentsPath ().Replace ("file://","")+"/xmlConfig.zip";
        GLogger.LogError (">>>>>>>>>>>>>>>>>加载XML资源>>>>>>>>>>>>>>>>");
        FileStream stream;
        if (File.Exists (inputPath)) {
            stream = new FileStream (inputPath, FileMode.Create);
        } else {
            CreateDic (inputPath);
            stream = File.Create (inputPath);
        } 
        byte[] data = www.bytes;  
        stream.Write (data, 0, data.Length);  
        stream.Flush ();  
        stream.Close ();



        string outputPath = GameUtils.GetDocumentsPath ().Replace ("file://","")+"/Config/";
        if(Directory.Exists(outputPath)){
            Directory.Delete (outputPath,true);
        }

        DecompressTool.DecompressFiles7Zip(inputPath, outputPath);
    }


    void LoadAndShowAssetBundle ()
    {
        isLoadingResources = true;
        GLogger.LogWarning ("正在加载资源...");
        string filePath = null;
        if (File.Exists (LOCAL_RES_PERSISTENT_PATH.Replace ("file://", "") + LOCAL_ALl_PERSISTENT_PREFAB)) {
            filePath = string.Format ("{0}{1}", LOCAL_RES_PERSISTENT_PATH, LOCAL_ALl_PERSISTENT_PREFAB);
        } else {
            GLogger.LogWarning ("************************本地加载资源不存在************************");
        }
        StartCoroutine (this.DownLoad (filePath, DownLoadFinishRes));
    }


    void DownLoadFinishRes(WWW www){

        bundle = www.assetBundle;  
        isLoadingResources = false;

        if (finishResources != null) {
            finishResources ();
        }
    }



    private void DownLoadCode (){

        if (!isNeedUpdateCode) {  
            LoadCodeAssembly ();
            return;  
        }

        UpdateLocalVersionFile ();  
        StartCoroutine (this.DownLoad (SERVER_RES_URL + SERVER_CODE_DLL, delegate(WWW w) {  
            //将下载的资源替换本地旧的资源  
            ReplaceLocalRes (LOCAL_CODE_PERSISTENT_DLL, w.bytes); 
            isNeedUpdateCode = false;
            DownLoadCode ();
        }));

    }

    private void LoadCodeAssembly(){
        isLoadingCode = true;
        GLogger.LogWarning ("正在加载代码...");
        string filePath = null;
        if (File.Exists (LOCAL_CODE_PERSISTENT_PATH.Replace ("file://", "") + LOCAL_CODE_PERSISTENT_DLL)) {
            filePath = string.Format ("{0}{1}", LOCAL_CODE_PERSISTENT_PATH, LOCAL_CODE_PERSISTENT_DLL);
        } else {
            GLogger.LogWarning ("************************本地加载Code不存在************************");
        }
        StartCoroutine (this.DownLoad (filePath, DownloadFinishCode));
    }


    void DownloadFinishCode(WWW www){

        AssetBundle bundle = www.assetBundle;
        TextAsset assets = bundle.Load (codeDllName, typeof(TextAsset)) as TextAsset;
        LocalResourceManager.assembly = Assembly.Load (assets.bytes);
        isLoadingCode = false;
        LocalResourceManager.GetInstance ().LoadCodeDll ();
        OpenGameObject ();
        if (finishCode != null) {
            finishCode ();
        }
    }



    //更新本地的version配置
    private void UpdateLocalVersionFile ()
    {  
        if (isNeedUpdateRes || isNeedUpdateCode) {  
            StringBuilder versions = new StringBuilder ();  
            foreach (var item in ServerResVersion) {  
                versions.Append (item).Append ("\n");  
            }  
            UpdatePersistentVersionFile (versions);
        }  
    }

    void UpdatePersistentVersionFile (StringBuilder versions)
    {
        string filePersistentPath = string.Format ("{0}{1}",LOCAL_RES_PERSISTENT_PATH.Replace ("file://", ""),LOCAL_PERSISTENT_VERSION_FILE);
        UpdateVersionFile (filePersistentPath, versions);
    }

    void UpdateVersionFile (string filePath, StringBuilder versions)
    {
        GLogger.LogWarning ("====================更新LocalVersion! " + filePath);
        FileStream stream;
        if (File.Exists (filePath)) {
            stream = new FileStream (filePath, FileMode.Create);
        } else {
            CreateDic (filePath);
            stream = File.Create (filePath);
        } 
        byte[] data = Encoding.UTF8.GetBytes (versions.ToString ());  
        stream.Write (data, 0, data.Length);  
        stream.Flush ();  
        stream.Close ();
    }


    private void ReplaceLocalRes (string fileName, byte[] data)
    {  

        FileStream stream;
        string filePath = LOCAL_RES_PERSISTENT_PATH.Replace ("file://", "") + fileName;
        if (File.Exists (filePath)) {
            stream = new FileStream (filePath, FileMode.Create);
        } else {
            CreateDic (filePath);
            stream = File.Create (filePath);
        } 
        stream.Write (data, 0, data.Length);  
        stream.Flush ();  
        stream.Close ();  

    }

    //创建路径
    void CreateDic (string filePath)
    {
        int index = filePath.LastIndexOf ('/');
        string dir = filePath.Substring (0, index + 1);
        if (!Directory.Exists (dir)) {
            Directory.CreateDirectory (dir);
        }
    }
}




/// <summary>
/// 保存本地资源dll到持久化目录
/// </summary>
/// <param name="prefabDll">Prefab dll.</param>
//  void SavePrefabDllToPersistentDataPath (string prefabDll)
//  {
//      FileStream stream;
//      string filePath = LOCAL_RES_PERSISTENT_PATH.Replace ("file://", "") + LOCAL_ALl_PERSISTENT_PREFAB;
//      if (File.Exists (filePath)) {
//          stream = new FileStream (filePath, FileMode.Create);
//      } else {
//          CreateDic (filePath);
//          stream = File.Create (filePath);
//      }
//      byte[] data = Encoding.UTF8.GetBytes (prefabDll);  
//      stream.Write (data, 0, data.Length);  
//      stream.Flush ();  
//      stream.Close (); 
//  }





using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Text;

public class LocalResourceManager : MonoBehaviour
{
    public static Assembly assembly;
    private static LocalResourceManager instance;
    public GameObject Child;
    public GameObject Root;
    public GameObject parseBaseXml;
    public delegate void HandleFinishDownloads (WWW www);

    public static LocalResourceManager GetInstance ()
    {
        return instance;
    }

     void Awake ()
    {
        instance = this;
    }


    public void LoadCodeDll(){

        if (assembly != null) {
            parseBaseXml.SetActive (true);
            return;
        }
    }

    void Start(){
        DontDestroyOnLoad (gameObject);
    }



    //给物体上挂在脚本
    public void AddComponentToResource (string className, GameObject gb)
    {
        System.Type type = assembly.GetType (className);

//      GLogger.LogWarning ("--------------类名：" + type);
        if (type == null) {
            GLogger.LogWarning ("null--------------");
        }

        if (gb == null) {
            GLogger.LogWarning ("null-------物体为空-------");
        }

//      GLogger.Log (type + "***********************************" + className);
        if (gb != null && type != null && gb.GetComponent (type) == null) {
            gb.AddComponent (type);
        }
    }
}




using System;
using UnityEngine;


public class GetCommponent : MonoBehaviour
{
    //物体上添加的脚本
    public string[] className;

//  public BaseView baseView;

    //物体上默认属性的值
    public int[] defaultIntVale;
    //物体上默认属性的值
    public float[] defaultFloatVale;
    //物体上默认属性的值
    public string[] defaultStrVal;

    public bool[] defaultBool;

    //物体上默认属性的值
    public GameObject[] defaultGameObject;

    void Awake(){

        if (className == null || className.Length <= 0) {
            return;
        }
//      Debug.Log("add");
        for (int i = 0; i < className.Length; i++) {
//          GLogger.LogWarning("00000000000000  " + className[i]);
            LocalResourceManager.GetInstance ().AddComponentToResource (className[i], gameObject);
        }
    }

    public T GetDefaultGB<T>(int index){


        if (defaultGameObject == null || defaultGameObject.Length <= 0) {
            GLogger.Log ("get gameobject fail: the defaultGameObject is null");
            return default(T);
        }
        if (index < 0 || index >= defaultGameObject.Length) {
            GLogger.Log ("get gameobject fail: IndexOutOfRangeException index error  " + index);
            return default(T);
        }
        if (defaultGameObject [index] == null) {
            GLogger.Log ("get gameobject fail: the index gameobject is null  " + index);
            return default(T);
        }
        Type type = typeof(T);
//      Debug.Log(type);
        if (type.Name == "GameObject") {
            return (T)Convert.ChangeType(defaultGameObject[index],type);
        }
        return (T)Convert.ChangeType(defaultGameObject[index].GetComponent(type),type);
    }

}
woshispl
关注
资源更新框架
12-06
无法达到最小化更新），最终是这样的出界面预设外的其他资源全部放到Resources 中，UI界面打成AB从磁盘来加载把UI关联的重复资源单独打出去（图集和字体），更新是UI预设可以直接打AB来更新，其他Resources 可以打成...
Unity的资源更新
shengtianzhu的专栏
05-13 2257
目录： 1、有资源更新需求时，资源的存储方式 2、下载资源的两种方式 3、断点续传的方式 在项目中。资源的更新是网络游戏中必不可少的一个环节。本文谈的是如何管理和下载资源 1、有资源更新需求时，资源的存储方式和读取方式 Unity提供了两个目录来存放资源： streamingAssetsPath：此路径下的文件只能读取。不能写入。文件随包的生成打入包中。不能修改 per...
C#异步编程案例学习——异步加载大资源文件 2 之 多线程加载
SQWH_SSGS的博客
11-12 1005
本文具体根据异步加载大资源文件案例中的多线程变成学习 C# 中 BeginInvoke 与 EndInvoke 的一个简单的使用案例 在使用 WPF 开发桌面软件过程中，遇到一个需要预加载大量文件的需求，具体需求如下： 在软件启动后，需要加载大量的 CAD 资源文件，文件供软件中后续使用。 文件加载过程中非常耗时，若同步加载则界面会出现假死的状态。 在文件加载过程中，需要保证界面仍然可以进行其他操作，屏蔽跟资源文件有关的操作。 文件加载完成后，开放跟资源文件有关的操作。 解决方案： 在软件启动后，软件页
AndEngine 分析之一-----Loading Resources In The Background With A Loading Screen
yezhiqiu_love的专栏
03-03 113
Loading Resources In The Background With A Loading Screen Well, after searching for this for the last two days it seems that either no one has figured it out, or...
C#异步编程案例学习——异步加载大资源文件1 之 使用 BeginInvoke 与 EndInvoke
SQWH_SSGS的博客
11-10 980
在使用 WPF 开发桌面软件过程中，遇到一个需要预加载大量文件的需求，具体需求如下： 在软件启动后，需要加载大量的 CAD 资源文件，文件供软件中后续使用。 文件加载过程中非常耗时，若同步加载则界面会出现假死的状态。 在文件加载过程中，需要保证界面仍然可以进行其他操作。 解决方案： 在软件启动后，软件页面正常完成加载后，后台继续进行异步加载资源文件，此时可操作正在加载的资源文件的按钮设置为不可操作。文件加载完成之后开发操作资源文件的按钮可操作。 具体实现如下： 1、WPF 页面 Window 中存在一个
第10章 游戏资源更新.zip
12-04
游戏资源更新是游戏开发和运营过程中的重要环节，它涉及到玩家体验、游戏性能优化以及内容迭代等多个方面。在本章中，我们将深入探讨游戏资源更新的相关知识点，主要以"BNUAssetBundles.zip"这个压缩包文件为例进行...
unity资源更新管理方式
08-15
Unity资源更新管理方式是游戏开发过程中非常重要的一环，特别是在移动端游戏和实时应用中，为了提供更流畅的游戏体验和持续的内容更新，开发者需要有效地管理和更新游戏内的资源。AssetBundles是Unity提供的一种强大...
unity简单易懂的版本对比和资源更新-附件资源
03-02
unity简单易懂的版本对比和资源更新-附件资源
更新资源
02-15
本话题主要关注使用Go语言进行资源更新的相关知识点。 Go语言，又称Golang，是Google推出的一种静态类型的、编译型的、并发型的、垃圾回收的、具有C风格语法的编程语言。它以其简洁的语法、高效的性能和内置的并发...
资源更新最快体积最小的电影播放器
03-07
软件版本：TTKvod V2.61 软件大小：5.03MB (目前网上体积最小的电影播放器) 系统要求：Win2000/XP/Vista/Win7 功能特性： 免费 完全免费，下载安装后即可观看 流畅 播放流畅P2P传输，越多人看越流畅 灵活 具有灵活点播的功能，随点随看，时间自由掌握 丰富 海量电影、电视剧、每日更新；电视、电台在线直播 记录 自动记录上次关闭时的文件位置，再次观看接着来 个性 支持功能快捷键修改或设置，满足您个性偏好 更新 全网电影电视剧更新最快 体积 目前网上体积最小的电影播放器 占用 占用电脑资源小
csdn博客资源管理帮助
08-31
csdn博客资源管理帮助，能帮助我们更好的管理csdn，都是经验心得
【UGF】（三）Resource模块的使用及资源热更新
Sun Spark Studio
02-05 3567
ResourceComponent有两种Resource Mode: Package(单机模式)，Updatable(可更新模式)一.Resource Mode: Package(单机模式)单机模式：资源打包后将AssetBundle Builder生成的Package下对应平台文件夹下的资源直接复制到StreamingAssets，资源随游戏一起打包举个栗子：①设置ResourceCompone...
unity简单易懂的版本对比和资源更新
foxの笔记本
11-23 7608
项目中没有使用lua脚本,所以热更只能资源更新,一旦逻辑代码上有改变,需要玩家自行更新游戏客户端. 本人把公司项目中的更新模块精简了下,还是画张流程图解释: 一般资源打入安装包有3种情况: 1.安装包没有资源,进入游戏后资源全部从资源服务器下载.        (包体最小 ,但第一次进入游戏耗时最长) 2.安装包有部分资源,剩余的资源还是从服务器下载.     (包体介于1-3之间...
网站资源更新
qq_34718767的博客
06-24 537
昨天网站全部应用都出现证书掉了的问题，证书掉了软件是无法打开的，会出现“无法验证应用”目前还有部分用户还是可以打开使用，能打开的朋友请及时备份你的资料。出现这样的问题请删...
[Unity]AssetBundle资源更新以及多线程下载
热门推荐
学无止境的专栏
09-03 1万+
前言此文章适合不太了解资源加载的萌新，有了入门基础之后再去github上搜大牛写的专业的资源加载方案才能得心应手，不然的话会看的很吃力或者说一脸懵逼。Unity里面关于资源加载我们都知道是下载更新AssetBundle，关于AssetBundle我之前的文章已经详细介绍过，没看过的朋友可以在看一下。下面介绍的资源加载的Demo有以下几点： 1.WWW下载图片资源 2.HTTP下载apk文件，并且
山东石油化工学院在辽宁2020-2024各专业最低录取分数及位次表.pdf
最新发布
10-04
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
STM32F1xx中文手册：微控制器系列详解与资源更新
STM32F1xx中文参考手册是一份详细的指南，针对意法半导体公司推出的STM32单片机系列，特别是STM32F105和STM32F107互连型系列。该系列继承了STM32增强型系列的特点，拥有72MHz处理频率，内存范围从64KB至256KB闪存和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值