void Start() { miner = GameObject.Find("Player").GetComponent <VoxelMining>(); Array3 <Voxel> voxels = WorldGenerator.CreateVoxels(33, 0, 1.0f, Vector3.zero); //Array3<Voxel> voxels = WorldGenerator.CreateVoxels(64, 0, 1.0f, Vector3.zero); MeshData data = MarchingCubes.CalculateMeshData(voxels, 1.0f); Mesh mesh = data.CreateMesh(); go = SplitManager.GetObject(); go.mr.enabled = false; go.mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided; go.mf.sharedMesh = mesh; go.mr.material = testMat; MeshData data2 = MarchingTetrahedra.CalculateMeshData(voxels, 1.0f); data2.CalculateSharedNormals(); Mesh mesh2 = data2.CreateMesh(); go2 = SplitManager.GetObject(); go2.mf.sharedMesh = mesh2; go2.mr.material = testMat; go2.mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.TwoSided; miner.forceDrawChunk = go2; }
// PopulateNoiseMap(), UpdateMesh() public Chunk(World _world, Vector2Int _chunkCoord) { world = _world; chunkCoord = _chunkCoord; verts = new List <Vector3>(); tris = new List <int>(); chunkWidth = GameData.chunkWidth; chunkHeight = GameData.chunkHeight; chunkPosInWorldSpace = new Vector3Int(chunkCoord.x * chunkWidth, 0, chunkCoord.y * chunkWidth); chunkObject = new GameObject(); chunkObject.name = $"Chunk: {chunkCoord.x}, {chunkCoord.y}"; chunkObject.transform.parent = world.transform; chunkObject.transform.position = chunkPosInWorldSpace; player = GameObject.FindGameObjectWithTag("Player").transform; meshFilter = chunkObject.AddComponent <MeshFilter>(); meshRenderer = chunkObject.AddComponent <MeshRenderer>(); meshCollider = chunkObject.AddComponent <MeshCollider>(); chunkObjectScript = chunkObject.AddComponent <ChunkObject>(); PopulateNoiseMap(); CreateMeshData(); CreateMesh(); }
// Use this for initialization void Start() { float voxelSize = 1.0f; int size = 33; Array3 <Voxel> voxels = WorldGenerator.CreateVoxels(size, 0, voxelSize, Vector3.zero); MeshData data = MarchingCubes.CalculateMeshData(voxels, voxelSize); data.CalculateNormals(); Mesh mesh = null; if (data != null) { mesh = data.CreateMesh(); } ChunkObject obj = SplitManager.GetObject(); obj.ov.shouldDraw = true; obj.mr.material = mat; obj.mf.mesh = mesh; Vector3 center = Vector3.one * (size - 1) / 2.0f; Bounds area = new Bounds(center, Vector3.one * voxelSize * (size - 1)); obj.ov.init(0, 0, center, area, null, Color.red); }
void CreateWorldMesh(int x, int y, int z) { ChunkObject chunkObject = Instantiate(_chunkPrefab) as ChunkObject; chunkObject.name = "Chunk[" + x + "," + y + "," + z + "]"; chunkObject.transform.parent = _worldTransform; chunkObject.transform.position = new Vector3(x * Chunk.SizeX, y * Chunk.SizeY, z * Chunk.SizeZ); _world.CreateChunkMesh(x, y, z, chunkObject); }
public Block(ChunkObject parent, string materialName, Vector3Int position) { ControlPoint = new Vector3(.5f, .5f, .5f); Parent = parent; Position = position; SearchMarker = 0; IsControlPointLocked = false; _materialName = materialName; }
/// <summary> /// Adds a feature to the feature dictionary; /// </summary> /// <param name="go">GameObject to treat as a feature to add</param> public void AddFeature(GameObject go) { ChunkObject feature = go.AddComponent <ChunkObject>(); feature.myId = objects.Count; feature.chunk = this; objects.Add(latestId, feature); latestId++; }
//// Update is called once per frame //void Update() { // int newTasks = 0; // while (splitList.Count > 0 // while there are things to split // && newTasks < taskLaunchesPerFrame // and havent launched too many tasks this frame // && taskList.Count < maxConcurrentTasks) { // and there are less tasks going than max // // find lowest depth of trees on list // int count = splitList.Count; // int minDepth = Octree.MAX_DEPTH; // for (int i = 0; i < count; ++i) { // minDepth = Mathf.Min(minDepth, splitList[i].depth); // } // int closest = 0; // float closestDist = float.MaxValue; // for (int i = 0; i < count; ++i) { // if (splitList[i].depth > minDepth) { // continue; // } // float dist = splitList[i].GetSqrDistToCamFromCenter(); // if (dist < closestDist) { // closest = i; // closestDist = dist; // } // } // Octree toSplit = splitList[closest]; // if (count > 1) { // remove from list fast // splitList[closest] = splitList[count - 1]; // splitList.RemoveAt(count - 1); // } else { // splitList.Clear(); // } // // one last check before queueing up task // if (toSplit.ShouldSplit()) { // taskList.Add(toSplit.SplitAsync()); // newTasks++; // } else { // otherwise just remove from list // toSplit.SetSplitting(false); // } // } // // check and resolve tasks that are complete // int resolutionsPerFrame = 1; // for (int i = 0; i < taskList.Count;) { // if (taskList[i].IsCompleted) { // //Debug.Log("resolved: " + ++totalResolved); // SplitData sd = taskList[i].Result; // sd.tree.SplitResolve(sd.data); // taskList.RemoveAt(i); // if (--resolutionsPerFrame <= 0) { // break; // } // } else { // ++i; // } // } // //splitCountText.text = "splits: " + splitList.Count; // //if(splitList.Count == 0) { // // Debug.Log(Time.time); // //} //} //public static void AddToSplitList(Octree node) { // splitList.Add(node); //} //// todo reimplement these to generate closest first //public int NearestToFarthest(Octree o1, Octree o2) { // return o1.GetSqrDistToCamFromCenter().CompareTo(o2.GetSqrDistToCamFromCenter()); //} //public int FurthestToNearest(Octree o1, Octree o2) { // return o2.GetSqrDistToCamFromCenter().CompareTo(o1.GetSqrDistToCamFromCenter()); //} // returns a gameobject with proper components public static ChunkObject GetObject() { if (freeObjects.Count > 0) { ChunkObject free = freeObjects.Pop(); free.go.SetActive(true); return(free); } return(new ChunkObject()); }
private static RenderMesh InitRenderMesh(ChunkObject chunkObject) { var meshRenderer = chunkObject.GetComponent <MeshRenderer>(); return(new RenderMesh { material = meshRenderer.sharedMaterial, castShadows = meshRenderer.shadowCastingMode, receiveShadows = meshRenderer.receiveShadows, subMesh = 0 }); }
/* Initialize 3D grid of chunks */ private void InitChunks() { for (int y = 0; y < numChunks; y++) { for (int x = 0; x < numChunks; x++) { for (int z = 0; z < numChunks; z++) { chunks[x, y, z] = new ChunkObject(new Vector3Int(x * chunkSize, y * chunkSize, z * chunkSize), chunkPrefab); } } } }
public void InitializeChunk(int x, int z) { float xPos = x * (HexChunk.xOffset * HexChunk.size); float zPos = z * (HexChunk.zOffset * HexChunk.size); goChunk = new GameObject("Chunk " + x + "_" + z); goChunk.transform.position = new Vector3(xPos, 0, zPos); goChunk.transform.rotation = Quaternion.identity; goChunk.transform.SetParent(GridManager.I.transform); goChunk.tag = "Chunk"; chunkObject = goChunk.AddComponent <ChunkObject>(); chunkObject.InitializeChunkObject(new Chunk(x, z, xPos, zPos)); }
public VoxelWorld(string name, int maxLights) : base(name, maxLights) { Initializer = () => { var green = new Vector3(0x7e, 0xc8, 0x50) / 255.0f; ChunkStreamer chunkStreamer = new ChunkStreamer(1 << 16, this.Renderer); var mat_id = chunkStreamer.MaterialMap.Register(green, green * 0.25f, 0.9f, 0.0f); ChunkObject obj = new ChunkObject(chunkStreamer); //Engine.CurrentPlayer.Position += Vector3.UnitY * 110; Random rng = new Random(0); ulong cnt = 0; Perlin p = new Perlin(); for (int x = ChunkConstants.Side * -10; x < ChunkConstants.Side * 10; x++) { //for (int y = ChunkConstants.Side * -1; y < ChunkConstants.Side * 1; y++) for (int z = ChunkConstants.Side * -10; z < ChunkConstants.Side * 10; z++) { //if (x * x + y * y + z * z <= 200 * 200) //if(y > -32 && y < 32) { int y = (x == -300) ? 400 : (int)((p.GetValue(x * 0.005f, z * 0.005f, 0) * 0.5f + 0.5f) * 128); if (y >= 0) { for (int y0 = y; y0 >= 0; y0--) { obj.Set(x, y0, z, mat_id); } } //else //if (rng.NextDouble() > 0.5f) // obj.Set(x, y, z, mat_id); cnt++; } } } obj.RebuildAll(); Console.WriteLine(cnt); //AddRenderable(new StaticRenderable(Kokoro.Graphics.Prefabs.SphereFactory.Create(grp))); AddRenderable(chunkStreamer); AddRenderable(obj); AddRenderable(chunkStreamer.Ender); //w.AddInterpreter(new Input.DefaultControlInterpreter("/actions/vrworld/in/hand_left", "/actions/vrworld/in/hand_right", grp)); }; }
public void AddFeature(GameObject go, bool buffer = true) { ChunkObject c = go.GetComponent <ChunkObject>(); //to get it to work, assign every ChunkObject prefab the script and add an id. c.myId = objects.Count; c.chunk = this; objects.Add(nid, c); nid++; if (buffer) { ChunkMod result = new ChunkMod(ChunkMod.ChunkModType.Add, go.transform.position, c.myId, c.model); Server.bufferedChunkmods.Add(result); ServerSend.ChunkMod(result); } }
public static ChunkObject Instance(World world, Chunk chunk) { GameObject gameObject = new GameObject("Chunk @ (" + chunk.WorldX + "," + chunk.WorldZ + ")"); gameObject.transform.parent = world.transform; gameObject.transform.position = new Vector3(chunk.WorldX, 0, chunk.WorldZ); gameObject.transform.rotation = Quaternion.identity; gameObject.AddComponent <MeshRenderer> ().sharedMaterials = world.materials; gameObject.renderer.castShadows = true; gameObject.renderer.receiveShadows = true; ChunkObject chunkObject = gameObject.AddComponent <ChunkObject> (); chunkObject.Initialize(world, chunk, gameObject.AddComponent <MeshFilter> (), gameObject.AddComponent <MeshCollider> ()); return(chunkObject); }
public bool TryGetPooledObject(out ChunkObject chunk) { chunk = null; foreach (var obj in pooledObjects) { if (!obj.gameObject.activeInHierarchy) { chunk = obj; return(true); } } return(false); }
void Start() { voxels = WorldGenerator.CreateVoxels(65, 0, 1, Vector3.zero); data = MarchingCubes.CalculateMeshData(voxels, 1); data.CalculateVertexSharing(); data.CalculateNormals(); simp = new Simplification(data.vertices, data.triangles); mesh = data.CreateMesh(); go = SplitManager.GetObject(); go.mr.material = mat; go.mf.sharedMesh = mesh; }
public void SetupChunk() { obj = SplitManager.GetObject(); //obj.go.name = GetTreeName(); obj.go.transform.parent = body.transform; obj.go.transform.localPosition = worldPos; obj.go.transform.localRotation = Quaternion.identity; //obj.go.transform.position = pos; obj.mr.material = body.terrainMat; // incase terrain is edited after //obj.mpb.SetVector(ShaderProps.LocalOffset, worldPos); // not sure what this was for //obj.UpdatePropBlock(); obj.ov.init(depth, branch, worldPos, localArea, body, depth == 0 ? Color.blue : Color.red); }
public InMemoryWorldStream(int worldSeed) { for (var i = 0; i < 100000; i++) { float xLocation = UnityEngine.Random.Range(-25000, 25000); float yLocation = UnityEngine.Random.Range(-25000, 25000); float zLocation = UnityEngine.Random.Range(-25000, 25000); ChunkObject newobject = new ChunkObject(){ Position = new Vector3(xLocation, yLocation, zLocation), Scale = Vector3.one, Rotation = Quaternion.identity, ChunkObjectType = "Asteroid"}; octree.Insert(new Bounds(newobject.Position, newobject.Scale), newobject); } }
public List<ChunkObject> GetObjects(Bounds mapbounds) { int numberOfObjects = UnityEngine.Random.Range(0, 10000); List<ChunkObject> retEnum = new List<ChunkObject>(numberOfObjects); for (int i = 0; i < numberOfObjects; i++) { // Get the position of the new object float xLocation = UnityEngine.Random.Range(mapbounds.min.x, mapbounds.max.x); float yLocation = UnityEngine.Random.Range(mapbounds.min.y, mapbounds.max.y); float zLocation = UnityEngine.Random.Range(mapbounds.min.z, mapbounds.max.z); ChunkObject newobject = new ChunkObject(){ Position = new Vector3(xLocation, yLocation, zLocation), Scale = Vector3.one, Rotation = Quaternion.identity, ChunkObjectType = "Asteroid"}; retEnum.Add(newobject); } return retEnum; }
public BlockGeometry(ChunkObject parent, Vector3Int position, byte blockType) { this.parent = parent; this.position = position; this.blockType = blockType; }
/// <summary> /// Generates block types with hp and hp level. /// Chunks and their objects (if first run = true). /// And calculates faces. /// </summary> public IEnumerator LoadWorld(bool firstRun, Action callback) { ResetProgressBarVariables(); _stopwatch.Restart(); ProgressDescription = "Loading data..."; Status = WorldGeneratorStatus.NotReady; var storage = new PersistentStorage(CHUNK_SIZE); SaveGameData save = storage.LoadGame(); Settings.WorldSizeX = save.WorldSizeX; Settings.WorldSizeZ = save.WorldSizeZ; PlayerLoadedPosition = save.PlayerPosition; PlayerLoadedRotation = save.PlayerRotation; AlreadyGenerated += _progressStep; yield return(null); // give back control ProgressDescription = "Creating game objects..."; if (firstRun) { _worldScene = SceneManager.CreateScene(name); } Blocks = save.Blocks; Status = WorldGeneratorStatus.TerrainReady; AlreadyGenerated += _progressStep; yield return(null); // give back control if (firstRun) { ProgressDescription = "Chunk data initialization..."; // chunkData need to be initialized earlier in order to allow main loop iterate over chunks before their meshes are ready // thanks to this we can display chunk as soon as they become ready Chunks = new ChunkData[Settings.WorldSizeX, WORLD_SIZE_Y, Settings.WorldSizeZ]; for (int x = 0; x < Settings.WorldSizeX; x++) { for (int z = 0; z < Settings.WorldSizeZ; z++) { for (int y = 0; y < WORLD_SIZE_Y; y++) { Chunks[x, y, z] = new ChunkData( new Vector3Int(x, y, z), new Vector3Int(x * CHUNK_SIZE, y * CHUNK_SIZE, z * CHUNK_SIZE)); } } } ChunkObjects = new ChunkObject[Settings.WorldSizeX, WORLD_SIZE_Y, Settings.WorldSizeZ]; AlreadyGenerated += _progressStep; yield return(null); // give back control } ProgressDescription = "Calculating faces..."; _meshGenerator.CalculateFaces(ref Blocks); AlreadyGenerated += _progressStep; yield return(null); // give back control ProgressDescription = "World boundaries check..."; _meshGenerator.WorldBoundariesCheck(ref Blocks); Status = WorldGeneratorStatus.FacesReady; AlreadyGenerated += _progressStep; yield return(null); // give back control ProgressDescription = "Creating chunks..."; // create chunk objects one by one for (int x = 0; x < Settings.WorldSizeX; x++) { for (int z = 0; z < Settings.WorldSizeZ; z++) { for (int y = 0; y < WORLD_SIZE_Y; y++) { ChunkData chunkData = Chunks[x, y, z]; _meshGenerator.CalculateMeshes(ref Blocks, chunkData.Position, out Mesh terrainMesh, out Mesh waterMesh); if (firstRun) { var chunkObject = new ChunkObject(); CreateChunkGameObjects(ref chunkData, ref chunkObject, terrainMesh, waterMesh); SceneManager.MoveGameObjectToScene(chunkObject.Terrain.gameObject, _worldScene); SceneManager.MoveGameObjectToScene(chunkObject.Water.gameObject, _worldScene); ChunkObjects[x, y, z] = chunkObject; } else { SetMeshesAndCollider(ref chunkData, ref ChunkObjects[x, y, z], terrainMesh, waterMesh); } Chunks[x, y, z].Status = ChunkStatus.NeedToBeRedrawn; AlreadyGenerated++; yield return(null); // give back control } } } Status = WorldGeneratorStatus.AllReady; _stopwatch.Stop(); UnityEngine.Debug.Log($"It took {_stopwatch.ElapsedTicks / TimeSpan.TicksPerMillisecond} ms to load all terrain."); AlreadyGenerated = TerrainProgressSteps + MeshProgressSteps; // hardcoded end indicator ProgressDescription = "Game Load Completed"; callback?.Invoke(); }
/// <summary> /// Generates block types with hp and hp level. /// Chunks and their objects (if first run = true). /// And calculates faces. /// </summary> public IEnumerator CreateWorld(bool firstRun, Action callback) { _terrainGenerator.Initialize(Settings); _meshGenerator.Initialize(Settings); _stopwatch.Restart(); ResetProgressBarVariables(); ProgressDescription = "Initialization..."; Status = WorldGeneratorStatus.NotReady; Blocks = new BlockData[Settings.WorldSizeX * CHUNK_SIZE, WORLD_SIZE_Y *CHUNK_SIZE, Settings.WorldSizeZ *CHUNK_SIZE]; AlreadyGenerated += _progressStep; yield return(null); if (Settings.ComputingAcceleration == ComputingAcceleration.UnityJobSystem) { ProgressDescription = "Calculating heights..."; var heights = _terrainGenerator.CalculateHeightsJobSystem(); AlreadyGenerated += _progressStep; yield return(null); ProgressDescription = "Calculating block types..."; var types = _terrainGenerator.CalculateBlockTypes(heights); AlreadyGenerated += _progressStep; yield return(null); ProgressDescription = "Job output deflattenization..."; DeflattenizeOutput(ref types); AlreadyGenerated += _progressStep; yield return(null); } else if (Settings.ComputingAcceleration == ComputingAcceleration.PureCSParallelisation) { ProgressDescription = "Calculating block types..."; _terrainGenerator.CalculateBlockTypesParallel(); AlreadyGenerated += _progressStep * 3; yield return(null); } if (Settings.IsWater) { ProgressDescription = "Generating water..."; _terrainGenerator.AddWater(ref Blocks); } AlreadyGenerated += _progressStep; yield return(null); ProgressDescription = "Generating trees..."; _terrainGenerator.AddTreesParallel(Settings.TreeProbability); AlreadyGenerated += _progressStep; yield return(null); ProgressDescription = "Chunk data initialization..."; if (firstRun) { _worldScene = SceneManager.CreateScene(name); } // chunkData need to be initialized earlier in order to allow main loop iterate over chunks before their meshes are ready // thanks to this we can display chunk as soon as they become ready Chunks = new ChunkData[Settings.WorldSizeX, WORLD_SIZE_Y, Settings.WorldSizeZ]; for (int x = 0; x < Settings.WorldSizeX; x++) { for (int z = 0; z < Settings.WorldSizeZ; z++) { for (int y = 0; y < WORLD_SIZE_Y; y++) { Chunks[x, y, z] = new ChunkData(new Vector3Int(x, y, z), new Vector3Int(x * CHUNK_SIZE, y * CHUNK_SIZE, z * CHUNK_SIZE)); } } } ChunkObjects = new ChunkObject[Settings.WorldSizeX, WORLD_SIZE_Y, Settings.WorldSizeZ]; yield return(null); ProgressDescription = "Calculating faces..."; _meshGenerator.CalculateFaces(ref Blocks); AlreadyGenerated += _progressStep; yield return(null); ProgressDescription = "World boundaries check..."; _meshGenerator.WorldBoundariesCheck(ref Blocks); AlreadyGenerated += _progressStep; yield return(null); ProgressDescription = "Creating chunks..."; // create chunk objects one by one for (int x = 0; x < Settings.WorldSizeX; x++) { for (int z = 0; z < Settings.WorldSizeZ; z++) { for (int y = 0; y < WORLD_SIZE_Y; y++) { ChunkData chunkData = Chunks[x, y, z]; _meshGenerator.CalculateMeshes(ref Blocks, chunkData.Position, out Mesh terrainMesh, out Mesh waterMesh); if (firstRun) { var chunkObject = new ChunkObject(); CreateChunkGameObjects(ref chunkData, ref chunkObject, terrainMesh, waterMesh); SceneManager.MoveGameObjectToScene(chunkObject.Terrain.gameObject, _worldScene); SceneManager.MoveGameObjectToScene(chunkObject.Water.gameObject, _worldScene); ChunkObjects[x, y, z] = chunkObject; } else { SetMeshesAndCollider(ref chunkData, ref ChunkObjects[x, y, z], terrainMesh, waterMesh); } Chunks[x, y, z].Status = ChunkStatus.NeedToBeRedrawn; AlreadyGenerated++; yield return(null); // give back control } } } Status = WorldGeneratorStatus.AllReady; AlreadyGenerated += _progressStep; _stopwatch.Stop(); UnityEngine.Debug.Log($"It took {_stopwatch.ElapsedTicks / TimeSpan.TicksPerMillisecond} ms to generate the world."); ProgressDescription = "Generation Completed"; callback?.Invoke(); }
// Create a chunk public void CreateChunkMesh(int x, int y, int z, ChunkObject chunkObject) { chunkObject.ChunkMesh.mesh = ChunkRenderer.Render(_chunks[x,y,z]); chunkObject.ChunkCollider.sharedMesh = chunkObject.ChunkMesh.mesh; _chunks[x,y,z].ChunkObject = chunkObject; }
static void Postfix(TerrainGeneration __instance, ref ChunkObject chunk) { chunk.MeshRenderer.sharedMaterial.SetVector("_WorldOrigin", WorldManager.OriginPositionLoading + new Vector3(0, 150, 0)); }
// Create a chunk public void CreateChunkMesh(int x, int y, int z, ChunkObject chunkObject) { chunkObject.ChunkMesh.mesh = ChunkRenderer.Render(_chunks[x, y, z]); chunkObject.ChunkCollider.sharedMesh = chunkObject.ChunkMesh.mesh; _chunks[x, y, z].ChunkObject = chunkObject; }
private void OnChunkBuilt(ChunkObject chunk) { _loadCount++; WatchdogTimer.Reset(); WatchdogTimer.Start(); }
/// <summary> /// Generates block types with hp and hp level. /// Chunks and their objects (if first run = true). /// And calculates faces. /// </summary> public IEnumerator CreateWorld(bool firstRun, Action callback) { MainController.InitializeOnWorldSizeChange(); _stopwatch.Restart(); ResetProgressBarVariables(); ProgressDescription = "Initialization..."; Status = WorldGeneratorStatus.NotReady; GlobalVariables.Blocks = new BlockData[ GlobalVariables.Settings.WorldSizeX * Constants.CHUNK_SIZE, Constants.WORLD_SIZE_Y *Constants.CHUNK_SIZE, GlobalVariables.Settings.WorldSizeZ *Constants.CHUNK_SIZE]; AlreadyGenerated += _progressStep; yield return(null); // return control ProgressDescription = "Calculating block types..."; TerrainGenerationAbstractionLayer.CalculateBlockTypes(); AlreadyGenerated += _progressStep; yield return(null); // return control to update the UI if (GlobalVariables.Settings.IsWater) { ProgressDescription = "Generating water..."; TerrainGenerationAbstractionLayer.AddWater(); } AlreadyGenerated += _progressStep; yield return(null); // return control ProgressDescription = "Generating trees..."; TerrainGenerationAbstractionLayer.AddTrees(); AlreadyGenerated += _progressStep; yield return(null); // return control ProgressDescription = "Chunk data initialization..."; if (firstRun) { _worldScene = SceneManager.CreateScene(name); } // chunkData need to be initialized earlier in order to allow main loop iterate over chunks before their meshes are ready // thanks to this we can display chunk as soon as they become ready GlobalVariables.Chunks = new ChunkData[GlobalVariables.Settings.WorldSizeX, Constants.WORLD_SIZE_Y, GlobalVariables.Settings.WorldSizeZ]; for (int x = 0; x < GlobalVariables.Settings.WorldSizeX; x++) { for (int z = 0; z < GlobalVariables.Settings.WorldSizeZ; z++) { for (int y = 0; y < Constants.WORLD_SIZE_Y; y++) { GlobalVariables.Chunks[x, y, z] = new ChunkData( coord: new ReadonlyVector3Int(x, y, z), position: new ReadonlyVector3Int(x * Constants.CHUNK_SIZE, y * Constants.CHUNK_SIZE, z * Constants.CHUNK_SIZE)); } } } ChunkObjects = new ChunkObject[GlobalVariables.Settings.WorldSizeX, Constants.WORLD_SIZE_Y, GlobalVariables.Settings.WorldSizeZ]; yield return(null); // return control ProgressDescription = "Calculating faces..."; MeshGenerationAbstractionLayer.CalculateFaces(); AlreadyGenerated += _progressStep; yield return(null); // return control ProgressDescription = "World boundaries check..."; MeshGenerationAbstractionLayer.WorldBoundariesCheck(); AlreadyGenerated += _progressStep; yield return(null); // return control ProgressDescription = "Creating chunks..."; // create chunk objects one by one for (int x = 0; x < GlobalVariables.Settings.WorldSizeX; x++) { for (int z = 0; z < GlobalVariables.Settings.WorldSizeZ; z++) { for (int y = 0; y < Constants.WORLD_SIZE_Y; y++) { ChunkData chunkData = GlobalVariables.Chunks[x, y, z]; MeshGenerationAbstractionLayer.CalculateMeshes(in chunkData.Position, out Mesh terrainMesh, out Mesh waterMesh); if (firstRun) { var chunkObject = new ChunkObject(); CreateChunkGameObjects(ref chunkData, ref chunkObject, terrainMesh, waterMesh); SceneManager.MoveGameObjectToScene(chunkObject.Terrain.gameObject, _worldScene); SceneManager.MoveGameObjectToScene(chunkObject.Water.gameObject, _worldScene); ChunkObjects[x, y, z] = chunkObject; } else { SetMeshesAndCollider(ref chunkData, ref ChunkObjects[x, y, z], terrainMesh, waterMesh); } GlobalVariables.Chunks[x, y, z].Status = ChunkStatus.NeedToBeRedrawn; AlreadyGenerated++; yield return(null); // return control } } } Status = WorldGeneratorStatus.AllReady; AlreadyGenerated += _progressStep; _stopwatch.Stop(); UnityEngine.Debug.Log($"It took {_stopwatch.ElapsedTicks / TimeSpan.TicksPerMillisecond} ms to generate the world."); ProgressDescription = $"Generation Completed {_stopwatch.ElapsedTicks / TimeSpan.TicksPerMillisecond} ms"; callback?.Invoke(); }
public static void ReturnObject(ChunkObject obj) { obj.Reset(tform); freeObjects.Push(obj); }