//-------------------------------------------------------------------------
    public AsyncLoadAssetResult asyncLoadAssetBundle <T>(string id, string resource_path, string resource_name, delegateAssetLoaded call_back) where T : UnityEngine.Object
    {
        resource_path += ".assetbundle";
        AsyncLoadAssetResult result = new AsyncLoadAssetResult();

        result.is_done = false;
        result.id      = id;
        AsyncAssetBundleInfo async_info;

        async_info.id         = id;
        async_info.asset_name = resource_name;
        async_info.asset_path = resource_path;
        AssetBundle asset     = null;
        WWW         asset_www = null;

        mMapAsyncAssetBundlePath.TryGetValue(resource_path, out asset);
        if (asset == null)
        {
            asset_www = WWW.LoadFromCacheOrDownload(resource_path, 0);
        }
        async_info.asset_www                = asset_www;
        async_info.asset                    = asset;
        async_info.t                        = typeof(T);
        async_info.asset_loaded             = call_back;
        async_info.loader_result            = result;
        mMapAsyncAssetBundleRequest[result] = async_info;
        return(result);
    }
    //-------------------------------------------------------------------------
    public AsyncLoadAssetResult asyncLoadResources <T>(string id, string resource_path, string resource_name, delegateAssetLoaded call_back) where T : UnityEngine.Object
    {
        AsyncLoadAssetResult result = new AsyncLoadAssetResult();

        result.is_done = false;
        result.id      = id;
        AsyncResourcesInfo async_info;

        async_info.id               = id;
        async_info.resource_name    = resource_name;
        async_info.resource_path    = resource_path;
        async_info.resource_request = Resources.LoadAsync <T>(async_info.resource_path);
        async_info.t                      = typeof(T);
        async_info.asset_loaded           = call_back;
        async_info.loader_result          = result;
        mMapAsyncResourcesRequest[result] = async_info;
        return(result);
    }
    //-------------------------------------------------------------------------
    public void update(float elapsed_tm)
    {
        foreach (var i in mMapAsyncResourcesRequest)
        {
            AsyncResourcesInfo resource_info = i.Value;
            if (resource_info.resource_request.isDone)
            {
                resource_info.asset_loaded(resource_info.loader_result, null, resource_info.resource_request.asset);
                mQueueLoadedResources.Enqueue(i.Key);
            }
        }

        while (mQueueLoadedResources.Count > 0)
        {
            AsyncLoadAssetResult key = mQueueLoadedResources.Dequeue();
            if (mMapAsyncResourcesRequest.ContainsKey(key))
            {
                mMapAsyncResourcesRequest.Remove(key);
            }
        }

        foreach (var i in mMapAsyncAssetBundleRequest)
        {
            AsyncAssetBundleInfo resource_info = i.Value;
            if (resource_info.asset == null)
            {
                AssetBundle asset = null;
                mMapAsyncAssetBundlePath.TryGetValue(resource_info.asset_path, out asset);
                if (asset == null)
                {
                    if (resource_info.asset_www != null && resource_info.asset_www.isDone)
                    {
                        if (string.IsNullOrEmpty(resource_info.asset_www.error))
                        {
                            resource_info.asset         = resource_info.asset_www.assetBundle;
                            mMapAsyncAssetBundle[i.Key] = resource_info;
                            mMapAsyncAssetBundlePath[resource_info.asset_path] = resource_info.asset_www.assetBundle;
                            resource_info.asset_www = null;
                        }
                        else
                        {
                            Debug.LogError(resource_info.asset_www.error);
                            mMapAsyncAssetBundle[i.Key] = resource_info;
                            mQueueLoadedAssetBundle.Enqueue(i.Key);
                        }
                    }
                }
                else
                {
                    resource_info.asset         = asset;
                    mMapAsyncAssetBundle[i.Key] = resource_info;
                }
            }
            else
            {
                if (resource_info.asset_www != null)
                {
                    resource_info.asset_www = null;
                }
                mMapAsyncAssetBundle[i.Key] = resource_info;
            }
        }

        foreach (var i in mMapAsyncAssetBundle)
        {
            AsyncAssetBundleInfo resource_info = i.Value;
            if (mMapAsyncAssetBundleRequest.ContainsKey(i.Key))
            {
                mMapAsyncAssetBundleRequest.Remove(i.Key);
            }
            if (resource_info.asset != null)
            {
                AssetBundleRequest assetbundle_request = resource_info.asset.LoadAssetAsync(resource_info.asset_name, resource_info.t);

                if (assetbundle_request.isDone)
                {
                    resource_info.asset_loaded(resource_info.loader_result, i.Value.asset, assetbundle_request.asset);
                    mQueueLoadedAssetBundle.Enqueue(i.Key);
                }
            }
        }

        while (mQueueLoadedAssetBundle.Count > 0)
        {
            AsyncLoadAssetResult key = mQueueLoadedAssetBundle.Dequeue();
            if (mMapAsyncAssetBundle.ContainsKey(key))
            {
                mMapAsyncAssetBundle.Remove(key);
            }
        }

        foreach (var i in mMapAsyncAssetRequest)
        {
            AsyncAssetInfo resource_info = i.Value;

            if (resource_info.asset_www != null && resource_info.asset_www.isDone)
            {
                if (string.IsNullOrEmpty(resource_info.asset_www.error))
                {
                    resource_info.asset_loaded(resource_info.loader_result, null, resource_info.asset_www.texture);
                    resource_info.asset_www.Dispose();
                }
                else
                {
                    Debug.LogError(resource_info.asset_www.error);
                }
                mQueueLoadedAsset.Enqueue(i.Key);
            }
        }

        while (mQueueLoadedAsset.Count > 0)
        {
            AsyncLoadAssetResult key = mQueueLoadedAsset.Dequeue();
            if (mMapAsyncAssetRequest.ContainsKey(key))
            {
                mMapAsyncAssetRequest.Remove(key);
            }
        }
    }