public void show(AsyncOperation ao)
	{
		Debug.Log("ao.progress: " + ao.progress);
		gameObject.SetActive(true);
		bg.SetActive(true);
		progressBar.value = ao.progress;
	}

    public void Show(AsyncOperation ao)
    {

        BG.SetActive(true);
        isAsyn = true;
        this.ao = ao;
    }

        public void ContinueWithActionInterfaceToOperationCallbackTest()
        {
            var operation = new AsyncOperation<bool>();
            IOperationResult<bool> operationResult = OperationResult.CreateResult(OperationType.PageNavigation, this, true,
                DataContext.Empty);

            bool isInvoked = false;
            var continuationAction = new ActionContinuationMock
            {
                Invoke = result =>
                {
                    result.ShouldEqual(operationResult);
                    isInvoked = true;
                }
            };

            operation.ContinueWith(continuationAction);
            isInvoked.ShouldBeFalse();
            operation.ToOperationCallback().Invoke(operationResult);
            isInvoked.ShouldBeTrue();

            isInvoked = false;
            operation.ContinueWith(continuationAction);
            isInvoked.ShouldBeTrue();
        }

 public void Show(AsyncOperation ao)
 {
     gameObject.SetActive(true);
     bg.SetActive(true);
     isAsyn = true;
     this.ao = ao;
 }

        public void OperationShouldSerializeAsyncMethodWithViewModel()
        {
            var vmMock = new NavigableViewModelMock();
            ServiceProvider.OperationCallbackFactory = new SerializableOperationCallbackFactory();
            var operation = new AsyncOperation<bool>();
            IOperationResult<bool> result = OperationResult.CreateResult(OperationType.PageNavigation, this, true,
                new NavigationContext(NavigationType.Page, NavigationMode.Back, vmMock, vmMock, this));

            AsyncMethodWithViewModel(operation, true, vmMock);
            var callback = operation.ToOperationCallback();
            var serialize = Serializer.Serialize(callback);
            serialize.Position = 0;
            callback = (IOperationCallback)Serializer.Deserialize(serialize);

            IocContainer.GetFunc = (type, s, arg3) =>
            {
                if (type == GetType())
                    return this;
                return Activator.CreateInstance(type);
            };
            AsyncMethodInvoked.ShouldBeFalse();
            ViewModel.ShouldBeNull();
            callback.Invoke(result);
            AsyncMethodInvoked.ShouldBeTrue();
            ViewModel.ShouldEqual(vmMock);
        }

    IEnumerator Load()
    {
        try
        {
            stageName = sc.getStageName().ToString();
            print("stageName: " + stageName);
            // 非同期でロード開始
            async = Application.LoadLevelAsync(stageName.ToString());
            // デフォルトはtrue。ロード完了したら勝手にシーンきりかえ発生しないよう設定。
            async.allowSceneActivation = false;
        }
        catch (Exception)
        {
            Application.LoadLevelAsync("StageSelect");
            yield break;
        }

        // 非同期読み込み中の処理
        while (async.progress < 0.9f)
        {
            loadingText.text = "NowLoading..." + (async.progress * 100).ToString("F0") + "%";
            //Debug.Log("ローディングパーセント" + async.progress * 100);
            lodingBar.value = async.progress;
            yield return new WaitForEndOfFrame();
        }
        lodingBar.value = 0.9f;
        loadingText.text = "NowLoading...100%";
        state.setState(GameState.NotPlaying);
        yield return async;
    }

    IEnumerator loadScene()
    {
        async = Application.LoadLevelAsync (Globe.getInstance().loadName);
        async.allowSceneActivation = false;
        while(async.progress<0.9f)
        {
            per+=0.01f;
            text.text =Mathf.Floor( per*100)+"%";
            loadingMc.fillAmount = per;
            yield return new WaitForEndOfFrame();
        }

        while (per <1f)
        {
            per+=0.01f;
            text.text =Mathf.Floor( per*100)+"%";
            loadingMc.fillAmount = per;
            yield return new WaitForEndOfFrame();
        }

        if(Globe.getInstance().afterEnterWorldHandler!=null)
        {
            Globe.getInstance().afterEnterWorldHandler();
            Globe.getInstance().afterEnterWorldHandler=null;
        }
        async.allowSceneActivation = true;
    }

 private IEnumerator LoadALevel(string sceneName)
 {
     yield return new WaitForSeconds(5f);
     async = SceneManager.LoadSceneAsync(sceneName);
     //yield return new WaitForSeconds(6f);
     yield return async;
 }

    IEnumerator Start()
    {
        // 非同期でロード開始
        switch(ButtonC.courceNum){
        case 1:
            async0 = Application.LoadLevelAsync("Stage00");
            async0.allowSceneActivation= false;
            yield return async0;
            break;

        case 2:
            async0 = Application.LoadLevelAsync("Stage01");
            async0.allowSceneActivation= false;
            yield return async0;
            break;

        case 3:
            async0 = Application.LoadLevelAsync("Stage10");
            async0.allowSceneActivation= false;
            yield return async0;
            break;

        default:
            break;
        }
    }

	IEnumerator loadScene()  
	{  
		isAsync = true;
		async = Application.LoadLevelAsync(Global.GetInstance().loadName);
		async.allowSceneActivation = false;//禁止协程加载完自动跳转关卡
		yield return async;
	}

 void Start()
 {
     async = Application.LoadLevelAsync(5);
     async.allowSceneActivation = false;
     //yield return async;
     Debug.Log("Loading complete");
 }

 void StreamLevel()
 {
     if (nextLevelID >= 0) {
         level = Application.LoadLevelAdditiveAsync(nextLevelID);
         level.allowSceneActivation = false;
     }
 }

 public void changeScene(string nextScene)
 {
     //Application.LoadLevel(nextScene);
     preloaderScreen.SetActive (true);
     loadOp = Application.LoadLevelAsync(nextScene);
     StartCoroutine (ScenePreload ());
 }

 public void Start()
 {
     if (this.SyncRequest == null)
     {
         this.SyncRequest = Res.LoadAsync(this.resourcePath, this.resourceType);
     }
 }

                        copyrightVisible = false; //determines if copyright is visible

    #endregion Fields

    #region Methods

    //Loads the next scene.
    IEnumerator AsyncLoadLevel()
    {
        async = Application.LoadLevelAsync("Greenlight Screen");
        async.allowSceneActivation = false;
        yield return async;
        Debug.Log("Loading complete");
    }

	IEnumerator load() {
		Debug.LogWarning("ASYNC LOAD STARTED - " +
		                 "DO NOT EXIT PLAY MODE UNTIL SCENE LOADS... UNITY WILL CRASH");
		async = Application.LoadLevelAsync(sceneToLoad.ToString());
		async.allowSceneActivation = false;
		yield return async;
	}

 IEnumerator LoadScene()
 {
     processBar.gameObject.SetActive(true);
     async = Application.LoadLevelAsync("Main");
     async.allowSceneActivation = false;
     yield return async;
 }

    IEnumerator Workflow()
    {
        FadeIn fadeIn = logo.AddComponent<FadeIn>();
        fadeIn.time = 1.0f;
        fadeIn.Begin();
        yield return new WaitForSeconds(2f);

        FadeOut fadeOut = logo.AddComponent<FadeOut>();
        fadeOut.time = 1.0f;
        fadeOut.Begin();
        yield return new WaitForSeconds(1f);

        logo.SetActive(false);
        loadingLayer.SetActive(true);
        yield return new WaitForEndOfFrame();

        MoveBy move = title.AddComponent<MoveBy>();
        move.offset = new Vector3(0, -2f, 0);
        move.time = 1f;
        move.Begin();
        yield return new WaitForSeconds(1f);

        async = Application.LoadLevelAsync("MainScene");
        async.allowSceneActivation = false;
        yield return StartCoroutine(Loading());

        text.text = "开始游戏";
        button.enabled = true;
    }

    private IEnumerator LoadLevel(int iSceneIndex)
    {
        m_LabelProg.gameObject.SetActive(true);

        m_Asyn = SceneManager.LoadSceneAsync (iSceneIndex);
        yield return m_Asyn;
    }

	IEnumerator LoadNextLevel()
	{
		async = Application.LoadLevelAsync(1);
		async.allowSceneActivation = false;

		yield return async;
	}