精华内容
下载资源
问答
  • Unity3D动态加载资源

    2016-07-12 14:16:26
    unity3d动态加载资源案例,里面有完整的代码和Demo
  • unity3d动态加载资源

    2019-07-07 01:53:48
    Unity3D的网络游戏中实现资源动态加载 分类:最新学习2012-06-14 13:351127人阅读评论(0)收藏举报 网络游戏nullvectorjson游戏string 用Unity3D制作基于web的网络游戏,不可避免的会用到一个技术-资源动态...
    分类: 最新学习2012-06-14 13:35 1127人阅读 评论(0) 收藏 举报
    用Unity3D制作基于web的网络游戏,不可避免的会用到一个技术-资源动态加载。比如想加载一个大场景的资源,不应该在游戏的开始让用户长时间等待全部资源的加载完毕。应该优先加载用户附近的场景资源,在游戏的过程中,不影响操作的情况下,后台加载剩余的资源,直到所有加载完毕。

    本文包含一些代码片段讲述实现这个技术的一种方法。本方法不一定是最好的,希望能抛砖引玉。代码是C#写的,用到了Json,还有C#的事件机制。

    在讲述代码之前,先想象这样一个网络游戏的开发流程。首先美工制作场景资源的3D建模,游戏设计人员把3D建模导进Unity3D,托托拽拽编辑场景,完成后把每个gameobject导出成XXX.unity3d格式的资源文件(参看BuildPipeline),并且把整个场景的信息生成一个配置文件,xml或者Json格式(本文使用Json)。最后还要把资源文件和场景配置文件上传到服务器,最好使用CMS管理。客户端运行游戏时,先读取服务器的场景配置文件,再根据玩家的位置从服务器下载相应的资源文件并加载,然后开始游戏,注意这里并不是下载所有的场景资源。在游戏的过程中,后台继续加载资源直到所有加载完毕。

    一个简单的场景配置文件的例子:
    MyDemoSence.txt
    复制代码
    1. {
    2.     "AssetList" : [{
    3.         "Name" : "Chair 1",
    4.         "Source" : "Prefabs/Chair001.unity3d",
    5.         "Position" : [2,0,-5],
    6.         "Rotation" : [0.0,60.0,0.0]
    7.     },
    8.     {
    9.         "Name" : "Chair 2",
    10.         "Source" : "Prefabs/Chair001.unity3d",
    11.         "Position" : [1,0,-5],
    12.         "Rotation" : [0.0,0.0,0.0]
    13.     },
    14.     {
    15.         "Name" : "Vanity",
    16.         "Source" : "Prefabs/vanity001.unity3d",
    17.         "Position" : [0,0,-4],
    18.         "Rotation" : [0.0,0.0,0.0]
    19.     },
    20.     {
    21.         "Name" : "Writing Table",
    22.         "Source" : "Prefabs/writingTable001.unity3d",
    23.         "Position" : [0,0,-7],
    24.         "Rotation" : [0.0,0.0,0.0],
    25.         "AssetList" : [{
    26.             "Name" : "Lamp",
    27.             "Source" : "Prefabs/lamp001.unity3d",
    28.             "Position" : [-0.5,0.7,-7],
    29.             "Rotation" : [0.0,0.0,0.0]
    30.         }]
    31.     }]
    32. }

    AssetList:场景中资源的列表,每一个资源都对应一个unity3D的gameobject
    Name:gameobject的名字,一个场景中不应该重名
    Source:资源的物理路径及文件名
    Position:gameobject的坐标
    Rotation:gameobject的旋转角度
    你会注意到Writing Table里面包含了Lamp,这两个对象是父子的关系。配置文件应该是由程序生成的,手工也可以修改。另外在游戏上线后,客户端接收到的配置文件应该是加密并压缩过的。

    主程序:
    复制代码
    1. 。。。
    2. public class MainMonoBehavior : MonoBehaviour {
    3.     public delegate void MainEventHandler(GameObject dispatcher);
    4.     public event MainEventHandler StartEvent;
    5.     public event MainEventHandler UpdateEvent;
    6.     public void Start() {
    7.         ResourceManager.getInstance().LoadSence("Scenes/MyDemoSence.txt");
    8.         if(StartEvent != null){
    9.             StartEvent(this.gameObject);
    10.         }
    11.     }
    12.     public void Update() {
    13.         if (UpdateEvent != null) {
    14.             UpdateEvent(this.gameObject);
    15.         }
    16.     }
    17. }
    18. 。。。
    19. }

    这里面用到了C#的事件机制,大家可以看看我以前翻译过的国外一个牛人的文章。C# 事件和Unity3D
    在start方法里调用ResourceManager,先加载配置文件。每一次调用update方法,MainMonoBehavior会把update事件分发给ResourceManager,因为ResourceManager注册了MainMonoBehavior的update事件。

    ResourceManager.cs
    复制代码
    1. 。。。
    2. private MainMonoBehavior mainMonoBehavior;
    3. private string mResourcePath;
    4. private Scene mScene;
    5. private Asset mSceneAsset;
    6. private ResourceManager() {
    7.     mainMonoBehavior = GameObject.Find("Main Camera").GetComponent<MainMonoBehavior>();
    8.     mResourcePath = PathUtil.getResourcePath();
    9. }
    10. public void LoadSence(string fileName) {
    11.     mSceneAsset = new Asset();
    12.     mSceneAsset.Type = Asset.TYPE_JSON;
    13.     mSceneAsset.Source = fileName;
    14.     mainMonoBehavior.UpdateEvent += OnUpdate;
    15. }
    16. 。。。

    在LoadSence方法里先创建一个Asset的对象,这个对象是对应于配置文件的,设置type是Json,source是传进来的“Scenes/MyDemoSence.txt”。然后注册MainMonoBehavior的update事件。
    复制代码
    1. public void OnUpdate(GameObject dispatcher) {
    2.     if (mSceneAsset != null) {
    3.         LoadAsset(mSceneAsset);
    4.         if (!mSceneAsset.isLoadFinished) {
    5.             return;
    6.         }
    7.         //clear mScene and mSceneAsset for next LoadSence call
    8.         mScene = null;
    9.         mSceneAsset = null;
    10.     }
    11.     mainMonoBehavior.UpdateEvent -= OnUpdate;
    12. }

    OnUpdate方法里调用LoadAsset加载配置文件对象及所有资源对象。每一帧都要判断是否加载结束,如果结束清空mScene和mSceneAsset对象为下一次加载做准备,并且取消update事件的注册。

    最核心的LoadAsset方法:
    复制代码
    1. private Asset LoadAsset(Asset asset) {
    2.     string fullFileName = mResourcePath + "/" + asset.Source;
    3.     
    4.     //if www resource is new, set into www cache
    5.     if (!wwwCacheMap.ContainsKey(fullFileName)) {
    6.         if (asset.www == null) {
    7.             asset.www = new WWW(fullFileName);
    8.             return null;
    9.         }
    10.         if (!asset.www.isDone) {
    11.             return null;
    12.         }
    13.         wwwCacheMap.Add(fullFileName, asset.www);
    14.     }
    15. 。。。

    传进来的是要加载的资源对象,先得到它的物理地址,mResourcePath是个全局变量保存资源服务器的网址,得到fullFileName类似http://www.mydemogame.com/asset/Prefabs/xxx.unity3d。然后通过wwwCacheMap判断资源是否已经加载完毕,如果加载完毕把加载好的www对象放到Map里缓存起来。看看前面Json配置文件,Chair 1和Chair 2用到了同一个资源Chair001.unity3d,加载Chair 2的时候就不需要下载了。如果当前帧没有加载完毕,返回null等到下一帧再做判断。这就是WWW类的特点,刚开始用WWW下载资源的时候是不能马上使用的,要等待诺干帧下载完成以后才可以使用。可以用yield返回www,这样代码简单,但是C#要求调用yield的方法返回IEnumerator类型,这样限制太多不灵活。

    继续LoadAsset方法:
    复制代码
    1. 。。。
    2.     if (asset.Type == Asset.TYPE_JSON) { //Json
    3.         if (mScene == null) {
    4.             string jsonTxt = mSceneAsset.www.text;
    5.             mScene = JsonMapper.ToObject<Scene>(jsonTxt);
    6.         }
    7.         
    8.         //load scene
    9.         foreach (Asset sceneAsset in mScene.AssetList) {
    10.             if (sceneAsset.isLoadFinished) {
    11.                 continue;
    12.             } else {
    13.                 LoadAsset(sceneAsset);
    14.                 if (!sceneAsset.isLoadFinished) {
    15.                     return null;
    16.                 }
    17.             }
    18.         }
    19.     }
    20. 。。。

    代码能够运行到这里,说明资源都已经下载完毕了。现在开始加载处理资源了。第一次肯定是先加载配置文件,因为是Json格式,用JsonMapper类把它转换成C#对象,我用的是LitJson开源类库。然后循环递归处理场景中的每一个资源。如果没有完成,返回null,等待下一帧处理。

    继续LoadAsset方法:
    复制代码
    1. 。。。
    2.     else if (asset.Type == Asset.TYPE_GAMEOBJECT) { //Gameobject
    3.         if (asset.gameObject == null) {
    4.             wwwCacheMap[fullFileName].assetBundle.LoadAll();
    5.             GameObject go = (GameObject)GameObject.Instantiate(wwwCacheMap[fullFileName].assetBundle.mainAsset);
    6.             UpdateGameObject(go, asset);
    7.             asset.gameObject = go;
    8.         }
    9.         if (asset.AssetList != null) {
    10.             foreach (Asset assetChild in asset.AssetList) {
    11.                 if (assetChild.isLoadFinished) {
    12.                     continue;
    13.                 } else {
    14.                     Asset assetRet = LoadAsset(assetChild);
    15.                     if (assetRet != null) {
    16.                         assetRet.gameObject.transform.parent = asset.gameObject.transform;
    17.                     } else {
    18.                         return null;
    19.                     }
    20.                 }
    21.             }
    22.         }
    23.     }
    24.     asset.isLoadFinished = true;
    25.     return asset;
    26. }

    终于开始处理真正的资源了,从缓存中找到www对象,调用Instantiate方法实例化成Unity3D的gameobject。UpdateGameObject方法设置gameobject各个属性,如位置和旋转角度。然后又是一个循环递归为了加载子对象,处理gameobject的父子关系。注意如果LoadAsset返回null,说明www没有下载完毕,等到下一帧处理。最后设置加载完成标志返回asset对象。

    UpdateGameObject方法:
    复制代码
    1. private void UpdateGameObject(GameObject go, Asset asset) {
    2.     //name
    3.     go.name = asset.Name;
    4.     //position
    5.     Vector3 vector3 = new Vector3((float)asset.Position[0], (float)asset.Position[1], (float)asset.Position[2]);
    6.     go.transform.position = vector3;
    7.     //rotation
    8.     vector3 = new Vector3((float)asset.Rotation[0], (float)asset.Rotation[1], (float)asset.Rotation[2]);
    9.     go.transform.eulerAngles = vector3;
    10. }

    这里只设置了gameobject的3个属性,眼力好的同学一定会发现这些对象都是“死的”,因为少了脚本属性,它们不会和玩家交互。设置脚本属性要复杂的多,编译好的脚本随着主程序下载到本地,它们也应该通过配置文件加载,再通过C#的反射创建脚本对象,赋给相应的gameobject。

    最后是Scene和asset代码:
    复制代码
    1. public class Scene {
    2.     public List<Asset> AssetList {
    3.         get;
    4.         set;
    5.     }
    6. }
    7. public class Asset {
    8.     public const byte TYPE_JSON = 1;
    9.     public const byte TYPE_GAMEOBJECT = 2;
    10.     public Asset() {
    11.         //default type is gameobject for json load
    12.         Type = TYPE_GAMEOBJECT;
    13.     }
    14.     public byte Type {
    15.         get;
    16.         set;
    17.     }
    18.     public string Name {
    19.         get;
    20.         set;
    21.     }
    22.     public string Source {
    23.         get;
    24.         set;
    25.     }
    26.     public double[] Bounds {
    27.         get;
    28.         set;
    29.     }
    30.     
    31.     public double[] Position {
    32.         get;
    33.         set;
    34.     }
    35.     public double[] Rotation {
    36.         get;
    37.         set;
    38.     }
    39.     public List<Asset> AssetList {
    40.         get;
    41.         set;
    42.     }
    43.     public bool isLoadFinished {
    44.         get;
    45.         set;
    46.     }
    47.     public WWW www {
    48.         get;
    49.         set;
    50.     }
    51.     public GameObject gameObject {
    52.         get;
    53.         set;
    54.     }
    55. }


    代码就讲完了,在我实际测试中,会看到gameobject一个个加载并显示在屏幕中,并不会影响到游戏操作。代码还需要进一步完善适合更多的资源类型,如动画资源,文本,字体,图片和声音资源。

    动态加载资源除了网络游戏必需,对于大公司的游戏开发也是必须的。它可以让游戏策划(负责场景设计),美工和程序3个角色独立出来,极大提高开发效率。试想如果策划改变了什么NPC的位置,美工改变了某个动画,或者改变了某个程序,大家都要重新倒入一遍资源是多么低效和麻烦的一件事。

    转载于:https://www.cnblogs.com/lifesteven/p/3673512.html

    展开全文
  • unity3D动态加载

    2014-06-13 10:15:38
    unity3D动态加载游戏资源,希望能给大家起到帮助
  •  当然本文的动态加载场景资源,是以玩家为中心,玩家的视野为半径进行加载。首先让美术将整个场景以一定的格式写入XML文件中,然后在程序开始运行时读取美术给我们提供的XML文件,然后遍历这个xml文件中的所有...

      当要加载一个较大的场景,长时间等待势必会影响用户体验,并且一个较大场景全部加载到场景中也会影响操作流畅度。不可避免的需要用一个技术就是在Unity中进行动态的加载场景中的资源。

      当然本文的动态加载场景资源,是以玩家为中心,玩家的视野为半径进行加载。首先让美术将整个场景以一定的格式写入XML文件中,然后在程序开始运行时读取美术给我们提供的XML文件,然后遍历这个xml文件中的所有节点找到所有处于玩家周围一定范围内的节点并加载即可。

      准备工作:

          首先我们要定义一个对象GameObjectInfo,其中包括这个资源的名称(string)、位置(Vector3)、旋转(Vector3)、缩放(Vector3)、所有子节点(List<T>)、Prefab路径(string)、包围盒(Bounds)等。 

    1,将场景资源写入到XML文件中

      当美术做好了我们要的模型之后,我们使用我们写的编辑器扩展程序将模型的属性写入到XML中。
      首先这个方法对于美术制作场景有一定的要求:
                           1,场景中的节点分为两类,分组节点和模型节点
                           2,分组节点上不能挂有任何组件,其作用仅在于将其子节点作为一个整体分组。
                           3,模型节点是从资源里加载的节点,可以从Prefab中加载,也可以从网络上下载。

      首先,我们在编辑器中添加菜单( [MenuItem("Helper/SaveToXml")]),弹出SaveToXmlEdit,将模型的根节点拖到ObjectField中,点击SaveToXml按钮将获取根节点并将其与其子节点的属性以及对应关系保存到xml文件中。而点击LoadFromXml则是会弹出一个选择要导入到场景中的模型信息的xml文件.

      那下面呢就讲下他是怎么实现的吧

      SaveToXml

      在编辑器中获取选择对象,再选择要保存的路径。

      将获取到的根节点下的所有子节点,实例化成GameObjectInfo对象,并将其序列化成xml文件。

      LoadFromXml 

      选择文件,将获取到的xml文件进行反序列化GameObjectInfo对象。

      首先创建一个空的Transform t,然后判断当前GameObjectInfo是否是Prefab,如果是则获取使用其PrefabPath加载其Prefab(”AssetDatabase.LoadAssetAtPath<Transform>(info.prefabPath)“),如果不是,则Tranform t=new GameObject().transform;

      然后将GameObjectInfo中的属性(名称/位置/旋转/缩放/等)将t赋值。

      最后获取他的子对象,并使用递归的方式将其子对象进行创建和赋值。

      (注:如果当前对象是Prefab时,那么当前对象就不用再获取他的子对象了) 

    2,玩家移动时加载

      在Start中加载xml文件,反序列化GameObjectInfo。

      在Update中根据玩家当前的位置(P)遍历所XML节点:
        1。如果P在当前节点的包围盒之内或和包围盒的距离小于viewDistance:
          a  如果当前节点尚未加载,那么加载当前节点;如果当前节点是分组节点,那么递归遍历其子节点。
          b  如果当前节点已经加载,那么将其显示出来。
        2。否则如果当前节点已经加载那么将其隐藏。

      在实现上,使用一个键值对字典用来判断某个节点是否加载,用一个枚举NodeBehaviour用来表示对当前节点作出什么处理(Load/Hide/None)

      在Update中获取玩家的位置/GameObjectInfo/viewDistance根据GameObject中记录的包围盒进行计算对象是否需要被加载,在首次加载中如果GameObjectInfo需要被加载就将NodeBehaviour设置为Load,并将其添加到键值对中,以供下次加载时不用再次创建对象。然后既然前句判断玩家不在当前GameObjectInfo的包围盒内那么则将其NodeBehaviour设置为Hide。

      最后,根据NodeBehaviour状态是否是将当前的GameObjectInfo是加载还是隐藏。

      Load状态:

          首先判断在保存GameObjectInfo和对象应创建的GameObject的键值对中是否存在,如果不存在,判断是否是Prefab,如果是prefab就获取其Prefab,如果不是则(new GameObject()).transform。然后将其名称/座标/旋转/缩放赋值,并将其保存于键值对中。

          如果存在,将判断些对象的activeSelf是否为false,如果为false,则将其设置为true.

          最后,判断其是否有子对象,如果有子对象,递归加载。

      Hide状态:

          判断在键值对中是否存在当前GameObjectInfo,如果存在就将此对象的状态设置为隐藏。

    3,需特殊处理的物体
      如果有一些物体需要特殊处理,比如灯光/地形等需要在场景中始终显示,并不需要根据与玩家的距离进行动态的加载。那么我们就需要将他作为一个特殊的物体进行处理了。   

       首先我们将新建一个脚本LoadFlag挂在我们需要特殊处理的物体上,这个脚本设置了一个枚举值Flag,分别是Dynamic/Allways/Ignore这三个状态,然后我们就可以根据自己的需要来选择其所需要的加载状态了。
      我们还需要将GameObjectInfo中增加一个加载标识LoadFlag.Flag flag。
      比如说灯光,我们需要他在场景运行时就一直加载到场景中无需隐藏,那么我们将这个脚本挂在这个灯光上,并设置其状态为Allways(一直显示),那么我们在给美术将模型写入xml的脚本中如果我们的模型中有LoadFlag这个脚本时,我们就将这个这个脚本中的枚举值赋值为GameObjectInfo中的flag属性中。
      在程序使用的脚本中,当在场景运行时,我们在读取xml文档的时候实例化GameObjectInfo时,在解读加载到场景中时如我们首先判断GameObjectInfo中的flag属性,然后flag值为Allways那么我们就将NodeBehaviour设置为Load,如果flag值为Dynamic那么参考如上第二点玩家移动时加载,flag值为Ignore那么我们就将NodeBehaviour设置为None。

      

     

    转载于:https://www.cnblogs.com/cathytong/p/5091608.html

    展开全文
  • Unity3d游戏开发中,我们经常需要频繁创建物体,而其中的资源读取就是个问题。其中Unity为我们资源读取提供了几种基本方法,总的来说分为从内部读取和从外部读取。 1.Resources.Load() 该方法是从项目资源的...

    在Unity3d游戏开发中,我们经常需要频繁创建物体,而其中的资源读取就是个问题。其中Unity为我们资源读取提供了几种基本方法,总的来说分为从内部读取和从外部读取。

    1.Resources.Load()

    该方法是从项目资源的Resources文件夹进行读取,为内部读取的方法。在项目打包时,Resources文件夹的所有资源会被压缩并加密,并打包进APK中,该文件为只读类型。建议只把需要的预制体打包进去,因为不需要的资源如果放进该文件夹会一起打包出去,造成空间的浪费。在路径参数上,参数默认为Resources/ + "(需要的资源路径)",根据需要输入即可。

    2.WWW类读取

    该方法是从外部读取,即从外部下载,会比从内部读取的时间要稍微慢一点。在安卓开发中,在打包时会自动生成一个名为StreamingAssets的文件夹,而我们可以手动生成该文件夹并把资源放进去,该文件与Resources对比,并没有进行加密,是完全打包到发布包中,而该文件夹可以通过www方式进行读取。

    示例:

            string localPath;//定义资源路径
            #if UNITY_ANDROID//预处理语句 不同平台StreamingAssets的目录不同
            //Appication.streamingAssetsPath为文件目录
                    localPath = Application.streamingAssetsPath + "/" + cfgName + ".txt";
            #else
                    localPath = "file:///" + Application.streamingAssetsPath + "/" + cfgName + ".txt";
            #endif
                    //通过www读取
                    WWW www = new WWW(localPath);
                    if (www.error != null)
                    {
                        Debug.LogError("error : " + localPath);
                    }
                    //因为www是异步方法,所以通过while判断是否完成下载
                    //也可以通过协程进行读取
                    while (!www.isDone)
                    {
    
                    }
    

    3.UnityWebRequest

    当然,在现在的Unity高版本中,www这种方法已经被弃用了,对于StreamingAssets文件,我们可以通过UnityWebRequest这个Unity封装的方法进行读取。引入命名空间UnityEngine.Networking即可使用。在使用前,我们想了解一下这个类的组成。

    UnityWebRequest组成的三个元素

    UploadHandler 处理数据将数据发送到服务器的对象
    DownloadHandler 从服务器接收数据的对象
    UnityWebRequest 负责 HTTP通信流量控制来管理上面两个对象的对象

    为了方便路径的寻找,我们引入一个System.Uri类,使用该类的Path.Combine方便我们拼接路径,因为不同的平台StreamingAssets文件的路径不尽相同。

    Windows平台 file:///D:/DATA/StreamingAssets/data.json
    WebGl平台 http://localhost/StreamingAssets/data.json
    Android平台 jar:file:///data/app/xxx!/assets/data.json
    iOS平台 Application/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/xxx.app/Data/Raw

    示例:加载文本

    public class JsonTest : MonoBehaviour
    {
        private void Start()
        {
            StartCoroutine(GetData());
        }
     
        IEnumerator GetData()
        {
            var  uri = new  System.Uri(Path.Combine(Application.streamingAssetsPath,"test.txt"));
            UnityWebRequest www = UnityWebRequest.Get(uri);
            yield return www.SendWebRequest();
     
            if(www.isNetworkError || www.isHttpError) {
                Debug.Log(www.error);
            }
            else
            {
                Debug.Log(www.downloadHandler.text);
                string jsonStr  = www.downloadHandler.text;
     
                TestData data = JsonMapper.ToObject<TestData>(jsonStr);
                
                Debug.Log("姓名:" + data.userName + "\n年龄:" + data.age);
            }
        }
    }
     
    [System.Serializable]
    public class TestData
    {
        public string userName;
        public int age;
    }
    

    测试结果

    
    {
       "userName":"王武",
       "age":26
    }
    

    示例:加载AssetBundle

    IEnumerator GetAssetBundle(string url)
        {
            UnityWebRequest request = UnityWebRequestAssetBundle.GetAssetBundle(path);
            yield return request.SendWebRequest();
     
            if (request.isDone)
            {
                AssetBundle ab = DownloadHandlerAssetBundle.GetContent(request); 
                if (ab)
                {
                    Instantiate(ab.LoadAsset("Cube"));
                }
            }
            request.Dispose();//记得使用完要释放呀 
        }
    

    总结

    Resources.Load() 比较适合不需要更改的数据,一些固定数据的游戏,因为项目打包出来的Resources文件只是可读的,如果需要频繁更改包里的数据的话,每次打包都需要耗费一定的时间。如果项目的数据是上传到服务器上的,推荐使用WWW或者UnityWebRequest方法
    参考:
    https://blog.csdn.net/Glow0129/article/details/104982681
    https://blog.csdn.net/qq_33994566/article/details/100015041
    https://blog.csdn.net/gaojinjingg/article/details/53128802

    展开全文
  • 1. Resources.Load:从一个缺省打进程序包的...2. 通过AssetBundle打包:自己创建,运行时动态加载,可以指定路径。 3. 使用AssetDataBase.loadset:只能在Editor中使用 4.使用StreamAsset:只能加载字符文件 ...

    1. Resources.Load:文件放到Assets/Resources文件夹下

    string url = "Data/Image/inside";
    inside = Resources.Load(url) as Texture;

    2. 通过AssetBundle打包

    AssetBundle assetBundle = AssetBundle.LoadFromFile(manifestFilePath);

    3. 使用AssetDatabase.loadset

     Texture2D t = AssetDatabase.LoadAssetAtPath("Assets/Textures/texture.jpg", typeof(Texture2D)) as Texture2D;

    4.WWW模块加载外部资源

    WWW www = new WWW("file://" + fileInfo.FullName);    
    outside = www.texture;

     

    展开全文
  • unity3d Resources.Load动态加载资源  初步整理并且学习unity3d资源加载方法,预计用时两天完成入门学习Unity3d常用两种加载资源方案:Resources.Load和AssetBundle Resources.Load就是从一个缺省打进程序包...
  • 最近一直在和这些内容纠缠,把心得和大家共享一下:Unity里有两种动态加载机制:一是Resources.Load,一是通过AssetBundle,其实两者本质上我理解没有什么区别。Resources.Load就是从一个缺省打进程序包里的...
  • Unity3D实现资源动态加载Demo

    热门讨论 2012-04-06 16:46:49
    Unity3D实现资源动态加载Demo,官网实例,对理解资源动态加载很有帮助
  • Spine在Unity动态加载

    2020-10-22 18:42:47
    Unity中使用Spine是非常平常的事情,一般的做法是把每一个动画做成预设然后Clone就好,但是如果要动态加载动画资源呢?把所有的动画做成一个预设,Clone之后再动态改变其动画内容: 下面展示一些 内联代码片。 // ...
  • Unity实现动态资源加载的4种方式

    万次阅读 多人点赞 2019-05-06 21:26:31
    前几天老大要做一下unity资源加载熟悉下unity资源加载的API,自己的代码还是有点烂啊,在老大的教导下,现在能将就看看了。 使用unity开发游戏的过程中,资源的加载一直都是需要重点关注的。unity一共提供了5种...
  • Unity3D动态加载FBX文件

    2020-10-13 16:28:26
    Unity3D动态加载FBX文件并非指使用Unity内部指令Resources、AssetsBundle等,而是在已发布的程序运行时,动态加载FBX资源文件。 Max导出模型格式有二进制和ASCII两种。本文针对ASCII予以说明。通过System.IO将文件...
  • Unity3D动态加载资源的2种方式

    千次阅读 2016-11-11 14:57:06
    unity开发中,我们经常要用到动态去创建物体,这里最常见的一种就是把我们的资源做成预制物体放在Resources文件夹下,然后用Resources.Load()去动态加载出来。在Resources文件夹下的所有资源都是会被打包一起发布...
  • unity开发中,我们经常要用到动态去创建物体,这里最常见的一种就是把我们的资源做成预制物体放在Resources文件夹下,然后用Resources.Load()去动态加载出来。在Resources文件夹下的所有资源都是会被打包一起发布...
  • 1.当项目抛弃了Unity的多场景模式,也就是说整个项目只有一个scene,资源全部都是以AssetBundle的形式动态加载资源全部由自己来加载和卸载。加载出来的资源,需要设置LightmapIndex和LightmapSc...
  • unity动态加载远程资源的相关话题网上有一些,但都语焉不详,经过本人的摸索,终于找到门道,记录下来备忘,也分享给同好。 unity动态加载远程资源需要用到unity的一个runtime class,叫做WWW,可以在帮助里面的...
  • Unity3D 实现动态加载游戏资源 在flash时代资源的动态加载非常的普遍主要是受限于网速的快慢我们在用...-资源动态加载 比如想加载一个大场景的资源 不应该在游戏的开始让用户长时间等待全部资源的加载完毕 应该优先加载
  • unity资源动态加载的方式

    千次阅读 2017-10-21 15:43:14
    1.首先总结下unity有哪几种资源类型 ...unity资源的类型:  -a) Unity内置的常用asset, fbx\jpg...  - b) textasset: txt、binary等,对应了它的TextAsset类,可以直接读入文本或者二进制byte
  • Unity打包AssetBundle,并加载AssetBundle代码。其中有几个细节的地方,是做项目的时候踩的坑,这里做个备份。 using UnityEngine; using UnityEditor; /// ///写一个Editor脚本,放在...
  • unity动态加载远程资源

    千次阅读 2013-09-28 17:28:39
    unity动态加载远程资源的相关话题网上有一些,但都语焉不详,经过本人的摸索,终于找到门道,记录下来备忘,也分享给同好。 unity动态加载远程资源需要用到unity的一个runtime class,叫做WWW,可以在帮助里面...
  • 本文记录如何通过unity3d进行脚本资源打包加载1、创建TestDll.cs文件public class TestDll : MonoBehaviour {void Start () {print("Hi U_tansuo!");}}2、生成dll文件(1)使用vs打包(2) 使用mono打包(3) 命令行打包 ...
  • 项目导入后 记得启用,在Edit->Project Settings->Editor->Sprite Packer->Mode设置成Always Enabled ,然后Edit Tools -->AtlasMaker 下具体解释:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 737
精华内容 294
关键字:

unity资源动态加载