Ejemplo n.º 1
0
    /// <summary>
    /// does the actual re-init work.  should only be called after destroy has had time to process.
    /// currently this involves an elaborate set of bools to keep up with engine execution
    /// </summary>
    private void init()
    {
        var loadStats = new Dictionary <string, string>();
        var loadStart = DateTime.Now;

        createdGameObjects = new GameObjectRegistry();
        createdGameObjects.Add("Rig", GameObject.Find("Rig"));//get the camera where we can find it quickly
        GameObject proCam = GameObject.Find("Pro Cam");

        createdGameObjects.Add(proCam.name, proCam);
        if (reloadStoryPlan)
        {
            Debug.Log(string.Format("loading story plan[{0}] @ [{1}].  last read [{2}]",
                                    currentInputSet.StoryPlanPath, DateTime.Now.ToString(timestampFormat), storyPlanLastReadTimeStamp.ToString(timestampFormat)));
            var impulseLoadStart = DateTime.Now;
            loadStructuredImpulsePlan(currentInputSet.StoryPlanPath);
            loadStats.Add("story plan", getElapsedTimeMillis(impulseLoadStart).ToString());
            storyPlanLastReadTimeStamp = DateTime.Now;
        }

        if (reloadCinematicModel)
        {
            Debug.Log(string.Format("loading cinematic model[{0}] @ [{1}].  last read [{2}]",
                                    currentInputSet.CinematicModelPath, DateTime.Now.ToString(timestampFormat), storyPlanLastReadTimeStamp.ToString(timestampFormat)));
            var cmLoadStart = DateTime.Now;
            cinematicModel = CM.Parser.Parse(currentInputSet.CinematicModelPath);
            loadStats.Add("cinematic model", getElapsedTimeMillis(cmLoadStart).ToString());
            cinematicModelPlanLastReadTimeStamp = DateTime.Now;
        }

        if (actorsAndAnimations != null && reloadActorsAndAnimationsBundle)
        {
            actorsAndAnimations.Unload(true);
        }


        if (reloadActorsAndAnimationsBundle)
        {
            Debug.Log(string.Format("loading actors bundle[{0}] @ [{1}].  last read [{2}]",
                                    currentInputSet.ActorsAndAnimationsBundlePath, DateTime.Now.ToString(timestampFormat), storyPlanLastReadTimeStamp.ToString(timestampFormat)));
            var actorBundleLoadStart = DateTime.Now;
            actorsAndAnimations = AssetBundle.LoadFromFile(currentInputSet.ActorsAndAnimationsBundlePath);
            loadStats.Add("actor bundle", getElapsedTimeMillis(actorBundleLoadStart).ToString());
            actorsAndAnimationsBundleLastReadTimeStamp = DateTime.Now;
        }

        if (terrain != null && reloadTerrainBundle)
        {
            terrain.Unload(true);
        }

        if (reloadTerrainBundle)
        {
            Debug.Log(string.Format("loading terrain bundle[{0}] @ [{1}].  last read [{2}]",
                                    currentInputSet.TerrainBundlePath, DateTime.Now.ToString(timestampFormat), storyPlanLastReadTimeStamp.ToString(timestampFormat)));
            var terrainBundleLoadStart = DateTime.Now;
            terrain = AssetBundle.LoadFromFile(currentInputSet.TerrainBundlePath);
            loadStats.Add("terrain bundle", getElapsedTimeMillis(terrainBundleLoadStart).ToString());
            terrainBundleLastReadTimeStamp = DateTime.Now;
            var terrainCreateStart = DateTime.Now;
            instantiateTerrain();
            loadStats.Add("terrain create", getElapsedTimeMillis(terrainCreateStart).ToString());
        }

        if (reloadStoryPlan || reloadActorsAndAnimationsBundle || reloadCinematicModel)
        {
            Debug.Log(string.Format("upstream components reloaded, rebuilding actor action queue @ [{0}].",
                                    DateTime.Now.ToString(timestampFormat)));
            var actionCreateStart = DateTime.Now;
            actorActionList = ActorActionFactory.CreateStoryActions(story, cinematicModel, implicitActorCreation);
            loadStats.Add("actor action create", getElapsedTimeMillis(actionCreateStart).ToString());
        }

        if (reloadStoryPlan || reloadCameraPlan)
        {
            Debug.Log(string.Format("upstream components reloaded, rebuilding camera action queue @ [{0}].",
                                    DateTime.Now.ToString(timestampFormat)));
            var discourseActionCreateStart = DateTime.Now;
            CameraActionFactory.CreateActions(story, cinematicModel, currentInputSet.CameraPlanPath, out cameraActionList, out discourseActionList);
            loadStats.Add("discourse action create", getElapsedTimeMillis(discourseActionCreateStart).ToString());
            cameraPlanLastReadTimeStamp = DateTime.Now;
        }

        currentDiscourseTime                = 0;
        currentStoryTime                    = 0;
        actorActionList.NextActionIndex     = 0;
        cameraActionList.NextActionIndex    = 0;
        discourseActionList.NextActionIndex = 0;

        executingActorActions     = new FireBoltActionList(new ActionTypeComparer());
        executingCameraActions    = new FireBoltActionList(new ActionTypeComparer());
        executingDiscourseActions = new FireBoltActionList(new ActionTypeComparer());
        GameObject instantiatedObjects = new GameObject("InstantiatedObjects");

        instantiatedObjects.transform.SetParent((GameObject.Find("FireBolt") as GameObject).transform);
        createdGameObjects.Add(instantiatedObjects.name, instantiatedObjects);

        if (generateKeyframes)
        {
            // Call the screenshot coroutine to create keyframe images for scrubbing.
            StartCoroutine(CreateScreenshots());
        }

        if (miniMapController != null)
        {
            List <string> actorNames = new List <string>();
            //get list of main actors to show on the minimap
            if (story.ObjectSets.ContainsKey("Main-Actors"))
            {
                foreach (var actor in (story.ObjectSets["Main-Actors"] as IFiniteObjectSet).Items)
                {
                    actorNames.Add(actor.Value.ToString());
                }
            }
            else
            {
                Debug.Log("Main-Actors group not defined.  Actors will not be shown on the minimap.");
            }
            miniMapController.InitializeMiniMap(actorNames);
        }


        initialized   = true;
        initNext      = false;
        initTriggered = false;

        reloadActorsAndAnimationsBundle = false;
        reloadCameraPlan     = false;
        reloadCinematicModel = false;
        reloadStoryPlan      = false;
        reloadTerrainBundle  = false;
        loadStats.Add("total", getElapsedTimeMillis(loadStart).ToString());
        Extensions.LogStatistics(loadStats);
    }