AssetBundle加载与卸载

最新推荐文章于 2023-06-09 15:57:42 发布
最新推荐文章于 2023-06-09 15:57:42 发布
阅读量267 收藏 2
点赞数
分类专栏： u3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcc858079762/article/details/113525449
版权

1.生成Asset Bundle

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using System.IO;

public class BuildAssetBundle :  Editor{

	[MenuItem("Tools/BuildAssetBundle")]
	public static void BuildBundle()
	{
		string abPath = Path.Combine(Application.streamingAssetsPath,"AssetBundle");
		if (!Directory.Exists(abPath))
		{
			Directory.CreateDirectory(abPath);
		}
		BuildPipeline.BuildAssetBundles(abPath, BuildAssetBundleOptions.ChunkBasedCompression,EditorUserBuildSettings.activeBuildTarget);
		AssetDatabase.Refresh();
	}

	[MenuItem("Tools/CreatScriptTableAsset")]
	public static void CreatScriptTableAsset()
	{
		ScriptTableTest test = ScriptableObject.CreateInstance<ScriptTableTest>();
		AssetDatabase.CreateAsset(test, "Assets/Resources/ScriptTableTest.asset");
		AssetDatabase.SaveAssets();
		AssetDatabase.Refresh();
	}
}

 

2.AssetBundleManager 管理（资源加载和卸载）

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

public enum ABLoadStateEnum
{
	None,
	Loading,
	Loaded,
	Release
}

public enum AssetLoadStateEnum
{
	LoadFail,
	Loading,
	Loaded
}

public class AssetBundleManager : MonoBehaviour {

	private static AssetBundleManager instance;
	public static AssetBundleManager Instance
	{
		get
		{
			return instance;
		}
	}
	private Coroutine mRequestABCor;
	private string mAssetBundlePath;
	private Dictionary<string, AssetBundleBaseInfo> mABBaseInfoDic = new Dictionary<string, AssetBundleBaseInfo>();
	public delegate void AssetReqCallBack(UnityEngine.Object obj, string assetName, string assetBundelName);
	private Queue<AssetReq> mAssetReqQueue = new Queue<AssetReq>();
	private List<AssetReq> mAssetReqs = new List<AssetReq>();
	private List<AssetReq> mLoadingAssetReqs = new List<AssetReq>();
	private Dictionary<string, AssetInfo> mLoadedAssetInfoDic = new Dictionary<string, AssetInfo>();
	private Dictionary<string, string> mAssetNameToABNameDic = new Dictionary<string, string>();
	private Dictionary<string, AssetBundleCreateRequest> mAbNameToCreateQequestDic = new Dictionary<string, AssetBundleCreateRequest>();
	private int mMaxLoadAssetReqCount = 5;
	private List<string> mDelayReleaseABNames = new List<string>();
	private List<bool> mLoadingAssetFlags = new List<bool>();
	private int mMaxReleaseAssetCount = 20;
	private float mTimeInterval = 50;
	private float mTimer;


	private void Awake()
	{
		instance = this;
		for (int i = 0; i < mMaxLoadAssetReqCount; i++)
		{
			mLoadingAssetFlags.Add(false);
		}
	}

	#region 获取所有资源依赖

	private void Start()
	{
		mAssetBundlePath = Path.Combine(Application.streamingAssetsPath, "AssetBundle/AssetBundle");
		if (mRequestABCor != null)
		{
			StopCoroutine(mRequestABCor);
			mRequestABCor = null;
		}
		mRequestABCor = StartCoroutine(RequestAssetBundle(0));
	}

	public IEnumerator RequestAssetBundle(int version)
	{
		AssetBundleCreateRequest abCreateRequest = AssetBundle.LoadFromFileAsync(mAssetBundlePath);
		yield return abCreateRequest;
		if (abCreateRequest.isDone)
		{
			if (abCreateRequest.assetBundle != null)
			{
				AssetBundleRequest abRequest = abCreateRequest.assetBundle.LoadAllAssetsAsync();
				yield return abRequest;
				if (abRequest.isDone)
				{
					AssetBundleManifest abMainfest = abRequest.asset as AssetBundleManifest;
					if (abMainfest != null)
					{
						string[] allABNames = abMainfest.GetAllAssetBundles();
						for (int i = 0; i < allABNames.Length; i++)
						{
							string abName = allABNames[i];
							string[] allDependence = abMainfest.GetAllDependencies(abName);
							AssetBundleBaseInfo abBaseInfo = new AssetBundleBaseInfo(abName, allDependence, version);
							mABBaseInfoDic.Add(abName, abBaseInfo);
						}
					}
				}
			}
		}
	}

