Ejemplo n.º 1
0
    private static void CreatePresetFromOpenScenes()
    {
        MultiScene multi = CreateInstance <MultiScene>();

        multi.name = "New Multi-Scene";

        Scene activeScene = SceneManager.GetActiveScene();
        int   sceneCount  = SceneManager.sceneCount;

        for (int i = 0; i < sceneCount; i++)
        {
            Scene scene = SceneManager.GetSceneAt(i);

            SceneAsset sceneAsset = AssetDatabase.LoadAssetAtPath <SceneAsset>(scene.path);

            if (activeScene == scene)
            {
                multi.activeScene = sceneAsset;
            }

            multi.sceneAssets.Add(new MultiScene.SceneInfo(sceneAsset, scene.isLoaded));
        }

        string directory   = AssetDatabase.GetAssetPath(Selection.activeObject.GetInstanceID());
        bool   isDirectory = Directory.Exists(directory);

        if (!isDirectory)
        {
            directory = Path.GetDirectoryName(directory);
        }

        ProjectWindowUtil.CreateAsset(multi, $"{directory}/{multi.name}.asset");
    }
Ejemplo n.º 2
0
        public StreamSceneOCController(OCParam param)
        {
            OcclusionRunningState.HasPVSData       = true;
            OcclusionRunningState.OcclusionEnabled = SharedConfig.EnableCustomOC;

            _param = param as StreamOCParam;
            _scene = new MultiScene(String.Empty, _param.TerrainNamePattern, _param.TerrainDimension, _param.TerrainSize, _param.OCData);
            _param.LevelManager.AfterGoLoaded    += OnGoLoad;
            _param.LevelManager.BeforeGoUnloaded += OnGoUnload;

            _pvsStats = new PVSStat[_param.TerrainDimension, _param.TerrainDimension];
            for (int i = 0; i < _param.TerrainDimension; ++i)
            {
                for (int j = 0; j < _param.TerrainDimension; ++j)
                {
                    var stat = new PVSStat()
                    {
                        Center    = new Vector2(i + 0.5f, j + 0.5f),
                        SceneName = String.Format(_param.TerrainNamePattern, i, j),
                        Status    = PVSStatus.UnLoaded
                    };

                    _pvsStats[i, j] = stat;
                }
            }

            UpdatePVSCache(_param.InitPosition, true);
        }
Ejemplo n.º 3
0
    protected override void OnEnable()
    {
        base.OnEnable();

        target = (MultiScene)base.target;
        list   = new ScenePresetList(target, target.sceneAssets, typeof(SceneAsset));
    }
Ejemplo n.º 4
0
        public static void TestBakeOneTile(string sceneName, int x, int y)
        {
            //GenerateOCDataForTile();
            var projectPath = "./Assets";
            var config      = LoadSceneConfig(projectPath, 0);

            if (string.IsNullOrEmpty(config.MapName))
            {
                Debug.LogErrorFormat("Can not get oc map config for stream scene in oc data generation, path {0} index {1}", projectPath, 0);
                ExitOnBatchMode();
                return;
            }

            if (x < 0 || x >= config.TileDimension || y < 0 || y >= config.TileDimension)
            {
                Debug.LogErrorFormat("The Sepcified Tile Index [{0}, {1}] exceeds the Tile Dimension [{3}, {4}] in map {5}",
                                     x, y, config.TileDimension, config.TileDimension, config.MapName);
                ExitOnBatchMode();
                return;
            }

            if (config.IsStreamScene)
            {
                ConfigGenerator(config);
                var streamScene = new MultiScene(config.GetSceneAssetPath(), config.SceneNamePattern, config.TileDimension, config.TileSize);
                var tileList    = new List <Index>();
                tileList.Add(new Index(x, y));
                streamScene.BakeTiles(tileList, config.ComputePerframe, config.TemporaryContainer);
            }
            else
            {
                BakeSingleSceneByConfig(config);
            }
        }
