public void Decorate(GameObject go, Dictionary<string, object> options, AssetBundle assetBundle)
        {
            go.AddComponent<global::Deco>();

            if (options.ContainsKey("heightDelta"))
                (new HeightDecorator((double)options["heightDelta"])).Decorate(go, options, assetBundle);
        }

 public static UIPackage AddPackage(AssetBundle desc, AssetBundle res, string resourceNamePrefix)
 {
     byte[] bytes = ((TextAsset)desc.mainAsset).bytes;
     if (desc != res)
         desc.Unload(true);
     return AddPackage(bytes, res, resourceNamePrefix);
 }

 public void Decorate(GameObject go, Dictionary<string, object> options, AssetBundle assetBundle)
 {
     if (go.GetComponent<Deco>() != null)
     {
         go.GetComponent<Deco>().defaultGridSubdivision = _subdivision;
     }
 }

 public CacheData(object data, AssetBundle assetBundle, string assetBundleName)
 {
     this.www = data;
     this.assetBundle = assetBundle;
     this.assetBundleKey = assetBundleName;
     this.assetHashCode = LuaHelper.StringToHash(assetBundleName);
 }

 public void Decorate(GameObject go, Dictionary<string, object> options, AssetBundle assetBundle)
 {
     if (go.GetComponent<Deco>() != null && _grid)
     {
         go.GetComponent<Deco>().buildOnGrid = _grid;
     }
 }

        protected virtual void Awake()
        {
            string bundlePath = EngineerGlobals.AssemblyPath;

            s_Images = AssetBundle.CreateFromFile(bundlePath + "/images");
            s_Prefabs = AssetBundle.CreateFromFile(bundlePath + "/prefabs");
        }

 void LoadAssets(string path)
 {
     if ((System.IO.File.Exists (path) == false) || (path.EndsWith (".unity3d") == false)) {
         return;
     }
     string assetBundleName = System.IO.Path.GetFileNameWithoutExtension (path);
     var loadedAssetBundles = Resources.FindObjectsOfTypeAll<AssetBundle> ();
     foreach (var loadedAssetBundle in loadedAssetBundles) {
         if (loadedAssetBundle.name == assetBundleName) {
             loadedAssetBundle.Unload (true);
         }
     }
     if (string.IsNullOrEmpty (path) == false) {
         if (System.IO.Directory.Exists (path)) {
             return;
         }
         byte[] bytes = System.IO.File.ReadAllBytes (path);
         if (_lastSelectedAssetBundle != null) {
             _lastSelectedAssetBundle.Unload (true);
             _lastSelectedAssetBundle = null;
         }
         _lastSelectedAssetBundle = AssetBundle.CreateFromMemoryImmediate (bytes);
         if (_lastSelectedAssetBundle != null) {
             _lastSelectedAssetBundle.name = assetBundleName;
             _assets = _lastSelectedAssetBundle.LoadAllAssets ();
         }
         OrderBySize ();
     }
 }

        public void Decorate(GameObject go, Dictionary<string, object> options, AssetBundle assetBundle)
        {
            CustomSize cs = go.AddComponent<CustomSize>();

            cs.minSize = 1;
            cs.maxSize = 4;
        }

        public static void OnRecievedAssetFromServerOrCache(string assetName, AssetBundle bundle)
        {
            Debug.Log(assetName);
            Debug.Log(bundle);

            if (bundle == null)
            {
                Debug.Log("Recived null asset");
            }

            string groupName = AssetGroupRefences[assetName];

            AssetObject newAssetObject = AssetGroups[groupName][assetName];

            if (bundle != null)
            {
                newAssetObject.asset = bundle.mainAsset;
                newAssetObject.bundle = bundle;
            }
            else
            {
                newAssetObject.asset = null;
                newAssetObject.bundle = null;
            }

            newAssetObject.isComplete = true;
            if (assetBundleTracker != null)
            {
                assetBundleTracker.addCompletedCount(groupName);
                assetBundleTracker.CheckIsCompletedAllDownloads(groupName);
            }
            newAssetObject.CallEvent();
        }

 public override bool IsDone()
 {
     if (this.dependences != null)
     {
         for (int i = 0; i < this.dependences.Length; ++i)
         {
             if (!ResMgr.Instance().IsLoadedAssetBundle(this.dependences[i]))
                 return false;
         }
     }
     if (this.op != null)
     {
         return this.op.isDone;
     }
     else
     {
         if (this.www.isDone)
         {
             this.assetbundle = this.www.assetBundle;
             string scene = base.SceneName.Substring(0, base.SceneName.LastIndexOf('.'));
             if (this.additive)
                 this.op = Application.LoadLevelAdditiveAsync(scene);
             else
                 this.op = Application.LoadLevelAsync(scene);
             this.www.Dispose();
             this.www = null;
         }
         return false;
     }
 }

 public void Decorate(GameObject go, Dictionary<string, object> options, AssetBundle assetBundle)
 {
     if (go.GetComponent<Deco>() != null)
     {
         go.GetComponent<Deco>().defaultSnapToGridCenter = _snap;
     }
 }

 private UnityEngine.Object LoadFromBundle(AssetBundle bundle, string name)
 {
     #if UNITY_4_3 || UNITY_4_5 || UNITY_4_6
     return bundle.Load(name);
     #else
     return bundle.LoadAsset(name);
     #endif
 }

			/*--------------------------------------------------*/
			/// <summary>
			/// コンストラクタ.
			/// </summary>
			/// <param name="url"> 接続先. </param>
			/// <param name="version"> バージョン. </param>
			/// <param name="crc"> チェックサム. </param>
			/*--------------------------------------------------*/
			public AssetBundleRef(string url, int version, uint crc)
			{
				this.url = url;
				this.version = version;
				this.crc = crc;
				this.status = downloadStatus.none;
				this.bundle = null;
			}

		public GameObject Decorate(Dictionary<string, object> options, AssetBundle assetBundle)
		{
			var asset = UnityEngine.Object.Instantiate(assetBundle.LoadAsset((string)options["model"])) as GameObject;
			asset.gameObject.SetActive (false);
			this.Decorate (asset,options, assetBundle);
			AssetManager.Instance.registerObject (asset.gameObject.GetComponent<Product> ());
			return asset;
		}

 public void Decorate(GameObject go, Dictionary<string, object> options, AssetBundle assetBundle)
 {
     switch (_type)
     {
         case "billboard":
             (new BillboardDecorator()).Decorate(go, options, assetBundle);
             break;
     }
 }

 public void AddAssetBundle(string bundleName, AssetBundle bundle)
 {
     if (bundles.ContainsKey(bundleName)) {
         bundles[bundleName].Increase();
     }
     else {
         bundles.Add(bundleName, new AssetReference(bundle));
     }
 }

        protected virtual void Start()
        {
            string bundlePath = EngineerGlobals.AssemblyPath + "/AssetBundles/";

            images = AssetBundle.LoadFromFile(bundlePath + "/images");
            prefabs = AssetBundle.LoadFromFile(bundlePath + "/prefabs");

            MyLogger.Log(images);
        }

 /// <summary>
 /// 卸载资源
 /// </summary>
 /// <param name="bundle">卸载的资源</param>
 /// <param name="unload"></param>
 public static void UnLoadSource(AssetBundle bundle, bool unload)
 {
     if (bundle == null)
     {
         LCSConsole.WriteError("卸载资源为空！");
         return;
     }
     bundle.Unload(unload);
 }

 //Start async load the assetbundle
 public static AsyncLoader StartLoad(AssetBundle asset, string resName , FINISH_CALLBACK finish_callback)
 {
     if(sGoInstance == null)
     {
         sGoInstance = new GameObject("AsyncLoader");
     }
     AsyncLoader loader = sGoInstance.AddComponent<AsyncLoader>();
     loader.StartCoroutine(loader.GoLoader(asset, resName,finish_callback));
     return loader;
 }

 public static bool PreviewAssetStoreAssetBundleInInspector(AssetBundle bundle, AssetStoreAsset info)
 {
   info.id = 0;
   info.previewAsset = bundle.mainAsset;
   AssetStoreAssetSelection.Clear();
   AssetStoreAssetSelection.AddAssetInternal(info);
   Selection.activeObject = (Object) AssetStoreAssetInspector.Instance;
   AssetStoreAssetInspector.Instance.Repaint();
   return true;
 }