	#endregion

	#region 加载资源
	public void LoadAsset<T>(string assetName, string assetBundleName, AssetReqCallBack callBack) where T:UnityEngine.Object
	{
		if (mLoadedAssetInfoDic.ContainsKey(assetName))
		{
			callBack(mLoadedAssetInfoDic[assetName].assetObj, assetName, assetBundleName);
		}
		else
		{
			AssetReq assetReq = new AssetReq(assetName, assetBundleName, callBack, false);
			mAssetReqQueue.Enqueue(assetReq);
			AddAssetReqToList();
			StartLoadAsset<T>();
		}
	}

	private void AddAssetReqToList()
	{
		mLoadingAssetReqs.Clear();
		for (int i = 0; i < mMaxLoadAssetReqCount; i++)
		{
			if (mAssetReqQueue.Count <= 0)
			{
				break;
			}
			else
			{
				AssetReq assetReq = mAssetReqQueue.Dequeue();
				if (assetReq != null)
				{
					mLoadingAssetReqs.Add(assetReq);
				}
			}
		}
	}

	private void StartLoadAsset<T>() where T:UnityEngine.Object
	{
		for (int i = 0; i < mLoadingAssetReqs.Count; i++)
		{
			AssetReq assetReq = mLoadingAssetReqs[i];
			if (assetReq != null)
			{
				StartCoroutine(LoadAssetCor<T>(assetReq, assetReq.assetBundleName, i));
			}
		}
	}

