/// <summary> /// Generates the terrain mesh on a separate thread. /// </summary> /// <param name="heightMap">The height map being turned into a mesh.</param> /// <param name="meshSettings">The settings of the mesh being generated.</param> public void RequestMesh(HeightMap heightMap, MeshSettings meshSettings) { // prevents the data being requested again before the thread is done hasRequestedMesh = true; // uses a lambda function to pass a funciton to the thread ThreadedDataRequester.RequestData(() => MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, m_lod), OnMeshDataReceived); }
public void RequestInteractiblesPoints(Vector3[] meshVertices, TerrainInteractibles interactiblesType) { ThreadedDataRequester.RequestData( () => { switch (interactiblesType) { case TerrainInteractibles.Collectibles: return(FixedRandomPointsSpawner.GeneratePoints(meshVertices, _levelSettings.maxCollectibles)); case TerrainInteractibles.Droids: return(FixedRandomPointsSpawner.GeneratePoints(meshVertices, _levelSettings.maxDroids)); default: return(FixedRandomPointsSpawner.GeneratePoints(meshVertices, _levelSettings.maxCollectibles)); } }, points => OnInteractiblesPointsReceived(points, interactiblesType) ); }
public void RequestMesh(HeightMap heightMap, MeshSettings meshSettings) { hasRequestedMesh = true; ThreadedDataRequester.RequestData( () => MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, lod), OnMeshDataReceived); }
public void Load() { ThreadedDataRequester.RequestData( () => HeightMapGenerator.GenerateHeightMap(meshSettings.numberOfVerticesPerLine, meshSettings.numberOfVerticesPerLine, heightMapSettings, sampleCenter), OnHeightMapReceived ); }
public void Load(Erosion erosion) { Debug.Log("Height map requested for coord: " + coord.x + ", " + coord.y); ThreadedDataRequester.RequestData( () => HeightMapGenerator.GenerateHeightMap(meshSettings.numberOfVerticesPerLine, heightMapSettings, erosion, sampleCenter), OnHeightMapReceived ); }
public void Load() { if (heightMapRequested == false) { heightMapRequested = true; ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap(meshSettings.numVerticesPerLine, meshSettings.numVerticesPerLine, heightMapSettings, sampleCenter), OnHeightMapReceived); } }
public void Load() { ThreadedDataRequester.RequestData(() => (isWithinMapBounds()) ? HeightMapGenerator.GenerateHeightMap(meshSettings.numberVerticesPerLine, meshSettings.numberVerticesPerLine, heightMapSettings, mapRulesSettings, sampleCenter, GetChunkBorderInfo()) : HeightMapGenerator.GenerateOcean(meshSettings.numberVerticesPerLine, meshSettings.numberVerticesPerLine), OnHeightMapReceived ); }
public void RequestTreePoints(Vector3[] meshVertices, int chunkSizeIndex) { hasRequestedTreePoints = true; ThreadedDataRequester.RequestData( () => TreePointsGenerator.SelectTreePoints(meshVertices, chunkSizeIndex, _meshCenter, _treeSettings, _clearingSettings), OnTreePointsReceived ); }
public void RequestTreePoints(Vector3[] meshVertices, int chunkSizeIndex) { hasRequestedTreePoints = true; ThreadedDataRequester.RequestData( () => TreePointsGenerator.SelectTreePoints(meshVertices, chunkSizeIndex), OnTreePointsReceived ); }
public TerrainChunk(Vector2 coord, HeightMapSettings heightMapSettings, MeshSettings meshSettings, LODInfo[] detailLevels, int lodIndex, Transform viewer, Transform parent = null, Material material = null, System.Action <TerrainChunk, bool> visibiltyCallback = null) { this.coord = coord; this.meshSettings = meshSettings; this.heightMapSettings = heightMapSettings; this.viewer = viewer; this.detailLevels = detailLevels; heightMapReceived = false; heightMapRequested = false; maxViewDistance = detailLevels[detailLevels.Length - 1].visibleDistanceThreshold; sampleCenter = coord * meshSettings.meshWorldSize / meshSettings.meshScale; Vector2 position = coord * meshSettings.meshWorldSize; bounds = new Bounds(position, Vector2.one * meshSettings.meshWorldSize); meshObject = new GameObject("Terrain Chunk"); meshRenderer = meshObject.AddComponent <MeshRenderer>(); meshFilter = meshObject.AddComponent <MeshFilter>(); meshCollider = meshObject.AddComponent <MeshCollider>(); meshObject.transform.position = new Vector3(position.x, 0, position.y); meshObject.transform.parent = parent; if (material != null) { meshRenderer.material = material; } LODColliderIndex = lodIndex; hasSetCollider = false; lodMeshes = new LODMesh[detailLevels.Length]; for (int i = 0; i < detailLevels.Length; i++) { lodMeshes[i] = new LODMesh(detailLevels[i].lod); lodMeshes[i].updateCallback += UpdateChunk; if (i == LODColliderIndex) { lodMeshes[i].updateCallback += UpdateCollisionMesh; } } SetVisible(false); if (visibiltyCallback != null) { OnVisibilityChanged += visibiltyCallback; heightMapRequested = true; ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap(meshSettings.numVerticesPerLine, meshSettings.numVerticesPerLine, heightMapSettings, sampleCenter), OnHeightMapReceived); } }
public void Load() { if (server) { ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMapSettings, sampleCentre), OnHeightMapReceived); } else { OnHeightMapReceived(HeightMapGenerator.GenerateHeightMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMapSettings, sampleCentre)); } }
public void RequestMesh(HeightMap heightMap, MeshSettings meshSettings, bool server) { hasRequestedMesh = true; if (server) { ThreadedDataRequester.RequestData(() => MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, lod), OnMeshDataReceived); } else { OnMeshDataReceived(MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, lod)); } }
public void Load() { ThreadedDataRequester.RequestData( () => HeightMapGenerator.GenerateHeightMap( m_meshSettings.numVertsPerLine, m_meshSettings.numVertsPerLine, m_heightMapSettings, m_sampleCentre ), OnHeightMapReceived ); }
public override void UpdateChunk(Vector3 viewerPosition) { base.UpdateChunk(viewerPosition); // If the chunk is visible if (IsVisible()) { // If the chunk hasn't generated a height map yet, request it if (!requestedHeightMap) { ThreadedDataRequester.RequestData(() => GenerateHeightMap(), OnHeightMapReceived); requestedHeightMap = true; } // If it has a height map... else if (hasHeightMap) { // Check if the current lod does not have a mesh requested, and request it if (!lodMeshes[lodIndex].requestedMesh) { RequestLodMeshData(lodMeshes[lodIndex], lodInfos[lodIndex]); } // If it has a mesh... else if (lodMeshes[lodIndex].hasMesh) { meshFilter.mesh = lodMeshes[lodIndex].mesh; } // Check if we need to create a collider if (meshCollider != null && colliderIndex != -1) { // If the the distance is near the threshold... if (distanceFromViewerLastUpdate < World.GetInstance().colliderDistanceThreshold * 1.5f) { // Request the collider mesh if it doesn't exist if (!lodMeshes[colliderIndex].requestedMesh) { RequestLodMeshData(lodMeshes[colliderIndex], lodInfos[colliderIndex]); } // If the player reached the collider distance threshold, set the mesh if (distanceFromViewerLastUpdate < World.GetInstance().colliderDistanceThreshold) { if (lodMeshes[colliderIndex].hasMesh) { meshCollider.sharedMesh = lodMeshes[colliderIndex].mesh; } } } } } } }
public void Load() { _heightMapRequested = true; ThreadedDataRequester.RequestData( () => HeightMapGenerator.GenerateHeightMap( _meshSettings.numVerticesPerLine, _meshSettings.numVerticesPerLine, _heightMapSettings, _sampleCenter ), OnHeightMapReceived ); }
public void RecalculateChunk() { int index = 0; int columnCount = (int)Math.Round(Math.Sqrt(_previewSize)); int offset = columnCount / 2; for (int y = -offset; y < columnCount - offset; y++) { for (int x = -offset; x < columnCount - offset; x++) { Vector2 sampleCentre = new Vector2(x * 48, y * 48); ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap( _meshSettings.numVertsPerLine, _meshSettings.numVertsPerLine, MapSettings, sampleCentre), _mapChunk2Ds[index].OnHeightMapReceive); index++; } } }
public void Load(Erosion erosion, WorldSettings worldSettings) { // Debug.Log("Height map requested for coord: " + coord.x + ", " + coord.y); ThreadedDataRequester.RequestData(() => { var realHeightMap = new float[meshSettings.numberOfVerticesPerLine, meshSettings.numberOfVerticesPerLine]; var heightMap = HeightMapGenerator.GenerateHeightMap(meshSettings.numberOfVerticesPerLine, heightMapSettings, erosion, sampleCenter); var worldLocalHeightMap = HeightMapGenerator.GenerateWorldLocalHeightMap(meshSettings.numberOfVerticesPerLine, worldSettings, erosion, sampleCenter); for (var y = 0; y < meshSettings.numberOfVerticesPerLine; y++) { for (var x = 0; x < meshSettings.numberOfVerticesPerLine; x++) { realHeightMap[x, y] = heightMap.values[x, y] * (worldLocalHeightMap.values[x, y] / worldSettings.heightScale) * 1 + worldLocalHeightMap.values[x, y]; } } return(new HeightMap(realHeightMap, Single.MinValue, Single.MaxValue)); }, OnHeightMapReceived); }
void GenerateResourceNodes() { if (hasResources) { return; } Vector3[] vertices = meshFilter.mesh.vertices; Vector3 gameObjectPosition = meshObject.transform.position; ThreadedDataRequester.RequestData(() => ResourceGeneration.GenerateResourcePoints(20f, vertices, meshObject, gameObjectPosition, heightMapSettings), PlaceTrees); hasResources = true; /*for (int i = 0; i < chunkSize; i++) * { * for (int j = 0; j < chunkSize; j++) * { * int index = i * chunkSize + j; * // Debug.Log("Index (" + index + ") = " + vertices[index]); // TODO Figure out what to do with these vertex cords... they are in world space... grab a distance around them and see if slope (in all 8 directions) is crazy? probably. * } * } */ }
public void Load() { ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap(meshSettings, heightMapSettings, sampleCentre), OnHeightMapReceived); }
public void Load() { ThreadedDataRequester.RequestData(GenerateHeightMap, OnHeightMapReceived); }
public void Load() { // RequestData needs a function that returns an object and has no parameters, so we use a lambda expression to get around that ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap(meshSettings.NumVertsPerLine, meshSettings.NumVertsPerLine, heightMapSettings, sampleCenter), OnHeightMapReceived); }
public void RequestMesh(HeightMap data, MeshSettings settings) { hasRequestedMesh = true; ThreadedDataRequester.RequestData(() => MeshGenerator.GenerateTerrainMesh(data.Values, settings, lod), OnMeshDataReceived); }
public void RequestMesh(float[,] values, MeshSettings meshSettings) { hasRequestedMesh = true; ThreadedDataRequester.RequestData(() => MeshGenerator.GenerateTerrainMesh(values, meshSettings, lod), OnMeshDataReceived); }
public void Load() { ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap(meshSettings.verticesPerLineCount, meshSettings.verticesPerLineCount, heightMapSettings, sampleCentre), OnHeightMapGenerated); }
/// <summary> /// Generates a height map on a separate thread. /// </summary> public void Load() { // passes the function into the thread using the lambda method ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap(m_meshSettings.NumVertsPerLine, m_meshSettings.NumVertsPerLine, m_heightMapSettings, m_sampleCenter), OnHeightMapReceived); }
public void Load() { // () creates a new lambda with no parameters that returns what is on the right of the => ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMapSettings, meshSettings, sampleCenter), OnHeightMapReceived); }
public void RequestMesh(HeightMap heightMap, MeshSettings meshSettings) { hasRequestedMesh = true; //mapGenerator.RequestMeshData(mapData, levelOfDetail, OnMeshDataReceived); ThreadedDataRequester.RequestData(() => MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, levelOfDetail), OnMeshDataReceived); }
protected override void OnHeightMapReceived(object heightMapObject) { heightMapData = (float[, ])heightMapObject; ThreadedDataRequester.RequestData(() => CreateHeightLevelMap(heightMapData), OnHeightLevelMapDataReceived); }
public static void AddChunkToMap(Vector2 chunkCoord) { Vector2 sampleCenter = chunkCoord * _singleton._meshSettings.MeshWorldSize / _singleton._meshSettings.MeshScale; ThreadedDataRequester.RequestData(() => RequestTextureChunkData(chunkCoord, sampleCenter), ReceivedTextureChunkData); }
//we only want this to happen after the OnTerrainChunkVisibilityChanged method has been subscribed to the onVisibilityChanged event in order to keep the terrain chunk from changing visibility without being added/removed from the terrainchunksvisible list public void Load() { //gets the mapData ThreadedDataRequester.RequestData(() => HeightMapGenerator.GenerateHeightMap(meshSettings.numVertsPerLine, meshSettings.numVertsPerLine, heightMapSettings, sampleCenter), OnHeightMapRecieved); }