Exemplo n.º 1
0
        public AssetRef Load(string path, TYPE type = TYPE.Prefab, string assetBundlePath = null)
        {
            path = Core.Path.instance.Resolve(path, type);
            var name     = System.IO.Path.GetFileNameWithoutExtension(path);
            var assetRef = FindAssetRef(path);

            if (assetRef != null)
            {
                Log.Resource.I("Load {0} in Cache", name);
                return(assetRef.Refrence());
            }

            if (string.IsNullOrEmpty(assetBundlePath))
            {
                assetBundlePath = Core.Path.instance.Resolve(path, TYPE.AssetBundle);
            }
            var assetBundleRef = LoadAssetBundle(assetBundlePath);

            if (assetBundleRef == null)
            {
                return(null);
            }

            var assetBundle = assetBundleRef.Get <AssetBundle>();
            var asset       = assetBundle.LoadAsset(name);

            assetRef = new AssetRef(path, asset, new List <AssetRef>()
            {
                assetBundleRef
            });
            CacheAssetRef(assetRef.Refrence());
            return(assetRef);
        }
Exemplo n.º 2
0
        public GameObject Instantiate(AssetRef assetRef)
        {
            assetRef.Refrence();
            var clone = UnityEngine.Object.Instantiate(assetRef.Get <GameObject>());

            clone.OnDestroyAsObservable().Subscribe(_ => assetRef.Release());
            return(clone);
        }
Exemplo n.º 3
0
        public virtual async Task <AssetRef> LoadAsync(string path, TYPE type, LoadingOption option, string assetBundlePath)
        {
            path = Core.Path.instance.Resolve(path, type);
            var name     = System.IO.Path.GetFileNameWithoutExtension(path);
            var assetRef = FindAssetRef(path);

            if (assetRef != null)
            {
                Log.Resource.I("LoadAsync {0} in Cache", name);
                return(assetRef.Refrence());
            }

            if (string.IsNullOrEmpty(assetBundlePath))
            {
                assetBundlePath = Core.Path.instance.Resolve(path, TYPE.AssetBundle);
            }
            var assetBundleRef = await LoadAssetBundleAsync(assetBundlePath, option);

            if (assetBundleRef == null)
            {
                return(null);
            }

            var assetBundle        = assetBundleRef.Get <AssetBundle>();
            var assetBundleRequest = assetBundle.LoadAssetAsync(name);
            var result             = await Loading.instance.Wrap(async() =>
            {
                return(await HookProgress(assetBundleRequest, option.progress, 0.7f));
            }, option);

            if (!result)
            {
                return(null);
            }

            var asset = assetBundleRequest.asset;

            if (asset == null)
            {
                return(null);
            }

            assetRef = new AssetRef(path, asset, new List <AssetRef>()
            {
                assetBundleRef
            });
            CacheAssetRef(assetRef.Refrence());
            return(assetRef);
        }
Exemplo n.º 4
0
        protected virtual async Task <AssetBundleManifest> LoadAssetBundleManifest()
        {
            var option      = new LoadingOption();
            var path        = $"Assets/{Path.AssetBundleFolder}/{Path.AssetBundleFolder}";
            var assetBundle = await LoadAssetBundleSingleAsync(path, option);

            var assetBundleRef = new AssetRef(path, assetBundle);

            var name     = "AssetBundleManifest";
            var manifest = await assetBundle.LoadAssetAsync <AssetBundleManifest>(name);

            var manifestRef = new AssetRef(name, manifest, new List <AssetRef>()
            {
                assetBundleRef
            });

            CacheAssetRef(manifestRef.Refrence());
            return(manifest as AssetBundleManifest);
        }