void SaveGUIDArray(NativeList <int4x4> arr)
{
byte[] cacheArray = SceneStreaming.GetByteArray(arr.Length * sizeof(int4x4) + sizeof(int));
int * intPtr = (int *)cacheArray.Ptr();
*intPtr = arr.Length;
UnsafeUtility.MemCpy(intPtr + 1, arr.unsafePtr, sizeof(int4x4) * arr.Length);
fsm.Write(cacheArray, 0, arr.Length * sizeof(int4x4) + sizeof(int));
}
void SaveMaterialArray(NativeList <VirtualMaterial.MaterialProperties> arr)
{
byte[] cacheArray = SceneStreaming.GetByteArray(arr.Length * sizeof(VirtualMaterial.MaterialProperties) + sizeof(int));
int * intPtr = (int *)cacheArray.Ptr();
*intPtr = arr.Length;
UnsafeUtility.MemCpy(intPtr + 1, arr.unsafePtr, sizeof(VirtualMaterial.MaterialProperties) * arr.Length);
fsm.Write(cacheArray, 0, arr.Length * sizeof(VirtualMaterial.MaterialProperties) + sizeof(int));
}
/*
* private void Update()
* {
* if(state == State.Loaded)
* {
* SceneController.MoveScene(propertyCount, (float3)transform.position - originPos, loader.clusterCount);
* originPos = transform.position;
* }
* }
*/
public static IEnumerator Separate(SceneStreaming parent, List <SceneStreaming> children)
{
while (loading)
{
yield return(null);
}
loading = true;
if (children.Count > 0)
{
var scene = children[0];
if (scene.state == State.Unloaded)
{
scene.waiting = true;
scene.state = State.Loading;
LoadingThread.AddCommand(generateAsyncFunc, scene);
}
for (int i = 1; i < children.Count; ++i)
{
var lastScene = children[i - 1];
while (lastScene.state == State.Loading)
{
yield return(null);
}
scene = children[i];
if (scene.state == State.Unloaded)
{
scene = children[i];
scene.waiting = true;
scene.state = State.Loading;
LoadingThread.AddCommand(generateAsyncFunc, scene);
}
}
scene = children[children.Count - 1];
while (scene.state == State.Loading)
{
yield return(null);
}
SceneController.baseBuffer.clusterCount = SceneController.baseBuffer.prepareClusterCount;
}
if (parent)
{
var deleteScene = parent;
if (deleteScene.state == State.Loaded)
{
deleteScene.DeleteSyncGPU();
deleteScene.DeleteDisposeMemory();
}
}
loading = false;
}
void SaveClusterData(NativeList <Cluster> cluster, NativeList <Point> points, NativeList <int> triangleMats)
{
int length = cluster.Length * sizeof(Cluster) + points.Length * sizeof(Point) + triangleMats.Length * sizeof(int);
byte[] bytes = SceneStreaming.GetByteArray(length);
fixed(byte *b = bytes)
{
UnsafeUtility.MemCpy(b, cluster.unsafePtr, cluster.Length * sizeof(Cluster));
UnsafeUtility.MemCpy(b + cluster.Length * sizeof(Cluster), points.unsafePtr, points.Length * sizeof(Point));
UnsafeUtility.MemCpy(b + cluster.Length * sizeof(Cluster) + points.Length * sizeof(Point), triangleMats.unsafePtr, triangleMats.Length * sizeof(int));
}
fsm.Write(bytes, 0, length);
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.Space))
{
if (sb)
{
StartCoroutine(SceneStreaming.Combine(parentStreamer, streamers));
}
else
{
StartCoroutine(SceneStreaming.Separate(parentStreamer, streamers));
}
sb = !sb;
}
}
void LoadClusterData(out NativeList <Cluster> cluster, out NativeList <Point> points, out NativeList <int> triangleMats)
{
cluster = new NativeList <Cluster>(clusterCount, clusterCount, Allocator.Persistent);
points = new NativeList <Point>(clusterCount * PipelineBaseBuffer.CLUSTERCLIPCOUNT, clusterCount * PipelineBaseBuffer.CLUSTERCLIPCOUNT, Allocator.Persistent);
triangleMats = new NativeList <int>(clusterCount * PipelineBaseBuffer.CLUSTERTRIANGLECOUNT, clusterCount * PipelineBaseBuffer.CLUSTERTRIANGLECOUNT, Allocator.Persistent);
int length = cluster.Length * sizeof(Cluster) + points.Length * sizeof(Point) + triangleMats.Length * sizeof(int);
byte[] bytes = SceneStreaming.GetByteArray(length);
fsm.Read(bytes, 0, length);
fixed(byte *b = bytes)
{
UnsafeUtility.MemCpy(cluster.unsafePtr, b, cluster.Length * sizeof(Cluster));
UnsafeUtility.MemCpy(points.unsafePtr, b + cluster.Length * sizeof(Cluster), points.Length * sizeof(Point));
UnsafeUtility.MemCpy(triangleMats.unsafePtr, b + cluster.Length * sizeof(Cluster) + points.Length * sizeof(Point), triangleMats.Length * sizeof(int));
}
}
public void TransformScene(uint value, MonoBehaviour behavior)
{
if (value < allScenes.Count)
{
SceneStreaming str = allScenes[(int)value];
if (str.state == SceneStreaming.State.Loaded)
{
// str.DeleteSync();
behavior.StartCoroutine(str.Delete());
}
else if (str.state == SceneStreaming.State.Unloaded)
{
// str.GenerateSync();
behavior.StartCoroutine(str.Generate());
}
}
}
//Press number load scene
public static void Update(MonoBehaviour behavior)
{
/* int value;
* if (int.TryParse(Input.inputString, out value) && value < testNodeArray.Length)
* {
* Random rd = new Random((uint)Guid.NewGuid().GetHashCode());
* addList.Add(testNodeArray[value]);
* TerrainQuadTree.QuadTreeNode* node = (TerrainQuadTree.QuadTreeNode*)testNodeArray[value];
* if (node->listPosition < 0)
* {
* NativeArray<float> heightMap = new NativeArray<float>(commonData.terrainDrawStreaming.heightMapSize, Allocator.Temp);
* for(int i = 0; i < heightMap.Length; ++i)
* {
* heightMap[i] = (float)(rd.NextDouble() * 0.2);
* }
* commonData.terrainDrawStreaming.AddQuadTrees(addList, heightMap);
*
* }
* else
* {
* commonData.terrainDrawStreaming.RemoveQuadTrees(addList);
* }
* addList.Clear();
* }
*/
int value;
if (int.TryParse(Input.inputString, out value))
{
if (value < allScenes.Count)
{
SceneStreaming str = allScenes[value];
if (str.state == SceneStreaming.State.Loaded)
{
behavior.StartCoroutine(str.Delete());
}
else if (str.state == SceneStreaming.State.Unloaded)
{
behavior.StartCoroutine(str.Generate());
}
}
}
}
void LoadMaterialArray(ref NativeList <VirtualMaterial.MaterialProperties> arr)
{
byte[] cacheArray = SceneStreaming.GetByteArray(4);
fsm.Read(cacheArray, 0, 4);
int len = *(int *)cacheArray.Ptr();
if (arr.isCreated)
{
arr.Clear();
}
else
{
arr = new NativeList <VirtualMaterial.MaterialProperties>(len, Allocator.Persistent);
}
cacheArray = SceneStreaming.GetByteArray(sizeof(VirtualMaterial.MaterialProperties) * len);
fsm.Read(cacheArray, 0, sizeof(VirtualMaterial.MaterialProperties) * len);
VirtualMaterial.MaterialProperties *arrPtr = (VirtualMaterial.MaterialProperties *)cacheArray.Ptr();
arr.AddRange(arrPtr, len);
}
//Press number load scene
private void Update()
{
int value;
if (int.TryParse(Input.inputString, out value))
{
if (value < allScenes.Count)
{
SceneStreaming str = allScenes[value];
if (str.state == SceneStreaming.State.Loaded)
{
StartCoroutine(str.Delete());
}
else if (str.state == SceneStreaming.State.Unloaded)
{
StartCoroutine(str.Generate());
}
}
}
}
void LoadGUIDArray(ref NativeList <int4x4> arr)
{
byte[] cacheArray = SceneStreaming.GetByteArray(4);
fsm.Read(cacheArray, 0, 4);
int len = *(int *)cacheArray.Ptr();
if (arr.isCreated)
{
arr.Clear();
}
else
{
arr = new NativeList <int4x4>(len, Allocator.Persistent);
}
cacheArray = SceneStreaming.GetByteArray(sizeof(int4x4) * len);
fsm.Read(cacheArray, 0, sizeof(int4x4) * len);
int4x4 *arrPtr = (int4x4 *)cacheArray.Ptr();
arr.AddRange(arrPtr, len);
}
private void Update()
{
int value;
if (int.TryParse(Input.inputString, out value))
{
if (value < allScenes.Count)
{
SceneStreaming str = allScenes[value];
if (str.state == SceneStreaming.State.Loaded)
{
StartCoroutine(str.Delete());
}
else if (str.state == SceneStreaming.State.Unloaded)
{
StartCoroutine(str.Generate());
}
}
}
lock (SceneStreaming.commandQueue)
{
SceneStreaming.commandQueue.Run(ref data.baseBuffer, data.resources);
}
}
public void TryThis()
{
bool save = false;
if (res == null)
{
save = true;
res = ScriptableObject.CreateInstance <ClusterMatResources>();
res.name = "SceneManager";
res.clusterProperties = new List <SceneStreaming>();
}
SceneStreaming property = new SceneStreaming();
SceneStreamLoader loader = new SceneStreamLoader();
loader.fsm = new FileStream(ClusterMatResources.infosPath + modelName + ".mpipe", FileMode.OpenOrCreate, FileAccess.ReadWrite);
property.name = modelName;
int containIndex = -1;
for (int i = 0; i < res.clusterProperties.Count; ++i)
{
if (property.name == res.clusterProperties[i].name)
{
containIndex = i;
break;
}
}
LODGroup[] groups = GetComponentsInChildren <LODGroup>();
Dictionary <MeshRenderer, bool> lowLevelDict = new Dictionary <MeshRenderer, bool>();
foreach (var i in groups)
{
LOD[] lods = i.GetLODs();
for (int j = 1; j < lods.Length; ++j)
{
foreach (var k in lods[j].renderers)
{
if (k.GetType() == typeof(MeshRenderer))
{
lowLevelDict.Add(k as MeshRenderer, true);
}
}
}
}
CombinedModel model = ProcessCluster(GetComponentsInChildren <MeshRenderer>(false), ref loader, lowLevelDict);
loader.clusterCount = ClusterGenerator.GenerateCluster(model.allPoints, model.allMatIndex, model.bound, voxelCount, containIndex < 0 ? res.clusterProperties.Count : containIndex, ref loader);
res.maximumMaterialCount = Mathf.Max(1, res.maximumMaterialCount);
res.maximumMaterialCount = Mathf.Max(res.maximumMaterialCount, loader.allProperties.Length);
if (containIndex < 0)
{
res.clusterProperties.Add(property);
}
else
{
res.clusterProperties[containIndex] = property;
}
if (save)
{
AssetDatabase.CreateAsset(res, "Assets/SceneManager.asset");
}
else
{
EditorUtility.SetDirty(res);
}
loader.SaveAll();
loader.Dispose();
}
void SaveClusterCount()
{
byte[] bytes = SceneStreaming.GetByteArray(4);
*(int *)bytes.Ptr() = clusterCount;
fsm.Write(bytes, 0, 4);
}
void LoadClusterCount()
{
byte[] bytes = SceneStreaming.GetByteArray(4);
fsm.Read(bytes, 0, 4);
clusterCount = *(int *)bytes.Ptr();
}
private IEnumerator Loader()
{
while (enabled)
{
LoadCommand cmd;
if (allLoadingCommand.TryDequeue(out cmd))
{
switch (cmd.ope)
{
case LoadCommand.Operator.Combine:
childrenList.Clear();
if (allGPURPScene[cmd.leftDownSon])
{
childrenList.Add(allGPURPScene[cmd.leftDownSon]);
}
if (allGPURPScene[cmd.leftUpSon])
{
childrenList.Add(allGPURPScene[cmd.leftUpSon]);
}
if (allGPURPScene[cmd.rightDownSon])
{
childrenList.Add(allGPURPScene[cmd.rightDownSon]);
}
if (allGPURPScene[cmd.rightUpSon])
{
childrenList.Add(allGPURPScene[cmd.rightUpSon]);
}
yield return(SceneStreaming.Combine(allGPURPScene[cmd.parent], childrenList));
break;
case LoadCommand.Operator.Disable:
yield return(allGPURPScene[cmd.parent].Delete());
break;
case LoadCommand.Operator.Enable:
yield return(allGPURPScene[cmd.parent].Generate());
break;
case LoadCommand.Operator.Separate:
childrenList.Clear();
if (allGPURPScene[cmd.leftDownSon])
{
childrenList.Add(allGPURPScene[cmd.leftDownSon]);
}
if (allGPURPScene[cmd.leftUpSon])
{
childrenList.Add(allGPURPScene[cmd.leftUpSon]);
}
if (allGPURPScene[cmd.rightDownSon])
{
childrenList.Add(allGPURPScene[cmd.rightDownSon]);
}
if (allGPURPScene[cmd.rightUpSon])
{
childrenList.Add(allGPURPScene[cmd.rightUpSon]);
}
yield return(SceneStreaming.Separate(allGPURPScene[cmd.parent], childrenList));
break;
}
}
else
{
yield return(null);
}
}
}
