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); } } }