Ejemplo n.º 5
0
        public static void MergeStreamSceneOCData(OCSceneConfig config)
        {
            var scene = new MultiScene(config.GetSceneAssetPath(), config.SceneNamePattern, config.TileDimension, config.TileSize);

            scene.MergeOCData(config.TemporaryContainer);
            scene.CopyOCDataTo(config.TemporaryContainer);
        }
Ejemplo n.º 6
0
        public ScenePresetList(MultiScene target, List <MultiScene.SceneInfo> elements, Type elementType) : base(elements, elementType, true, false, true, true)
        {
            this.target = target;
            this.list   = elements;

            drawElementCallback = DrawElement;
            drawHeaderCallback  = DrawHeader;
            onRemoveCallback    = OnRemove;
            onAddCallback       = OnAdd;
        }
Ejemplo n.º 7
0
        //jenkins interface computer pvs data for one tile
        public static void GenerateOCDataForTile()
        {
            Config.IsBatchMode = true;
            var projectPath  = System.Environment.GetCommandLineArgs()[1];
            var index        = int.Parse(System.Environment.GetCommandLineArgs()[2]);
            var processorNum = int.Parse(System.Environment.GetCommandLineArgs()[3]);
            var x            = int.Parse(System.Environment.GetCommandLineArgs()[4]);
            var y            = int.Parse(System.Environment.GetCommandLineArgs()[5]);

            PrintArgs(5);

            //Config.CustomVolume = true;
            //Config.CustomVolumeCenter = new Vector3(100, 100, 100);
            //Config.CustomVolumeSize = new Vector3(10, 10, 10);

            var config = LoadSceneConfig(projectPath, 0);

            if (string.IsNullOrEmpty(config.MapName))
            {
                Debug.LogErrorFormat("Can not get oc map config for stream scene in oc data generation, path {0} index {1}", projectPath, 0);
                ExitOnBatchMode();
                return;
            }

            if (x < 0 || x >= config.TileDimension || y < 0 || y >= config.TileDimension)
            {
                Debug.LogErrorFormat("The Sepcified Tile Index [{0}, {1}] exceeds the Tile Dimension [{3}, {4}] in map {5}",
                                     x, y, config.TileDimension, config.TileDimension, config.MapName);
                ExitOnBatchMode();
                return;
            }

            if (config.IsStreamScene)
            {
                ConfigGenerator(config);
                var streamScene = new MultiScene(config.GetSceneAssetPath(), config.SceneNamePattern, config.TileDimension, config.TileSize);
                var tileList    = new List <Index>();
                tileList.Add(new Index(x, y));
                streamScene.BakeTiles(tileList, config.ComputePerframe, config.TemporaryContainer);
            }
            else if (index == 0)
            {
                BakeSingleSceneByConfig(config);
            }
            else
            {
                ExitOnBatchMode();
            }
        }
Ejemplo n.º 8
0
        public static void TestBakeAll(string sceneName)
        {
            var config = GetSceneConfig(sceneName);

            ConfigGenerator(config);

            if (config.IsStreamScene)
            {
                var multiScene = new MultiScene(config.GetSceneAssetPath(), config.SceneNamePattern, config.TileDimension, config.TileSize);
                multiScene.BakeTiles(config.indices, config.ComputePerframe, config.TemporaryContainer);
            }
            else
            {
                var scene = new SingleScene(config.GetSceneAssetPath(), config.SceneNamePattern, Index.InValidIndex);
                scene.Bake(true, "D:/OCTemp");
            }
        }
Ejemplo n.º 9
0
        private static void BakeStreamSceneByConfig(OCSceneConfig config)
        {
            Debug.Log("batch mode Do bake stream!");
            ConfigGenerator(config);
            var tiles = config.indices;

            if (tiles != null)
            {
                var multiScene = new MultiScene(config.GetSceneAssetPath(), config.SceneNamePattern, config.TileDimension, config.TileSize);
                multiScene.BakeTiles(tiles, config.ComputePerframe, config.TemporaryContainer);
            }
            else
            {
                Debug.LogErrorFormat("batch mode Can not get bake tiles for map {0}", config.MapName);
                ExitOnBatchMode();
            }
        }
