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