	private IEnumerator LoadAssetCor<T>(AssetReq assetReq, string abName, int curIndex) where T:UnityEngine.Object
	{
		if (assetReq == null)
		{
			if (!CheckIsHaveAssetBundle(abName))
			{
				yield break;
			}
			AssetBundleBaseInfo abBaseInfo = mABBaseInfoDic[abName];
			if (abBaseInfo.abLoadState == ABLoadStateEnum.Loaded)
			{
				yield break;
			}
			while (abBaseInfo.abLoadState == ABLoadStateEnum.Loading)
			{
				yield return null;
			}
			abBaseInfo.abLoadState = ABLoadStateEnum.Loading;
			string abPath = Application.streamingAssetsPath + "/AssetBundle/" + abBaseInfo.assetBundleName;
			AssetBundleCreateRequest abCreateRequest = AssetBundle.LoadFromFileAsync(abPath);
			yield return abCreateRequest;
			if (abCreateRequest.isDone)
			{
				abBaseInfo.abLoadState = ABLoadStateEnum.Loaded;
				abBaseInfo.refCount++;
			}
		}
		else
		{
			if (!CheckIsHaveAssetBundle(abName))
			{
				yield break;
			}
			AssetBundleBaseInfo abBaseInfo = mABBaseInfoDic[abName];
			while (abBaseInfo.abLoadState == ABLoadStateEnum.Loading)
			{
				yield return null;
			}
			if (abBaseInfo.abLoadState == ABLoadStateEnum.None)
			{
				abBaseInfo.abLoadState = ABLoadStateEnum.Loading;
			}
			if (mDelayReleaseABNames.Contains(assetReq.assetBundleName))
			{
				mDelayReleaseABNames.Remove(assetReq.assetBundleName);
			}
			for (int i = 0; i < abBaseInfo.dependceArr.Length; i++)
			{
				string assetBundlename = abBaseInfo.dependceArr[i];
				StartCoroutine(LoadAssetCor<T>(null, assetBundlename,-1));
			}
			AssetBundleCreateRequest abCreateRequest = null;
			string abPath = Application.streamingAssetsPath + "/AssetBundle/" + abBaseInfo.assetBundleName;
			if (mAbNameToCreateQequestDic.ContainsKey(abName))
			{
				abCreateRequest = mAbNameToCreateQequestDic[abName];
			}
			else
			{
				abCreateRequest = AssetBundle.LoadFromFileAsync(abPath);
				yield return abCreateRequest;
			}
			if (abCreateRequest.isDone)
			{
				abBaseInfo.abLoadState = ABLoadStateEnum.Loaded;
				abBaseInfo.assetBundle = abCreateRequest.assetBundle;
				if (!mAbNameToCreateQequestDic.ContainsKey(abName))
				{
					mAbNameToCreateQequestDic.Add(abName, abCreateRequest);
				}
			}
			if (abBaseInfo.abLoadState == ABLoadStateEnum.Loaded)
			{
				if (!abBaseInfo.assetInfoDic.ContainsKey(assetReq.assetBundleName))
				{
					AssetInfo assetInfo = new AssetInfo(assetReq.assetName,null, AssetLoadStateEnum.Loading);
					Dictionary<string, AssetInfo> dic = new Dictionary<string, AssetInfo>();
					dic.Add(assetReq.assetName, assetInfo);
					abBaseInfo.assetInfoDic.Add(assetReq.assetBundleName, dic);
					AssetBundleRequest abRequest = abBaseInfo.assetBundle.LoadAssetAsync<T>(assetReq.assetName);
					yield return abRequest;
					if (abRequest.isDone)
					{
						assetInfo.assetObj = abRequest.asset;
						string assetName = abRequest.asset.name;
						if (!mLoadedAssetInfoDic.ContainsKey(assetName))
						{
							mLoadedAssetInfoDic.Add(assetName, assetInfo);
						}
						if (!mAssetNameToABNameDic.ContainsKey(assetName))
						{
							mAssetNameToABNameDic.Add(assetName,abName);
						}
					}
				}
				else
				{
					AssetInfo assetInfo = new AssetInfo(assetReq.assetName, null, AssetLoadStateEnum.Loading);
					if (!abBaseInfo.assetInfoDic.ContainsKey(assetReq.assetBundleName))
					{
						Dictionary<string, AssetInfo> dic = new Dictionary<string, AssetInfo>();
						dic.Add(assetReq.assetName, assetInfo);
						abBaseInfo.assetInfoDic.Add(assetReq.assetBundleName, dic);
					}
					else
					{
						if (!abBaseInfo.assetInfoDic[assetReq.assetBundleName].ContainsKey(assetReq.assetName))
						{
							abBaseInfo.assetInfoDic[assetReq.assetBundleName].Add(assetReq.assetName, assetInfo);
						}
					}
					AssetBundleRequest abRequest = abBaseInfo.assetBundle.LoadAssetAsync<T>(assetReq.assetName);
					yield return abRequest;
					if (abRequest.isDone)
					{
						assetInfo.assetObj = abRequest.asset;
						string assetName = abRequest.asset.name;
						if (!mLoadedAssetInfoDic.ContainsKey(assetName))
						{
							mLoadedAssetInfoDic.Add(assetName, assetInfo);
						}
						if (!mAssetNameToABNameDic.ContainsKey(assetName))
						{
							mAssetNameToABNameDic.Add(assetName, abName);
						}
					}
				}
				UnityEngine.Object assetObj = abBaseInfo.assetInfoDic[assetReq.assetBundleName][assetReq.assetName].assetObj;
				assetReq.assetReqCallBack(assetObj, assetReq.assetName, abBaseInfo.assetBundleName);
			}
			abBaseInfo.refCount++;
			mLoadingAssetFlags[curIndex] = false;
			yield return new WaitForEndOfFrame();
			if (!mLoadingAssetFlags.Contains(true))
			{
				if (mAssetReqQueue.Count > 0)
				{
					AddAssetReqToList();
					StartLoadAsset<T>();
				}
			}
		}
	}

	private bool CheckIsHaveAssetBundle(string abName)
	{
		return mABBaseInfoDic.ContainsKey(abName);
	}

	#endregion

	#region 释放资源

	public void ReleaseAsset(string abName,bool isDelayRelease, AssetReqCallBack callBack)
	{
		if (mABBaseInfoDic.ContainsKey(abName))
		{
			AssetBundleBaseInfo abBaseInfo = mABBaseInfoDic[abName];
			abBaseInfo.refCount--;
			if (abBaseInfo.refCount < 0)
			{
				abBaseInfo.refCount = 0;
			}
			if (isDelayRelease)
			{
				mDelayReleaseABNames.Add(abName);
			}
			else
			{
				if (abBaseInfo.abLoadState == ABLoadStateEnum.Loaded && abBaseInfo.assetBundle != null && abBaseInfo.refCount == 0)
				{
					UnLoadAssetBundle(abName);
				}
			}
			if (callBack != null)
			{
				callBack(null,null,abName);
			}
		}
	}

