static void RenderTriangles(VoxelData voxelData, int size, SKCanvas canvas, MeshSettings settings)
{
var matrix = GetMatrix(voxelData, size);
settings.MeshType = MeshType.Triangles;
var triangles = new MeshBuilder(voxelData, settings);
using (var fill = new SKPaint()) {
var vertices = triangles.Vertices
.Select(v => matrix.MapScalars(v.X, v.Z, -v.Y, 1f))
.Select(v => new SKPoint(v[0], v[1]))
.ToArray();
var colors = triangles.Colors;
var occlusion = triangles.Occlusion;
var indices = triangles.Faces;
// Render triangles in batches since SkiaSharp DrawVertices indices are 16 bit which fails for large files
var batchSize = 3 * 20000; // up to 20000 triangles per batch
for (var i = 0; i < indices.Length; i += batchSize)
{
var batch = Enumerable.Range(i, Math.Min(batchSize, indices.Length - i));
var _vertices = batch.Select(j => vertices[indices[j]]).ToArray();
var _colors = batch.Select(j => AmbientOcclusion.CombineColorOcclusion(colors[indices[j]], occlusion[indices[j]])).Select(ToSKColor).ToArray();
var _indices = batch.Select(j => (ushort)(j - i)).ToArray();
canvas.DrawVertices(SKVertexMode.Triangles, _vertices, null, _colors, _indices, fill);
}
}
}
public static HeightMap GenerateHeightMap(MeshSettings meshSettings, HeightMapSettings settings, Vector2 sampleCentre)
{
int width = meshSettings.numVertsPerLine;
int height = meshSettings.numVertsPerLine;
float[,] values = Noise.GenerateNoiseMap(width, height, settings.noiseSettings, sampleCentre);
AnimationCurve heightCurve_threadsafe = new AnimationCurve(settings.heightCurve.keys);
float minValue = float.MaxValue;
float maxValue = float.MinValue;
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
values[i, j] *= heightCurve_threadsafe.Evaluate(values[i, j]) * settings.heightMultiplier;
if (values[i, j] > maxValue)
{
maxValue = values[i, j];
}
if (values[i, j] < minValue)
{
minValue = values[i, j];
}
}
}
return(new HeightMap(values, minValue, maxValue));
}
public static void SpawnObjects(ObjectsData objectData, Transform parent, MeshSettings meshSettings, int seed)
{
Random.seed = seed;
while (true)
{
if (parent.FindChild("ObjectsWorld"))
{
DestroyImmediate(parent.FindChild("ObjectsWorld").gameObject);
}
else
{
break;
}
}
GameObject objPreParent = new GameObject("ObjectsWorld");
objPreParent.transform.parent = parent;
objPreParent.transform.position = parent.position;
for (int i = 0; i < objectData.objectList.Count; i++)
{
if (objectData.objectList[i].pointsToSpawn.Count > 0 && objectData.objectList[i].isSpawn)
{
GameObject objParent = new GameObject();
if (objectData.objectList[i].objectToSpawn == null)
{
objParent.name = "Default Cube";
}
else
{
objParent.name = objectData.objectList[i].objectToSpawn.name;
}
objParent.transform.parent = objPreParent.transform;
objParent.transform.position = objPreParent.transform.position;
objParent.transform.localPosition = Vector3.zero;
for (int k = 0; k < objectData.objectList[i].pointsToSpawn.Count; k++)
{
Vector3 position = new Vector3(objectData.objectList[i].pointsToSpawn[k].x, objectData.objectList[i].pointsToSpawn[k].y, objectData.objectList[i].pointsToSpawn[k].z);
GameObject objChild;
if (objectData.objectList[i].objectToSpawn == null)
{
objChild = GameObject.CreatePrimitive(PrimitiveType.Cube);
objChild.name = "Default Cube Child " + k;
}
else
{
objChild = Instantiate(objectData.objectList[i].objectToSpawn);
objChild.name = objectData.objectList[i].objectToSpawn.name + " - " + k + 1;
}
objChild.transform.parent = objParent.transform;
objChild.transform.localPosition = position;
objChild.transform.rotation = new Quaternion(objChild.transform.rotation.x, objChild.transform.rotation.y + Random.Range(0, 10), objChild.transform.rotation.z, objChild.transform.rotation.w);
objChild.transform.localScale = new Vector3(objChild.transform.localScale.x + objectData.objectList[i].ScaleOffset + Random.Range(0, 1),
objChild.transform.localScale.y + objectData.objectList[i].ScaleOffset + Random.Range(0, 1),
objChild.transform.localScale.z + objectData.objectList[i].ScaleOffset + Random.Range(0, 1));
}
}
}
}
static void RenderQuads(VoxelData voxelData, int size, SKCanvas canvas, MeshSettings settings)
{
var matrix = GetMatrix(voxelData, size);
settings.MeshType = MeshType.Quads;
var quads = new MeshBuilder(voxelData, settings);
var vertices = quads.Vertices
.Select(v => matrix.MapScalars(v.X, v.Z, -v.Y, 1f))
.Select(v => new SKPoint(v[0], v[1]))
.ToArray();
var indices = quads.Faces;
for (var i = 0; i < indices.Length; i += 4)
{
using (var path = new SKPath()) {
var quad = Enumerable.Range(0, 4)
.Select(n => vertices[indices[i + n]])
.ToArray();
path.AddPoly(quad, close: true);
var color = quads.Colors[quads.Faces[i]]; // Take 1st vertex color for face
using (var fill = new SKPaint()
{
Color = ToSKColor(color)
}) {
canvas.DrawPath(path, fill);
}
}
}
}
public TerrainChunk(Vector2 coordinate, float[,] heightMap, MeshSettings meshSettings, Transform parent, Material material)
{
this.coordinate = coordinate;
this.heightMap = heightMap;
this.meshSettings = meshSettings;
offset = new Vector2((meshSettings.meshWorldSize * (meshSettings.worldChunkWidth - 1)) / 2, (meshSettings.meshWorldSize * (meshSettings.worldChunkWidth - 1)) / 2);
Vector2 position = coordinate * meshSettings.meshWorldSize - offset;
meshObject = new GameObject("Terrain Chunck: " + coordinate);
meshObject.layer = LayerMask.NameToLayer("Terrain");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
meshRenderer.material = material;
meshObject.transform.position = new Vector3(position.x, 0, position.y);
meshObject.transform.parent = parent;
meshData = MeshGenerator.TestMeshData(heightMap, meshSettings);
meshFilter.sharedMesh = meshData.CreateMesh();
meshCollider.sharedMesh = meshFilter.sharedMesh;
}
/// <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 static MeshData GenerateTerrainMeshData(float[,] heightMap, MeshSettings meshSettings)
{
int width = heightMap.GetLength(0);
int height = heightMap.GetLength(1);
float topLeftX = (width - 1) / -2f;
float topLeftZ = (height - 1) / 2f;
int verticesPerLine = meshSettings.numVertsPerLine;
MeshData meshData = new MeshData(verticesPerLine);
int vertexIndex = 0;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
meshData.vertices[vertexIndex] = new Vector3((topLeftX + x) * meshSettings.unitsPerVertex, heightMap[x, y], (topLeftZ - y) * meshSettings.unitsPerVertex);
meshData.uvs[vertexIndex] = new Vector2(x / (float)width, y / (float)height);
if (x < width - 1 && y < height - 1)
{
meshData.AddTriangle(vertexIndex, vertexIndex + verticesPerLine + 1, vertexIndex + verticesPerLine);
meshData.AddTriangle(vertexIndex + verticesPerLine + 1, vertexIndex, vertexIndex + 1);
}
vertexIndex++;
}
}
return(meshData);
}
public void DrawTrees(float[,] heightMap, MeshSettings meshSettings, float[,] treeMap)
{
Object tree = Resources.Load("Trees/Olive_Tree/Olive_Prefab/Olive_Tree_Prefab");
int numVertsPerLine = meshSettings.numVertsPerLine;
Vector2 topLeft = new Vector2(-1, 1) * meshSettings.meshWorldSize / 2f;
System.Random rng = new System.Random();
for (int y = 0; y < numVertsPerLine; y++)
{
for (int x = 0; x < numVertsPerLine; x++)
{
Vector2 percent = new Vector2(x - 1, y - 1) / (numVertsPerLine - 3);
Vector2 vertexPosition2D = topLeft + new Vector2(percent.x, -percent.y) * meshSettings.meshWorldSize;
float height = heightMap[numVertsPerLine - 1 - x, y];
// float p = treeMap[x,y]*0.1f;
float rotation = (float)rng.NextDouble() * 180;
// Debug.Log (rotation);
if (treeMap[x, y] > 0)
{
GameObject treeObject = (GameObject)Instantiate(tree,
new Vector3(-vertexPosition2D.x, height, vertexPosition2D.y), //position
Quaternion.Euler(new Vector3(-90, rotation, 0))); //rotation
treeObject.transform.localScale *= treeMap[x, y] * 2;
}
}
}
}
public void FillNodeMapWithWorldCoordinates(NodeGrid nodeGrid, MeshSettings meshSettings)
{
Vector2 bottomLeft;
if (meshSettings.isCentered)
{
bottomLeft = new Vector2(-nodeGrid.width, -nodeGrid.height) * meshSettings.cellScale * 0.5f + new Vector2(meshSettings.mapOffsetX, -meshSettings.mapOffsetZ);
}
else
{
bottomLeft = new Vector2(meshSettings.mapOffsetX, -meshSettings.mapOffsetZ);
}
float vertexOffset = meshSettings.cellScale;
Vector3 halfCell = new Vector3(vertexOffset, 0.0f, vertexOffset) * 0.5f;
for (int y = 0; y < nodeGrid.height; y++)
{
for (int x = 0; x < nodeGrid.width; x++)
{
Vector3 cellOffset = new Vector3(x * meshSettings.cellScale, 0.0f, y * meshSettings.cellScale) + new Vector3(bottomLeft.x, 0.0f, bottomLeft.y);
//! Cell center
nodeGrid.values[x, y].pos = halfCell + cellOffset;
}
}
}
/* Constructors */
public TerrainChunk(Vector2 coord, HeightMapSettings heightMapSettings, MeshSettings meshSettings,
Transform parent, Transform viewerTransform, Material material)
{
this.coord = coord;
this.heightMapSettings = heightMapSettings;
this.meshSettings = meshSettings;
viewer = viewerTransform;
sampleCentre = coord * meshSettings.meshWorldSize / meshSettings.meshScale;
Vector2 position = coord * meshSettings.meshWorldSize; // Calculate the position of this TerrainChunk
bounds = new Bounds(position, Vector2.one * meshSettings.meshWorldSize);
// Instantiate the new object
meshObject = new GameObject("Terrain Chunk: " + coord.ToString());
meshObject.SetActive(false);
GameObject.Instantiate(Resources.Load <GameObject>(Util.PathTo("Lake")), meshObject.transform);
meshObject.layer = LayerMask.NameToLayer("Terrain");
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
BoxCollider boxCollider = meshObject.AddComponent <BoxCollider>();
boxCollider.size = new Vector3(46f, 0.1f, 46f);
meshRenderer.material = material;
meshObject.isStatic = true;
// Set the GameObjects position and parent
meshObject.transform.position = new Vector3(position.x, 0, position.y);
meshObject.transform.parent = parent;
}
public void RequestMesh(HeightMap heightMap, MeshSettings meshSettings)
{
hasRequestedMesh = true;
ThreadedDataRequester.RequestData(
() => MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, lod),
OnMeshDataReceived);
}
/*
* void OnMeshDataReceived(object meshDataObject)
* {
* mesh = ((MeshData)meshDataObject).CreateMesh();
* hasMesh = true;
*
* updateCallback(); // have to manually update the mesh
* }*/
public void RequestMesh(HeightMap heightMap, MeshSettings meshSettings)
{
hasRequestedMesh = true;
//mapGenerator.RequestMeshData(mapData, levelOfDetail, OnMeshDataReceived);
mesh = MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, levelOfDetail).CreateMesh();
hasMesh = true;
}
public static Mesh GenerateGridMesh(MapSettings settings, MeshSettings meshSettings)
{
Mesh mesh = new Mesh();
Vector2 bottomLeft;
if (meshSettings.isCentered)
{
bottomLeft = new Vector2(-settings.width, -settings.height) * meshSettings.cellScale * 0.5f + new Vector2(meshSettings.mapOffsetX, -meshSettings.mapOffsetZ);
}
else
{
bottomLeft = new Vector2(meshSettings.mapOffsetX, -meshSettings.mapOffsetZ);
}
Vector3[] vertices = new Vector3[settings.width * settings.height * 4];
Vector2[] uv = new Vector2[vertices.Length];
int[] triangles = new int[settings.width * settings.height * 6]; //6 = 2 triangles * 3 vertices
Color[] colors = new Color[vertices.Length];
float vertexOffset = meshSettings.cellScale;
int vert = 0;
int tri = 0;
for (int y = 0; y < settings.height; y++)
{
for (int x = 0; x < settings.width; x++)
{
Vector3 cellOffset = new Vector3(x * meshSettings.cellScale, 0.0f, y * meshSettings.cellScale) + new Vector3(bottomLeft.x, 0.0f, bottomLeft.y);
vertices[vert] = cellOffset; //bottom left
vertices[vert + 1] = new Vector3(vertexOffset, 0.0f, 0.0f) + cellOffset; //bottom right
vertices[vert + 2] = new Vector3(0.0f, 0.0f, vertexOffset) + cellOffset; //top left
vertices[vert + 3] = new Vector3(vertexOffset, 0.0f, vertexOffset) + cellOffset; //top right
uv[vert] = new Vector2((float)x / settings.width, (float)y / settings.height);
uv[vert + 1] = new Vector2((float)(x + 1) / settings.width, (float)y / settings.height);
uv[vert + 2] = new Vector2((float)x / settings.width, (float)(y + 1) / settings.height);
uv[vert + 3] = new Vector2((float)(x + 1) / settings.width, (float)(y + 1) / settings.height);
colors[vert] = colors[vert + 1] = colors[vert + 2] = colors[vert + 3] = settings.tilesColors[Random.Range(0, settings.tilesColors.Length)];
triangles[tri + 2] = vert++; //_ _ 1 | _ _ _
triangles[tri + 1] = triangles[tri + 3] = vert++; //_ 2 1 | 2 _ _
triangles[tri] = triangles[tri + 4] = vert++; //3 2 1 | 2 3 _
triangles[tri + 5] = vert++; //3 2 1 | 2 3 4
tri += 6;
}
}
mesh.name = "Discrete Mesh";
mesh.vertices = vertices;
mesh.uv = uv;
mesh.triangles = triangles;
mesh.colors = colors;
mesh.RecalculateNormals();
return(mesh);
}
public static float[] Erode(float[] values, HightMapSettings hightMapSettings, MeshSettings meshSettings, ComputeShader erosionShader, int seed)
{
if (hightMapSettings.erossionSettings.numberOfIterationsMode == ErossionSettings.NumberOfIterationsMode.perSurface)
{
hightMapSettings.erossionSettings.numErosionIterations = Mathf.RoundToInt(hightMapSettings.erossionSettings.numberOfIterations * meshSettings.numberVerticisPerLine * meshSettings.numberVerticisPerLine);
}
else
{
hightMapSettings.erossionSettings.numErosionIterations = Mathf.RoundToInt(hightMapSettings.erossionSettings.numberOfIterations);
}
ErossionSettings.ErosionMode erosionMode = hightMapSettings.erossionSettings.erosionMode;
if (erosionMode == ErossionSettings.ErosionMode.CPU)
{
return(ErodeCPU(values, meshSettings.numberVerticisPerLine, hightMapSettings.erossionSettings, seed));
}
else if (erosionMode == ErossionSettings.ErosionMode.GPU)
{
return(ErodeGPU(values, meshSettings.numberVerticisPerLine, hightMapSettings.erossionSettings, erosionShader));
}
else
{
return(values);
}
}
public TerrainChunk(Vector2 coord, HeightMapSettings heightMapSettings, MeshSettings meshSettings, int colliderLodIndex, Transform parent, Transform viewer, Material material)
{
this.Coord = coord;
this._colliderLodIndex = colliderLodIndex;
this._heightMapSettings = heightMapSettings;
this._meshSettings = meshSettings;
this._viewer = viewer;
this.Biome = BiomeGenerator.GenerateRelativeBiome(_unnormalizedCenter);
_unnormalizedCenter = coord * meshSettings.meshWorldSize / meshSettings.meshScale;
var position = coord * meshSettings.meshWorldSize;
_bounds = new Bounds(position, Vector2.one * meshSettings.meshWorldSize);
_meshObject = new GameObject("Terrain Chunk");
_meshObject.transform.localScale = new Vector3(10.2f, 10.2f, 10.2f);
_meshRenderer = _meshObject.AddComponent <MeshRenderer>();
_meshFilter = _meshObject.AddComponent <MeshFilter>();
_meshCollider = _meshObject.AddComponent <MeshCollider>();
_terrainChunkGameObject = _meshObject.AddComponent <TerrainChunkGameObject>();
SetNeighboringChunks();
_meshRenderer.material = material;
_meshObject.transform.position = new Vector3(position.x, 0, position.y);
_meshObject.transform.parent = parent;
SetVisible(false);
_maxViewDst = 400f;
}
public MeshGenerator(MeshSettings settings)
{
this.settings = settings;
Mesh = new Mesh();
lookup = MeshLookup.GetInstance(settings);
Allocate();
}
public async Task <MeshSettings> CreateAsync(MeshSettings entity)
{
VPLContext.MeshSettings.Add(entity);
await VPLContext.SaveChangesAsync();
return(entity);
}
public TerrainChunk
(
Vector2 coord,
HeightMapSettings heightMapSettings,
MeshSettings meshSettings,
LODInfo[] detailLevels,
int colliderLODIndex,
Transform parent,
Transform viewer,
GameManager gameManager,
Material material,
NoiseSettings oreNoiseSettings, //last 3 are ore related
OreType[] oreTypes,
float oreSpawnThreshold
)
{
this.coord = coord;
this.detailLevels = detailLevels;
this.colliderLODIndex = colliderLODIndex;
this.heightMapSettings = heightMapSettings;
this.meshSettings = meshSettings;
this.viewer = viewer;
chunkOres = new ChunkOres(oreTypes, oreSpawnThreshold);
sampleCentre = coord * meshSettings.meshWorldSize / meshSettings.meshScale;
Vector2 position = coord * meshSettings.meshWorldSize;
bounds = new Bounds(position, Vector2.one * meshSettings.meshWorldSize);
meshObject = new GameObject("Terrain Chunk " + coord);
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
meshObject.layer = 6;
meshRenderer.material = material;
meshObject.transform.position = new Vector3(position.x, 0, position.y);
meshObject.transform.parent = parent;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod);
lodMeshes[i].updateCallback += UpdateTerrainChunk;
if (i == colliderLODIndex)
{
lodMeshes[i].updateCallback += UpdateCollisionMesh;
}
}
maxViewDst = detailLevels [detailLevels.Length - 1].visibleDstThreshold;
chunkOres.GenerateOres(coord, meshSettings.meshWorldSize, meshSettings.meshScale, oreNoiseSettings);
gameManager.RunCoroutine(GenerateOreMeshes());
}
public void GenerateMesh(HeightMap heightMap, MeshSettings meshSettings)
{
if (mRequestingMesh == false || sampleCenter != heightMap.sampleCenter)
{
sampleCenter = heightMap.sampleCenter;
mRequestingMesh = true;
ThreadQueue.RunAsync(() => heightMap.GenerateMeshData(meshSettings, lod), OnMeshDataReceived);
}
}
/// <summary>
/// Starts the Meshing API.
/// </summary>
/// <param name="settings">The settings to start the meshing client with.</param>
/// <returns>
/// MLResult.Result will be <c>MLResult.Code.Ok</c> if successful.
/// MLResult.Result will be <c>MLResult.Code.InvalidParam</c> if an invalid parameter was passed in.
/// MLResult.Result will be<c> MLResult.Code.PrivilegeDenied</c> if there was a lack of privileges.
/// MLResult.Result will be <c>MLResult.Code.UnspecifiedFailure</c> if failed due to internal error.
/// </returns>
public static MLResult Start(MeshSettings?settings = null)
{
if (settings == null)
{
settings = MeshSettings.Create();
}
CreateInstance(settings.Value);
return(MLMeshing.BaseStart(true));
}
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 async Task <IActionResult> PutMeshSettings([FromBody] MeshSettings meshSettings)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await MeshService.UpdateSettingsAsync(meshSettings);
return(NoContent());
}
public TerrainGenerator(MeshSettings meshSettings, HeightMapSettings heightMapSettings, Transform viewer,
Material terrainMaterial, int maxMapSize)
{
_sceneObject = new GameObject("TerrainGenerator");
this.meshSettings = meshSettings;
this.heightMapSettings = heightMapSettings;
this.viewer = viewer;
this.terrainMaterial = terrainMaterial;
this._maxMapSize = maxMapSize;
UpdateVisibleChunks();
}
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 TerrainChunk(Vector2 coord, HeightMapSettings heightMapSettings,
MeshSettings meshSettings, TreeSettings treeSettings,
LevelSettings levelSettings, ClearingSettings clearingSettings, LODInfo[] detailLevels,
int colliderLODIndex, Transform parent, Transform viewer, Material material,
bool createEnemies)
{
this.coord = coord;
_droidsRequested = !createEnemies;
_meshDatSentForTower = !createEnemies;
_detailLevels = detailLevels;
_prevLODIndex = -1;
_colliderLODIndex = colliderLODIndex;
_heightMapSettings = heightMapSettings;
_meshSettings = meshSettings;
_viewer = viewer;
_sampleCenter = coord * meshSettings.meshWorldSize / meshSettings.meshScale;
var position = coord * meshSettings.meshWorldSize;
_bounds = new Bounds(position, Vector2.one * meshSettings.meshWorldSize);
_meshObject = new GameObject("Terrain Chunk");
_meshObject.transform.position = new Vector3(position.x, 0, position.y);
_meshObject.transform.SetParent(parent);
_meshObject.layer = 11;
_meshObject.tag = TagManager.Terrain;
_meshRenderer = _meshObject.AddComponent <MeshRenderer>();
_meshRenderer.material = material;
_meshFilter = _meshObject.AddComponent <MeshFilter>();
_meshCollider = _meshObject.AddComponent <MeshCollider>();
_chunkTrees = new Trees(position, treeSettings, clearingSettings);
_terrainInteractibles = new TerrainInteractiblesCreator(position, _meshObject.transform,
levelSettings, clearingSettings);
SetVisible(false);
_lodMeshes = new LODMesh[detailLevels.Length];
for (var i = 0; i < detailLevels.Length; i++)
{
_lodMeshes[i] = new LODMesh(detailLevels[i].lod);
_lodMeshes[i].UpdateCallback += UpdateTerrainChunk;
if (i == _colliderLODIndex)
{
_lodMeshes[i].UpdateCallback += UpdateCollisionMesh;
}
}
_maxViewDistance = detailLevels[detailLevels.Length - 1].visibleDistanceThreshold;
}
public DiscoverableMeshEthNetwork(
string meshName,
NetworkInterfaceType network = NetworkInterfaceType.Ethernet,
AddressFamily addressFamily = AddressFamily.InterNetwork,
int fromPortRange = 8048, int toPortRange = 12000)
{
_Port = r.Next(fromPortRange, toPortRange);
_Ip = GetFirstIpAddress(network, addressFamily);
_settings = new MeshSettings();
Self = new Peer(_Ip.ToString(), _Port, false);
Log.Info($"I am {Self.IpPort}");
_mesh = new WatsonMesh(_settings, Self)
{
PeerConnected = PeerConnected,
PeerDisconnected = PeerDisconnected,
AsyncMessageReceived = AsyncMessageReceived,
SyncMessageReceived = SyncMessageReceived
};
_mesh.StartServer();
var b = new Beacon(meshName, (ushort)_Port)
{
BeaconData = _Ip.ToString()
};
b.Start();
probe = new Probe(meshName);
probe.BeaconsUpdated += delegate(IEnumerable <BeaconLocation> locations)
{
var connectedPeers = _mesh.GetPeers()
.Select(p => p.IpPort)
.ToList();
var newNodes = locations
.Where(x => !connectedPeers.Contains($"{x.Data}:{x.Address.Port}"))
.ToArray();
foreach (var beacon in newNodes)
{
var peer = new Peer(beacon.Data, beacon.Address.Port, ssl: false);
Console.Write($"Mesh -> Adding peer {peer.Ip}:{peer.Port} to mesh ... ");
_mesh.Add(peer);
Log.Info("Connected.");
}
};
probe.Start();
}
public static MeshGenerator CreateInstance(MeshSettings settings)
{
switch (settings.GeneratorType)
{
case MeshSettings.Generator.Tetrahedron:
return(new MeshGeneratorTetrahedron(settings));
case MeshSettings.Generator.Cube:
default:
return(new MeshGeneratorCube(settings));
}
}
public TerrainChunk(Vector2 coord, HeightMapSettings heightMapSettings, MeshSettings meshSettings, LODInfo[] detailLevels, int colliderLODIndex, Transform parent, Transform viewer, Material material, bool anotherWorld, TerrainType[] arrayOfTerrainTypes)
{
this.isInAnotherWorld = anotherWorld;
this.coord = coord;
this.detailLevels = detailLevels;
this.colliderLODIndex = colliderLODIndex;
this.heightMapSettings = heightMapSettings;
this.meshSettings = meshSettings;
this.viewer = viewer;
this.terrainType = arrayOfTerrainTypes[Random.Range(0, arrayOfTerrainTypes.Length)];
this.chunkType = this.terrainType.chunkType;
int chunRandomizer = Random.Range(0, 50);
sampleCentre = coord * meshSettings.meshWorldSize / meshSettings.meshScale;
Vector2 position = coord * meshSettings.meshWorldSize;
bounds = new Bounds(position, Vector2.one * meshSettings.meshWorldSize);
meshObject = new GameObject("Terrain Chunk");
this.meshObject.transform.tag = "Terrain";
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshFilter = meshObject.AddComponent <MeshFilter>();
meshCollider = meshObject.AddComponent <MeshCollider>();
meshRenderer.material = material;
meshObject.transform.position = new Vector3(position.x, 0, position.y);
meshObject.transform.parent = parent;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod);
lodMeshes[i].updateCallback += UpdateTerrainChunk;
if (i == colliderLODIndex)
{
lodMeshes[i].updateCallback += UpdateCollisionMesh;
lodMeshes[i].updateCallback += UpdateMeshData;
}
}
maxViewDst = detailLevels[detailLevels.Length - 1].visibleDstThreshold;
this.meshObject.isStatic = true;
}
public TerrainChunk(Vector2 coord, HeightMapSettings heightMapSettings, MeshSettings meshSettings, LODInfo[] detailLevels, int colliderLODIndex, Transform parent, Transform viewer, Material material, bool server)
{
this.coord = coord;
this.detailLevels = detailLevels;
this.colliderLODIndex = colliderLODIndex;
this.heightMapSettings = heightMapSettings;
this.meshSettings = meshSettings;
this.viewer = viewer;
this.server = server;
this.regionSize = new Vector2(meshSettings.meshWorldSize, meshSettings.meshWorldSize);
this.meshArrayDimension = (int)meshSettings.meshWorldSize + 1;
this.meshDimension = (int)meshSettings.meshWorldSize;
sampleCentre = coord * meshSettings.meshWorldSize / meshSettings.meshScale;
Vector2 position = coord * meshSettings.meshWorldSize;
bounds = new Bounds(position, Vector2.one * meshSettings.meshWorldSize);
meshObject = new GameObject("Terrain Chunk");
meshCollider = meshObject.AddComponent <MeshCollider>();
meshObject.transform.position = new Vector3(position.x, 0, position.y);
meshObject.transform.parent = parent;
if (!server)
{
meshFilter = meshObject.AddComponent <MeshFilter>();
meshRenderer = meshObject.AddComponent <MeshRenderer>();
meshRenderer.material = material;
SetVisible(false);
lodMeshes = new LODMesh[detailLevels.Length];
for (int i = 0; i < detailLevels.Length; i++)
{
lodMeshes[i] = new LODMesh(detailLevels[i].lod);
lodMeshes[i].updateCallback += UpdateTerrainChunk;
if (i == colliderLODIndex)
{
lodMeshes[i].updateCallback += UpdateCollisionMesh;
}
}
maxViewDst = detailLevels[detailLevels.Length - 1].visibleDstThreshold;
}
else
{
lodMeshes = new LODMesh[1];
lodMeshes[0] = new LODMesh(detailLevels[0].lod);
lodMeshes[0].updateCallback += ServerUpdateCallback;
}
}
public static HightMap GenHightMap(MeshSettings meshSettings, HightMapSettings settings, Vector2 center)
{
AnimationCurve animationCurve_t = new AnimationCurve(settings.animationCurve.keys);
float minV = float.MaxValue;
float maxV = float.MinValue;
float[,] falloffMap = null;
if (settings.useFalloff)
{
if (falloffMap == null)
{
falloffMap = fallofGenerator.GenerateFalloff(meshSettings.numberVerticisPerLine + 2, settings.FalloffBlur, settings.FalloffSize);
}
}
float[,] valuse = PerlinNoise.GeneratorNoise(meshSettings.numberVerticisPerLine + 2, meshSettings.numberVerticisPerLine + 2, settings.noiseSettings, center);
//Erode
valuse = HightMap.ConwertTabBack(Erosion.Erode(HightMap.ConwertTab(valuse, meshSettings.numberVerticisPerLine + 2), settings, meshSettings, settings.erosionShader, 1), meshSettings.numberVerticisPerLine + 2);
for (int i = 0; i < meshSettings.numberVerticisPerLine + 2; i++)
{
for (int j = 0; j < meshSettings.numberVerticisPerLine + 2; j++)
{
if (settings.useFalloff)
{
valuse[i, j] = Mathf.Clamp(valuse[i, j] - falloffMap[i, j], 0, 1) * animationCurve_t.Evaluate(valuse[i, j]) * settings.heightMultiplayer;
}
else
{
valuse[i, j] *= animationCurve_t.Evaluate(valuse[i, j]) * settings.heightMultiplayer;
}
if (valuse[i, j] > maxV)
{
maxV = valuse[i, j];
}
if (valuse[i, j] < minV)
{
minV = valuse[i, j];
}
}
}
return(new HightMap(valuse, minV, maxV));
}
