generated from max/template-unity-project
432 lines
17 KiB
C#
432 lines
17 KiB
C#
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text.RegularExpressions;
|
|
using UnityEditor;
|
|
using UnityEditor.SceneManagement;
|
|
using UnityEngine;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
namespace VertexColor.ScenePartition.Editor
|
|
{
|
|
[CreateAssetMenu(fileName = "Scene", menuName = "Max/ScenePartitionSO")]
|
|
public class ScenePartitionSO : ScriptableObject
|
|
{
|
|
[field: SerializeField]
|
|
public SceneAsset SceneAsset { get; private set; } = null;
|
|
public string SceneName => SceneAsset == null ? name : SceneAsset.name;
|
|
|
|
public List<ulong> alwaysLoadIds = new List<ulong> { 0, 1, 2, 3, 4 };
|
|
|
|
public ScenePartitionData Data
|
|
{
|
|
get
|
|
{
|
|
// Load data from the ScriptableSingleton.
|
|
data ??= ScenePartitionSS.instance.GetScenePartitionData(this);
|
|
return data;
|
|
}
|
|
}
|
|
private ScenePartitionData data = null;
|
|
|
|
public void CreateScene()
|
|
{
|
|
if (SceneAsset != null) return;
|
|
|
|
string scenePath = Path.Combine(AssetDatabase.GetAssetPath(this), $"../{this.name}.unity");
|
|
|
|
Scene scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
|
|
EditorSceneManager.SaveScene(scene, scenePath);
|
|
Save();
|
|
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.Refresh();
|
|
|
|
SceneAsset = AssetDatabase.LoadAssetAtPath<SceneAsset>(scenePath);
|
|
|
|
AssetDatabase.SaveAssets();
|
|
AssetDatabase.Refresh();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load partitions from disk and construct the scene file.
|
|
/// </summary>
|
|
public void LoadAll()
|
|
{
|
|
CreateScenePartitions();
|
|
SortedSet<ulong> ids = new SortedSet<ulong>(Data.ScenePartitions.Keys);
|
|
LoadScenePartitions(ids);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Discard changes and reload loaded partitions.
|
|
/// </summary>
|
|
public void Reload()
|
|
{
|
|
if (!Data.HasLoadedPartitions) return;
|
|
LoadScenePartitions(new SortedSet<ulong>(Data.LoadedScenePartitions.Keys));
|
|
}
|
|
|
|
private void CreateScenePartitions()
|
|
{
|
|
string dataPath = ScenePartitionUtils.GetDataPath(this);
|
|
string[] files = Directory.GetFiles(dataPath);
|
|
|
|
Data.ScenePartitions = new ScenePartitionSortedList();
|
|
|
|
for (int i = 0; i < files.Length; i++)
|
|
{
|
|
ScenePartition scenePartition = new ScenePartition(files[i]);
|
|
Data.ScenePartitions.Add(scenePartition.id, scenePartition);
|
|
}
|
|
}
|
|
|
|
private void LoadScenePartitions(SortedSet<ulong> partitionIds)
|
|
{
|
|
using (new ProfilerUtility.ProfilerScope($"{nameof(LoadScenePartitions)}"))
|
|
{
|
|
if (!Data.HasCreatedPartitions) return;
|
|
|
|
string scenePath = ScenePartitionUtils.GetScenePath(this);
|
|
|
|
Data.LoadedScenePartitions.Clear();
|
|
|
|
// Add always load ids.
|
|
SortedSet<ulong> baseIds = GetAlwaysLoadIds();
|
|
foreach (ulong id in baseIds)
|
|
{
|
|
partitionIds.Add(id);
|
|
}
|
|
|
|
// Clear file.
|
|
File.WriteAllText(scenePath, string.Empty);
|
|
|
|
// Create scene data.
|
|
try
|
|
{
|
|
using (FileStream outputStream = new FileStream(scenePath, FileMode.Append, FileAccess.Write))
|
|
{
|
|
foreach (ulong id in partitionIds)
|
|
{
|
|
ScenePartition p = Data.ScenePartitions[id];
|
|
|
|
using (FileStream inputStream = new FileStream(p.filePath, FileMode.Open, FileAccess.Read))
|
|
{
|
|
byte[] buffer = new byte[4096];
|
|
int bytesRead;
|
|
while ((bytesRead = inputStream.Read(buffer, 0, buffer.Length)) > 0)
|
|
{
|
|
outputStream.Write(buffer, 0, bytesRead);
|
|
}
|
|
}
|
|
|
|
Data.LoadedScenePartitions.Add(p.id, p);
|
|
}
|
|
}
|
|
}
|
|
catch (System.Exception ex)
|
|
{
|
|
Debug.LogException(ex);
|
|
}
|
|
|
|
AssetDatabase.Refresh();
|
|
// 'Reload' the scene to prevent the user getting the popup 'Scene has been changed on disk'.
|
|
EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert scene to partitions and save them to disk.
|
|
/// </summary>
|
|
public void Save()
|
|
{
|
|
using (new ProfilerUtility.ProfilerScope($"{nameof(Save)}"))
|
|
{
|
|
// Check if the user wants to save the scene if dirty.
|
|
if (!EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) return;
|
|
|
|
DeleteLoadedPartitions(); // Delete the loaded partitions from disk so we can write the new ones.
|
|
|
|
string pattern = @"&(\d+)";
|
|
string dataPath = ScenePartitionUtils.GetDataPath(this);
|
|
string scenePath = ScenePartitionUtils.GetScenePath(this);
|
|
|
|
// Read the data from the scene file.
|
|
string[] sceneData = File.ReadAllLines(scenePath);
|
|
|
|
// Split it into blocks.
|
|
int lastIndex = sceneData.Length;
|
|
for (int i = sceneData.Length - 1; i >= 0; i--)
|
|
{
|
|
if (sceneData[i].StartsWith("---")) // --- is the start of a new yaml document.
|
|
{
|
|
Match match = Regex.Match(sceneData[i], pattern);
|
|
|
|
if (match.Success)
|
|
{
|
|
// Modify scene data.
|
|
// Optional: ClearRootOrderProperty.
|
|
ClearRootOrderProperty(ref sceneData, i, lastIndex);
|
|
|
|
// Extract the file number.
|
|
string id = match.Groups[1].Value;
|
|
|
|
// Write data to disk.
|
|
File.WriteAllLines($"{dataPath}/{SceneName}-{id}.yaml", sceneData[i..lastIndex]);
|
|
}
|
|
|
|
lastIndex = i;
|
|
}
|
|
}
|
|
|
|
// Write header to disk.
|
|
File.WriteAllLines($"{dataPath}/{SceneName}.yaml", sceneData[0..lastIndex]);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Empty the scene and save it (so it has no changes in source control).
|
|
/// </summary>
|
|
public void Unload()
|
|
{
|
|
using (new ProfilerUtility.ProfilerScope($"{nameof(Unload)}"))
|
|
{
|
|
string dataPath = ScenePartitionUtils.GetDataPath(this);
|
|
string scenePath = ScenePartitionUtils.GetScenePath(this);
|
|
|
|
Scene scene = EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single);
|
|
|
|
GameObject[] gameObjects = scene.GetRootGameObjects();
|
|
|
|
for (int i = gameObjects.Length - 1; i >= 0; i--)
|
|
{
|
|
DestroyImmediate(gameObjects[i]);
|
|
}
|
|
|
|
EditorSceneManager.SaveScene(scene);
|
|
|
|
Data.LoadedScenePartitions.Clear();
|
|
|
|
AssetDatabase.Refresh();
|
|
}
|
|
}
|
|
|
|
private void DeleteLoadedPartitions()
|
|
{
|
|
using (new ProfilerUtility.ProfilerScope($"{nameof(DeleteLoadedPartitions)}"))
|
|
{
|
|
if (!Data.HasLoadedPartitions) return;
|
|
|
|
foreach (KeyValuePair<ulong, ScenePartition> scenePartition in Data.LoadedScenePartitions)
|
|
{
|
|
if (!File.Exists(scenePartition.Value.filePath)) continue;
|
|
|
|
File.Delete(scenePartition.Value.filePath);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void LoadPartitions(ulong[] ids)
|
|
{
|
|
using (new ProfilerUtility.ProfilerScope($"{nameof(LoadPartitions)}"))
|
|
{
|
|
SortedSet<ulong> partitionIds = new SortedSet<ulong>();
|
|
|
|
for (int i = 0; i < ids.Length; i++)
|
|
{
|
|
SortedSet<ulong> connections = ScenePartitionUtils.FindDeeplyLinkedObjects(Data.ScenePartitions, ids[i]);
|
|
foreach (ulong c in connections)
|
|
{
|
|
partitionIds.Add(c);
|
|
}
|
|
}
|
|
|
|
LoadScenePartitions(partitionIds);
|
|
}
|
|
}
|
|
|
|
public void LoadPartitionsAdditive(ulong[] ids)
|
|
{
|
|
using (new ProfilerUtility.ProfilerScope($"{nameof(LoadPartitions)}"))
|
|
{
|
|
SortedSet<ulong> partitionIds = new SortedSet<ulong>();
|
|
|
|
// Additive partitions to load.
|
|
for (int i = 0; i < ids.Length; i++)
|
|
{
|
|
SortedSet<ulong> connections = ScenePartitionUtils.FindDeeplyLinkedObjects(Data.ScenePartitions, ids[i]);
|
|
foreach (ulong c in connections)
|
|
{
|
|
partitionIds.Add(c);
|
|
}
|
|
}
|
|
|
|
// Partitions already loaded.
|
|
if (Data.HasLoadedPartitions)
|
|
{
|
|
foreach (KeyValuePair<ulong, ScenePartition> item in Data.LoadedScenePartitions)
|
|
{
|
|
partitionIds.Add(item.Key);
|
|
}
|
|
}
|
|
|
|
LoadScenePartitions(partitionIds);
|
|
}
|
|
}
|
|
|
|
private SortedSet<ulong> GetAlwaysLoadIds()
|
|
{
|
|
SortedSet<ulong> partitionIds = new SortedSet<ulong>();
|
|
|
|
foreach (ulong id in alwaysLoadIds)
|
|
{
|
|
SortedSet<ulong> connections = ScenePartitionUtils.FindDeeplyLinkedObjects(Data.ScenePartitions, id);
|
|
foreach (ulong c in connections)
|
|
{
|
|
partitionIds.Add(c);
|
|
}
|
|
}
|
|
|
|
return partitionIds;
|
|
}
|
|
|
|
public void GenerateSceneGridData()
|
|
{
|
|
using (new ProfilerUtility.ProfilerScope($"{nameof(GenerateSceneGridData)}"))
|
|
{
|
|
LoadAll();
|
|
|
|
if (!Data.HasCreatedPartitions) return;
|
|
|
|
Scene scene = EditorSceneManager.OpenScene(ScenePartitionUtils.GetScenePath(this), OpenSceneMode.Single);
|
|
|
|
GameObject[] rootGameObjects = scene.GetRootGameObjects();
|
|
|
|
Data.SceneGrid.Grid.Clear();
|
|
|
|
//// Maybe later switch to getting the data from disk instead of loading the scene and then unloading it again.
|
|
//foreach (GameObject gameObject in rootGameObjects)
|
|
//{
|
|
// // https://forum.unity.com/threads/how-to-get-the-local-identifier-in-file-for-scene-objects.265686/
|
|
// PropertyInfo inspectorModeInfo = typeof(SerializedObject).GetProperty("inspectorMode", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
// SerializedObject serializedObject = new SerializedObject(gameObject.transform);
|
|
// inspectorModeInfo.SetValue(serializedObject, InspectorMode.Debug, null);
|
|
// SerializedProperty localIdProp = serializedObject.FindProperty("m_LocalIdentfierInFile");
|
|
|
|
// long localId = localIdProp.longValue;
|
|
|
|
// if (localId == 0)
|
|
// {
|
|
// if (PrefabUtility.IsPartOfPrefabInstance(gameObject))
|
|
// {
|
|
// GlobalObjectId id = GlobalObjectId.GetGlobalObjectIdSlow(gameObject); // We could use this funtion for all objects. Might be a bit slower but is also simple.
|
|
// localId = long.Parse(id.targetPrefabId.ToString());
|
|
|
|
// Debug.Log($"{id.assetGUID} | {id.identifierType} | {id.targetObjectId} | {id.targetPrefabId}");
|
|
|
|
// if (id.targetObjectId == 0 && id.targetPrefabId == 0)
|
|
// {
|
|
// Debug.LogWarning($"Could not find LocalIdentfierInFile for {gameObject.transform} {gameObject.name} {gameObject.transform.GetInstanceID()}");
|
|
// continue;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// Debug.LogWarning($"Could not find LocalIdentfierInFile for {gameObject.transform} {gameObject.name} {gameObject.transform.GetInstanceID()}");
|
|
// continue;
|
|
// }
|
|
// }
|
|
|
|
// if (!Data.ScenePartitions.ContainsKey(localId))
|
|
// {
|
|
// Debug.LogWarning($"Could not find LocalIdentfierInFile for {gameObject.transform} {gameObject.name} {gameObject.transform.GetInstanceID()}");
|
|
// continue;
|
|
// }
|
|
|
|
// Data.SceneGrid.Insert(localId, gameObject.transform.position);
|
|
//}
|
|
|
|
GlobalObjectId[] ids = new GlobalObjectId[rootGameObjects.Length];
|
|
GlobalObjectId.GetGlobalObjectIdsSlow(rootGameObjects, ids);
|
|
|
|
for (int i = 0; i < ids.Length; i++)
|
|
{
|
|
//Debug.Log($"{ids[i].assetGUID} | {ids[i].identifierType} | {ids[i].targetObjectId} | {ids[i].targetPrefabId}");
|
|
|
|
if (ids[i].targetPrefabId == 0) // 0 = no prefab.
|
|
{
|
|
Data.SceneGrid.Insert(ids[i].targetObjectId, rootGameObjects[i].transform.position, ScenePartitionSceneViewEditor.cellSize);
|
|
}
|
|
else
|
|
{
|
|
Data.SceneGrid.Insert(ids[i].targetPrefabId, rootGameObjects[i].transform.position, ScenePartitionSceneViewEditor.cellSize);
|
|
}
|
|
}
|
|
|
|
Unload();
|
|
}
|
|
}
|
|
|
|
public void LoadCell(int gridId)
|
|
{
|
|
if (Data.SceneGrid.Grid.TryGetValue(gridId, out GridList ids))
|
|
{
|
|
LoadPartitions(ids.list.ToArray());
|
|
}
|
|
}
|
|
|
|
public void LoadCellAdditive(int gridId)
|
|
{
|
|
if (Data.SceneGrid.Grid.TryGetValue(gridId, out GridList ids))
|
|
{
|
|
LoadPartitionsAdditive(ids.list.ToArray());
|
|
}
|
|
}
|
|
|
|
public void ClearCache()
|
|
{
|
|
data = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the m_RootOrder property to '0' on all transforms and prefab transform modifications.
|
|
/// The property changes every time you add/remove something in the scene for each object underneat it in the hierarchy.
|
|
/// This results in a lot of changes in source control that might cause conficts, and we don't want that.
|
|
/// This does however change the scene hierarchy order, so if things are order dependent this will break it.
|
|
/// </summary>
|
|
private void ClearRootOrderProperty(ref string[] data, int i, int lastIndex)
|
|
{
|
|
using (new ProfilerUtility.ProfilerScope($"{nameof(ClearRootOrderProperty)}"))
|
|
{
|
|
const string prefabHeaderPattern = "--- !u!1001 &";
|
|
const string transformHeaderPattern = "--- !u!4 &";
|
|
const string prefabRootOrderPropertyPattern = " propertyPath: m_RootOrder";
|
|
const string transformRootOrderPropertyPattern = " m_RootOrder:";
|
|
const string numberPattern = @"[\d-]";
|
|
|
|
// If object is a Prefab.
|
|
if (data[i].StartsWith(prefabHeaderPattern))
|
|
{
|
|
for (int j = i; j < lastIndex; j++)
|
|
{
|
|
if (!data[j].StartsWith(prefabRootOrderPropertyPattern)) continue;
|
|
|
|
data[j + 1] = Regex.Replace(data[j + 1], numberPattern, "0");
|
|
return;
|
|
}
|
|
}
|
|
// If object is a Transform.
|
|
else if (data[i].StartsWith(transformHeaderPattern))
|
|
{
|
|
// Reverse loop since property is usually at the bottom of the transform component.
|
|
for (int j = lastIndex - 1; j >= 0; j--)
|
|
{
|
|
if (!data[j].StartsWith(transformRootOrderPropertyPattern)) continue;
|
|
|
|
data[j] = Regex.Replace(data[j], numberPattern, "0");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} |