	private void UnLoadAssetBundle(string abName)
	{
		AssetBundleBaseInfo abBaseInfo = mABBaseInfoDic[abName];
		if (abBaseInfo != null)
		{
			abBaseInfo.assetInfoDic.Clear();
			abBaseInfo.assetBundle.Unload(true);
			abBaseInfo.abLoadState = ABLoadStateEnum.None;
			abBaseInfo.assetBundle = null;
			if (mAbNameToCreateQequestDic.ContainsKey(abName))
			{
				mAbNameToCreateQequestDic.Remove(abName);
			}
			foreach (var item in mAssetNameToABNameDic.Keys)
			{
				if (mAssetNameToABNameDic[item].Equals(abName))
				{
					Debug.Log("UnLoadAssetBundle.assetName " + item + " abName " + abName);
					mLoadedAssetInfoDic.Remove(item);
				}
			}
			Debug.Log("UnLoadAssetBundle.abName " + abName);
		}
	}

	private void DelayReleaseAsset()
	{
		if (mDelayReleaseABNames.Count > mMaxReleaseAssetCount)
		{
			int removeIndex = 0;
			for (int i = 0; i < mDelayReleaseABNames.Count; i++)
			{
				string abName = mDelayReleaseABNames[i];
				UnLoadAssetBundle(abName);
				removeIndex++;
			}
			mDelayReleaseABNames.RemoveRange(0, removeIndex);
		}
	}

	private void Update()
	{
		if (mTimer >= mTimeInterval)
		{
			DelayReleaseAsset();
		}
		else
		{
			mTimer += Time.deltaTime;
		}
	}

	#endregion

	public class AssetBundleBaseInfo
	{
		public string assetBundleName;
		public string[] dependceArr;
		public int refCount;
		public int version;
		public AssetBundle assetBundle;
		public ABLoadStateEnum abLoadState;
		public Dictionary<string, Dictionary<string, AssetInfo>> assetInfoDic = new Dictionary<string, Dictionary<string, AssetInfo>>();

		public AssetBundleBaseInfo(string abName, string[] dependences, int version)
		{
			assetBundleName = abName;
			dependceArr = dependences;
			this.version = version;
		}
	}

	public class AssetInfo
	{
		public UnityEngine.Object assetObj;
		public string assetName;
		public AssetLoadStateEnum assetLoadStateEnum;

		public AssetInfo(string assetName, UnityEngine.Object asset, AssetLoadStateEnum state)
		{
			assetObj = asset;
			assetLoadStateEnum = state;
		}
	}

	public class AssetReq
	{
		public string assetName;
		public string assetBundleName;
		public AssetReqCallBack assetReqCallBack;
		public bool isDelay;

		public AssetReq(string assetName, string abName, AssetReqCallBack callBack, bool isDelay)
		{
			this.assetName = assetName;
			assetBundleName = abName;
			assetReqCallBack = callBack;
			this.isDelay = isDelay;
		}
	}
}

 

3.加载资源

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class Main : MonoBehaviour {

	public Button loadAssetBtn;
	public Button releaseAssetBtn;
	public Button loadBgBtn;
	public Button releaseBgBtn;
	public Button loadScriptTabelBtn;
	public Button releasecriptTabelBtn;
	public Image nameImg;
	public Image bgImg;
	public Text scriptTabel_text;

	private void Start()
	{
		loadAssetBtn.onClick.AddListener(LoadImg);
		releaseAssetBtn.onClick.AddListener(ReleaseImg);
		loadBgBtn.onClick.AddListener(LoadBg);
		releaseBgBtn.onClick.AddListener(ReleaseBg);
		loadScriptTabelBtn.onClick.AddListener(LoadScriptTable);
		releasecriptTabelBtn.onClick.AddListener(ReleaseScriptTable);
	}

	private void LoadCube()
	{
		AssetBundleManager.Instance.LoadAsset<GameObject>("Cube","prefab/cube",(obj,assetName,assetBundleName)=> 
		{
			GameObject go = Instantiate(obj) as GameObject;
		});
	}

	private void ReleaseCube()
	{
		AssetBundleManager.Instance.ReleaseAsset("prefab/cube",false,null);
	}

	private void LoadImg()
	{
		AssetBundleManager.Instance.LoadAsset<Sprite>("wy_bg_19", "ui/common",(obj, assetName, assetBundleName) =>
		{
			Sprite sprite = (Sprite)obj;
			nameImg.sprite = sprite;
		});
	}

	private void ReleaseImg()
	{
		AssetBundleManager.Instance.ReleaseAsset("ui/common", false, null);
	}

	private void LoadBg()
	{
		AssetBundleManager.Instance.LoadAsset<Sprite>("drawCardBg1", "ui/common", (obj, assetName, assetBundleName) =>
		{
			Sprite sprite = (Sprite)obj;
			bgImg.sprite = sprite;
		});
	}

	private void ReleaseBg()
	{
		AssetBundleManager.Instance.ReleaseAsset("ui/common", false, null);
	}

	private void LoadScriptTable()
	{
		AssetBundleManager.Instance.LoadAsset<ScriptableObject>("ScriptTableTest", "scripttable/scripttabletest", (obj, assetName, assetBundleName) =>
		{
			ScriptTableTest scriptTabel = (ScriptTableTest)obj;
			Debug.Log("LoadScriptTable.scriptTabel " + scriptTabel);
			scriptTabel_text.text = scriptTabel.ID + "---" + scriptTabel.name;
		});
	}

	private void ReleaseScriptTable()
	{
		AssetBundleManager.Instance.ReleaseAsset("scripttable/scrpttabletest", false, null);
	}
}

 

