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");
}
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);
}
protected override void OnEnable()
{
base.OnEnable();
target = (MultiScene)base.target;
list = new ScenePresetList(target, target.sceneAssets, typeof(SceneAsset));
}
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);
}
}
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);
}
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;
}
//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();
}
}
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");
}
}
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();
}
}
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");
}
public static void LoadMultiScene(MultiScene multiScene, LoadSceneMode mode = LoadSceneMode.Single) => multiScene.sceneAssets.For(sceneInfo => SceneManager.LoadScene(sceneInfo.asset, mode));
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);
}
}
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);
}
}
void OnEnable()
{
target = (MultiScene)base.target;
list = new ScenePresetList(target, target.sceneAssets, typeof(SceneAsset));
}
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);
}