Ejemplo n.º 10
0
    private static void CreateMultiScene()
    {
        MultiScene multi = CreateInstance <MultiScene>();

        multi.name = "New Multi-Scene";

        UnityEngine.Object parent = Selection.activeObject;

        string directory = "Assets";

        if (parent != null)
        {
            directory = AssetDatabase.GetAssetPath(parent.GetInstanceID());
            if (!Directory.Exists(directory))
            {
                directory = Path.GetDirectoryName(directory);
            }
        }

        ProjectWindowUtil.CreateAsset(multi, $"{directory}/{multi.name}.asset");
    }
Ejemplo n.º 11
0
 public static void LoadMultiScene(MultiScene multiScene, LoadSceneMode mode = LoadSceneMode.Single)
 => multiScene.sceneAssets.For(sceneInfo => SceneManager.LoadScene(sceneInfo.asset, mode));
Ejemplo n.º 12
0
    private static void OpenMultiScene(MultiScene obj, bool additive)
    {
        Scene activeScene = default;

        if (additive || EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())
        {
            List <string> firstUnloadedScenes   = new List <string>();
            bool          inFirstUnloadedScenes = true;
            Scene         firstLoadedScene      = default;

            foreach (MultiScene.SceneInfo info in obj.sceneAssets)
            {
                if (info.asset == null)
                {
                    continue;
                }

                string        path          = AssetDatabase.GetAssetPath(((SceneAsset)info.asset).GetInstanceID());
                OpenSceneMode mode          = OpenSceneMode.Single;
                bool          isActiveScene = (SceneAsset)info.asset == obj.activeScene;

                bool exitedFirstUnloadedScenes = false;
                if (inFirstUnloadedScenes)
                {
                    if (!isActiveScene && !info.loadScene)
                    {
                        firstUnloadedScenes.Add(path);
                        continue;
                    }

                    inFirstUnloadedScenes     = false;
                    exitedFirstUnloadedScenes = true;
                }

                if ((!exitedFirstUnloadedScenes) || additive)
                {
                    mode = ((!additive && isActiveScene) || info.loadScene)
                                                ? OpenSceneMode.Additive
                                                : OpenSceneMode.AdditiveWithoutLoading;
                }

                Scene scene = EditorSceneManager.OpenScene(path, mode);

                if (isActiveScene)
                {
                    activeScene = scene;
                }
                if (exitedFirstUnloadedScenes)
                {
                    firstLoadedScene = scene;
                }
            }

            foreach (string path in firstUnloadedScenes)
            {
                Scene scene = EditorSceneManager.OpenScene(path, OpenSceneMode.AdditiveWithoutLoading);

                if (firstLoadedScene.IsValid())
                {
                    EditorSceneManager.MoveSceneBefore(scene, firstLoadedScene);
                }
            }
        }
        if (!additive && activeScene.IsValid())
        {
            SceneManager.SetActiveScene(activeScene);
        }
    }