zcc858079762
关注
专栏目录
AssetBundle打包类型和加载卸载与资源管理(加载卸载超详细)
weixin_56104874的博客
07-11 1443
不会在AssetBundle中包含类型信息。使用存储在AssetBundle中的对象的id的哈希构建AssetBundle。强制重建AssetBundles。执行增量构建检查时忽略类型树更改。将哈希附加到assetBundle名称。StrictMode如果在其中报告任何错误，则不允许构建成功。不实际构建它们。通过文件名禁用AssetBundle的加载。通过带扩展名的文件名禁用AssetBundle的加载。一般都是默认ChunkBasedCompression是最常用的).........
assetbundle能不能删除_U3D assetbundle加载与卸载的深入理解
weixin_39557813的博客
12-19 271
usingUnityEngine;usingSystem.Collections;usingSystem;public classtestLoadFromAB : MonoBehaviour {IEnumerator DownloadAndCache(){while (!Caching.ready)yield return null;//注意，从本地加载时，必须使用前缀 file:///或file...
AssetBundle系统之（二）加载卸载
东北砍王的栖息地
02-22 411
因为AssetBundle，必须要从指定bundle中加载资源。 如果没有打包，就不能加载。 那么在开发环境中，如果每次添加或者修改资源都需要重新打包，那就很麻烦，怎么解决？ 1.增量打包，且不同的功能拆分成不同AssetBundle，只需打修改的。而且是增量的形式，不需要那么长时间。 2.使用之前生成的自定义依赖关系表，读取资源名对应的资源路径，通过编辑器下的AssetDataBase.Load方法进行加载。 2 的优点：无需每次打包 2 的缺点：可能表现形式不一样，比如说一个面板在editor下加载完成
Unity热更新之AssetBundle的加载与卸载
qq_14914623的博客
07-28 969
unity3d想要从一个AssetBundle里Load出资源，必须将该AssetBundle及该AssetBundle依赖到的其他AssetBundle都先加载到内存中，然后才能从该AssetBundle中Load资源。我们怎么知道一个AssetBundle依赖到了哪些其他的AssetBundle呢，这就需要提一下unity的打包机制。Unity3d调用打包函数BuildPipeline.Bui...
AssetBundle资源打包、本地加载和卸载以及问题总结
weixin_45347704的博客
11-22 818
AssetBundle资源打包、本地加载和卸载以及问题总结
AssetBundle 资源打包 加载 卸载
icebergliu1234的博客
07-10 3309
    1 给要打包的资源设置标记，表示对应的包名： 　　   2 Unity5 AssetBundle不需要我们来管理引用关系了       3 可以使用代码批量设置包名 AssetImporter ai = AssetImporter.GetAtPath(assetPath); i.assetBundleName = xxx; ai.assetBundleVaria...
关于AssetBundle的卸载
weixin_45979158的博客
02-07 1160
关于AssetBundle的卸载 又坐了一天月子，继续写文章找状态。 本文是关于 卸载AssetBundle 的一些知识点。 下图是一个最简单的从 AssetBundle 加载 Asset 并 实例化 的流程： 这里的 Bundle 在加载完 资源A 后就没用了，我们可以通过 AssetBundle.Unload(false) 把它卸掉，只保留住 资源A。 如果 资源A 也没用了，我们可以通过 ...
AssetBundle加载冗余分析插件.rar
最新发布
09-14
AssetBundle加载冗余分析插件是一个工具，帮助开发者识别和解决在使用AssetBundle过程中可能存在的无效或重复的加载操作，从而提高应用性能。 在Unity项目中， AssetBundle的加载通常涉及以下步骤： 1. **创建...
AssetBundle资源加载，AssetBundle-Browser打包助手
11-10
一旦AssetBundle加载完成，就可以通过AssetBundle对象的`LoadAsset`或`LoadAssetAsync`方法来获取具体的资源实例。 5. **释放资源**：为了防止内存泄漏，当不再需要某个Asset时，需要正确地卸载AssetBundle。使用`...
Unity网络交互☀️AssetBundle二、：如何下载、加载与卸载AssetBundle
星河造梦坊
02-19 2592
AssetBundle二、：如何下载、加载与卸载AssetBundle
正确使用AssetBundle加载和卸载
海洋个人博客
10-09 3333
在使用Unity开发项目时，AssetBundle是必须使用的，对资源进行打包加载，因为移动端游戏包体的大小对用户体验非常重要，对内存的使用更加重要，下面我们就介绍一下关于AssetBundlle的加载和卸载，虽然网上关于这方面的介绍已经非常多了，自己还是总结一下： 当从本地加载AssetBundle文件时，可以通过缓存后者AssetBundle.LoadFromFile加载文件，它们对于内存的消...
【Unity 3D】AssetBundle打包、上传、加载、卸载详解及演示（附源码）
showswoller的博客
01-07 2943
【Unity 3D】AssetBundle打包、上传、加载、卸载详解及演示（附源码）
[游戏开发][Unity]Assetbundle加载篇（9) AB包卸载
liuyongjie1992的博客
06-09 625
[游戏开发][Unity]Assetbundle加载篇（9）
【Unity】AssetBundle的加载与卸载方式摘要
Arvin的博客
05-22 2285
AssetBundle的加载与卸载方式摘要 文中Object和Asset两个词用的比较混乱，但是Unity的官方英文文档里就是不停地在用这两个词，所以这里也没有翻译。 用于加载AssetBundle的API AssetBundle.LoadFromFile[Async]() 首选方法（在速度、磁盘使用和内存占用方面都很高效） 适用于从本地存储加载未压缩或LZ4压缩的AssetBundle...
【Unity3D】基于AssetBundle实现资源热更新
little_fat_sheep
12-13 4245
Unity3D 本地资源一般放在 Resources 目录下，但是 Resouces 文件夹的大小不能超过 2G，使用 AssetBundle 管理资源可以解决 Resources 文件夹受限问题。AssetBundle 主要用于管理资源，配合 AssetDatabase 和 AssetImporter 可以实现资源重命名，配合 BuildPipeline 可以实现资源压缩，配合 WWW 或 UnityWebRequest 可以实现加载服务器资源。
【Unity】AssetBundle资源异步加载以及AB包卸载
weixin_43453797的博客
09-02 3021
AssetBundle异步加载，封装AB包加载器（完结）。
Unity之AssetBundle的加载与卸载
莫问夜雨的博客
03-16 5309
AssetBundle AssetBundle(阿赛特邦豆)是Unity官方推荐的资源加载方式，网上对AssetBundle的介绍有很多，且在了解了Unity对资源的加载机制后，其本身没有什么特别难以理解的地方了，因此在这不过多介绍，仅挑选几个关键点进行阐述。 AssetBundle的生成 生成AssetBundle有很多种方式，在此仅简单说一下比较常用的方式，使用BuildPipeline...
Unity中几种资源的加载卸载方式
weixin_37753983的博客
11-25 2199
Unity目前有四种资源加载方式（个人接触到的，基于2019 LTS）： Resources AssetBundle Addressable AssetDatabase 本文内容刚更新到Resoureces部分接口。 Resources Resources类允许找到并且访问对象包括资产。提供了加载和卸载资产的方式。 加载: Resources.Load Resources.LoadAll Resources.LoadAsync Resources.Load: public static T Loa
js添加事件和移除事件:addEventListener()与removeEventListener()
热门推荐
Just do it
03-28 14万+
作用：      addEventListener()与removeEventListener()用于处理指定和删除事件处理程序操作。      它们都接受3个参数：事件名、事件处理的函数和布尔值。      布尔值参数是true，表示在捕获阶段调用事件处理程序；如果是false，表示在冒泡阶段调用事件处理程序。 示例： 环境：移动端，界面禁止触摸事件 要在bo
unity assetbundle加载资源
04-06
Unity AssetBundle 是 Unity 引擎中的一种资源打包方式，通过打包场景、模型、材质、动画、代码等资源到一个 AssetBundle 文件中，便于在需要时动态加载和卸载，提高游戏的整体性能和加载速度。加载 AssetBundle ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值