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