Ejemplo n.º 13
0
    private static void OpenMultiscene(MultiScene obj, bool additive)
    {
        Scene activeScene = default(Scene);

        if (additive || EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo())
        {
            var   firstUnloadedScenes   = new List <string>();
            var   inFirstUnloadedScenes = true;
            Scene firstLoadedScene      = default(Scene);
            for (int i = 0; i < obj.sceneAssets.Count; i++)
            {
                var info = obj.sceneAssets[i];
                if (info.asset == null)
                {
                    continue;
                }
                var path          = AssetDatabase.GetAssetPath(info.asset.GetInstanceID());
                var mode          = OpenSceneMode.Single;
                var isActiveScene = info.asset == obj.activeScene;

                var exitedFirstUnloadedScenes = false;
                if (inFirstUnloadedScenes)
                {
                    if (!isActiveScene && !info.loadScene)
                    {
                        firstUnloadedScenes.Add(path);
                        continue;
                    }
                    else
                    {
                        inFirstUnloadedScenes     = false;
                        exitedFirstUnloadedScenes = true;
                    }
                }

                if ((!inFirstUnloadedScenes && !exitedFirstUnloadedScenes) || (additive && exitedFirstUnloadedScenes))
                {
                    if ((!additive && isActiveScene) || info.loadScene)
                    {
                        mode = OpenSceneMode.Additive;
                    }
                    else
                    {
                        mode = OpenSceneMode.AdditiveWithoutLoading;
                    }
                }

                var scene = EditorSceneManager.OpenScene(path, mode);

                if (isActiveScene)
                {
                    activeScene = scene;
                }
                if (exitedFirstUnloadedScenes)
                {
                    firstLoadedScene = scene;
                }
            }

            for (int i = 0; i < firstUnloadedScenes.Count; i++)
            {
                var path  = firstUnloadedScenes[i];
                var scene = EditorSceneManager.OpenScene(path, OpenSceneMode.AdditiveWithoutLoading);
                if (firstLoadedScene.IsValid())
                {
                    EditorSceneManager.MoveSceneBefore(scene, firstLoadedScene);
                }
            }
        }
        if (!additive && activeScene.IsValid())
        {
            EditorSceneManager.SetActiveScene(activeScene);
        }
    }
Ejemplo n.º 14
0
 void OnEnable()
 {
     target = (MultiScene)base.target;
     list   = new ScenePresetList(target, target.sceneAssets, typeof(SceneAsset));
 }
Ejemplo n.º 15
0
        public static bool OpenAllScenesAndGernerateGUID(string mapName)
        {
            var config = GetSceneConfig(mapName);

            if (string.IsNullOrEmpty(config.MapName))
            {
                return(false);
            }

            if (config.IsStreamScene)
            {
                Util.ClearScenes();

                var tiles = config.indices;

                var multiScene = new MultiScene(config.GetSceneAssetPath(), config.SceneNamePattern, config.TileDimension, config.TileSize);

                foreach (var tile in tiles)
                {
                    int tileX = tile.x;
                    int tileY = tile.y;

                    int tileDimension = config.TileDimension;
                    for (int x = 0; x < tileDimension; ++x)
                    {
                        for (int y = 0; y < tileDimension; ++y)
                        {
                            if (Math.Abs(x - tileX) > 1 || Math.Abs(y - tileY) > 1)
                            {
                                continue;
                            }

                            //string scenePath = string.Format("{0}/{1}.unity", config.GetSceneAssetPath(), string.Format(config.SceneNamePattern, x, y));

                            Util.OpenScene(config.GetSceneAssetPath(), string.Format(config.SceneNamePattern, x, y), OpenSceneMode.Single);
                            Util.OpenScene(config.GetSceneAssetPath() + "/Streaming", string.Format(config.SceneNamePattern, x, y) + SingleScene.StreamSuffix, OpenSceneMode.Additive);

                            SingleScene scene = new SingleScene(config.GetSceneAssetPath(), string.Format(config.SceneNamePattern, x, y), new Index(x, y), null, multiScene);
                            scene.GeneraterRenderableObjectID();

                            multiScene.AddMaxGUID(x, y, scene.MaxGameObjectIDCount);
                        }
                    }
                }

                multiScene.Save();
            }
            else
            {
                //string scenePath = string.Format("{0}/{1}.unity", config.GetSceneAssetPath(), config.SceneNamePattern);
                Util.OpenScene(config.GetSceneAssetPath(), config.SceneNamePattern, OpenSceneMode.Single);

                var singleScene = new SingleScene(config.GetSceneAssetPath(), config.SceneNamePattern, Index.InValidIndex);
                singleScene.GeneraterRenderableObjectID();
                singleScene.Save();
            }



            return(true);
        }