/// <summary> /// Writes a boolean array of which points are active /// </summary> /// <param name="size">Vector3 of the Chunk size to be generated</param> void VertexWrite(Vector3 size) { for (int i = 0; i < size.x; i++) { for (int j = 0; j < size.y; j++) { for (int k = 0; k < size.z; k++) { HexCell center = new HexCell(i, j, k); HexWorldCoord shiftedCenter = HexToWorldHex(center.ToHexCoord()); if (world.GradientCheck(shiftedCenter)) { vertexes[i, j, k] = true; if (world.pointMode == PointMode.Gradient) { CreatePoint(center.ToHexCoord()); } } if (world.pointMode == PointMode.All) { CreatePoint(center.ToHexCoord()); } } } } }
/// <summary> /// Send mesh data to the mesh and apply after affects /// </summary> void MeshProcedure() { List <Vector3> posVerts = new List <Vector3>(); foreach (HexCell hexCell in verts) { HexCoord hex = hexCell.ToHexCoord(); HexWorldCoord point = HexToWorldHex(hex); normals.Add(GetNormal(hex)); Vector3 offset = new Vector3(); Vector3 smooth = new Vector3(); if (world.smoothLand) { Vector3 norm = GetNormal(hex); norm = norm.normalized * sqrt3 / 2; float A = GetNoise(PosToHex(World.HexToPos(point) + norm)); float B = GetNoise(PosToHex(World.HexToPos(point) - norm)); float T = 0; smooth = norm.normalized * ((A + B) / 2 - T) / ((A - B) / 2) * -sqrt3 / 2; } if (world.offsetLand) { offset = .4f * World.GetNormalNonTerrain((HexToPos(hexCell) + smooth) * 27); } posVerts.Add(HexToPos(hexCell) + offset + smooth); } mesh.SetVertices(posVerts); mesh.SetTriangles(tris, 0); mesh.SetNormals(normals); }
/// <summary> /// Checks if a point is on the edge of a surface using IVT and gradients /// </summary> /// <param name="point">Hex point to check</param> /// <returns>Boolean</returns> public bool GradientCheck(HexWorldCoord point) { Vector3 pos = HexToPos(point); if (pos.y <= heightBoundary + 1 && pos.y > heightBoundary - 1) { return(BoundaryGradientCheck(point)); } Vector3 gradient = GetNormal(point); gradient = gradient.normalized; if (!Land(point + PosToHex(gradient)) && Land(point - PosToHex(gradient))) { return(true); } //Vector3 gradientHigh = GetNormal(point + PosToHex(gradient * 0.5f)); //Vector3 gradientLow = GetNormal(point - PosToHex(gradient * 0.5f)); //gradientHigh = gradientHigh.normalized * Chunk.sqrt3 * 0.25f; //gradientLow = gradientLow.normalized * Chunk.sqrt3 * 0.25f; //if (!Land(point + PosToHex(gradient * 0.5f) + PosToHex(gradientHigh)) && Land(point - PosToHex(gradient * 0.5f) + PosToHex(gradientLow))) // return true; return(false); }
public HexWorldCoord ToHexWorldCoord() { HexWorldCoord output = new HexWorldCoord(); output.x = x; output.y = y; output.z = z; return(output); }
public static Vector3 HexToPos(HexWorldCoord point) { Vector3 output; output.x = h2P[0].x * point.x + h2P[0].y * point.y + h2P[0].z * point.z; output.y = h2P[1].x * point.x + h2P[1].y * point.y + h2P[1].z * point.z; output.z = h2P[2].x * point.x + h2P[2].y * point.y + h2P[2].z * point.z; return(output); }
public static Vector3 ChunkToPos(ChunkCoord chunkCoord) { HexWorldCoord output; output.x = chunkCoord.x * Chunk.chunkSize; output.y = chunkCoord.y * Chunk.chunkSize; output.z = chunkCoord.z * Chunk.chunkSize; output += new HexWorldCoord(1, 1, 1); return(HexToPos(output)); }
public static ChunkCoord PosToChunk(Vector3 point) { HexWorldCoord hex = PosToHex(point); ChunkCoord output; output.x = Mathf.FloorToInt((hex.x + .5f) / Chunk.chunkSize); output.y = Mathf.FloorToInt((hex.y + .5f) / Chunk.chunkSize); output.z = Mathf.FloorToInt((hex.z + .5f) / Chunk.chunkSize); return(output); }
float GetNoiseAbove(HexWorldCoord hex) { Vector3 pos = HexToPos(hex); float noise = Procedural.Noise.noiseMethods[2][2](hex.ToVector3(), noiseScale, worldName.GetHashCode()).value * 20 + hex.y * thresDropOff; if (island) { noise += 100 * Mathf.Pow(islandDropOff, (Mathf.Pow(pos.x, 2) + Mathf.Pow(pos.z, 2)) - 10386); } return(noise); }
Vector3 GetNormalAbove(HexWorldCoord hex) { Vector3 pos = HexToPos(hex); Vector3 gradient; gradient = Procedural.Noise.noiseMethods[2][2](hex.ToVector3(), noiseScale, worldName.GetHashCode()).derivative * 20 + new Vector3(0, thresDropOff, 0); if (island) { gradient += 100 * new Vector3(pos.x * Mathf.Log(islandDropOff) * Mathf.Pow(islandDropOff, (Mathf.Pow(pos.x, 2) + Mathf.Pow(pos.z, 2)) - 10386), 0, pos.z * Mathf.Log(islandDropOff) * Mathf.Pow(islandDropOff, (Mathf.Pow(pos.x, 2) + Mathf.Pow(pos.z, 2)) - 10386)); } return(gradient); }
public float GetNoise(HexWorldCoord hex) { Vector3 pos = HexToPos(hex); if (pos.y > heightBoundary) { return(GetNoiseAbove(hex)); } else { return(GetNoiseBelow(hex)); } }
bool BoundaryGradientCheck(HexWorldCoord point) { Vector3 pos = HexToPos(point); Vector3 gradientAbove = GetNormalAbove(point).normalized; Vector3 gradientBelow = GetNormalBelow(point).normalized; Vector3 gradientDown = -GetNormal(point); gradientDown = new Vector3(gradientDown.x, 0, gradientDown.z).normalized; if ((!Land(point + PosToHex(gradientAbove)) || !Land(point + PosToHex(gradientBelow))) && Land(point + PosToHex(gradientDown))) { return(true); } return(false); }
public bool Land(HexWorldCoord point, int forcedLocation = 0) { switch (forcedLocation) { case -1: return(GetNoiseBelow(point) < threshold); case 1: return(GetNoiseAbove(point) < threshold); default: return(GetNoise(point) < threshold); } }
float GetNoiseBelow(HexWorldCoord hex) { Vector3 pos = HexToPos(hex); Vector3 basePos = new Vector3(pos.x, heightBoundary, pos.z); HexWorldCoord baseHex = PosToHex(basePos); float noise = Procedural.Noise.noiseMethods[2][2](baseHex.ToVector3(), noiseScale, worldName.GetHashCode()).value * 20 + baseHex.y * thresDropOff; if (island) { noise += 100 * Mathf.Pow(islandDropOff, (Mathf.Pow(basePos.x, 2) + Mathf.Pow(basePos.z, 2)) - 10386); } noise += 5 * (Mathf.Pow(-pos.y + heightBoundary, 0.35f)); return(noise); }
Vector3 GetNormalBelow(HexWorldCoord hex) { Vector3 pos = HexToPos(hex); Vector3 gradient; Vector3 basePos = new Vector3(pos.x, heightBoundary, pos.z); HexWorldCoord baseHex = PosToHex(basePos); gradient = Procedural.Noise.noiseMethods[2][2](baseHex.ToVector3(), noiseScale, worldName.GetHashCode()).derivative * 20 + new Vector3(0, thresDropOff, 0); if (island) { gradient += 100 * new Vector3(basePos.x * Mathf.Log(islandDropOff) * Mathf.Pow(islandDropOff, (Mathf.Pow(basePos.x, 2) + Mathf.Pow(basePos.z, 2)) - 10386), 0, pos.z * Mathf.Log(islandDropOff) * Mathf.Pow(islandDropOff, (Mathf.Pow(basePos.x, 2) + Mathf.Pow(basePos.z, 2)) - 10386)); } gradient = new Vector3(gradient.x, -1.75f * Mathf.Pow(-pos.y + heightBoundary, -0.65f), gradient.z); return(gradient); }
public Vector3 GetNormalInterp(HexCoord pos) { HexWorldCoord low = HexOffset; HexWorldCoord high = HexOffset + new HexCoord(chunkSize, chunkSize, chunkSize); float xD = (pos.x - low.x) / (high.x - low.x); float yD = (pos.y - low.y) / (high.y - low.y); float zD = (pos.z - low.z) / (high.z - low.z); Vector3 c00 = Vector3.Lerp(cornerNormals[0, 0, 0], cornerNormals[1, 0, 0], xD); Vector3 c01 = Vector3.Lerp(cornerNormals[0, 0, 1], cornerNormals[1, 0, 1], xD); Vector3 c10 = Vector3.Lerp(cornerNormals[0, 1, 0], cornerNormals[1, 1, 0], xD); Vector3 c11 = Vector3.Lerp(cornerNormals[0, 1, 1], cornerNormals[1, 1, 1], xD); Vector3 c0 = Vector3.Lerp(c00, c10, yD); Vector3 c1 = Vector3.Lerp(c01, c11, yD); Vector3 c = Vector3.Lerp(c0, c1, zD); return(c); }
public float GetInterp(HexCoord pos) { HexWorldCoord low = HexOffset; HexWorldCoord high = HexOffset + new HexCoord(chunkSize, chunkSize, chunkSize); float xD = (pos.x - low.x) / (high.x - low.x); float yD = (pos.y - low.y) / (high.y - low.y); float zD = (pos.z - low.z) / (high.z - low.z); float c00 = Mathf.Lerp(corners[0, 0, 0], corners[1, 0, 0], xD); float c01 = Mathf.Lerp(corners[0, 0, 1], corners[1, 0, 1], xD); float c10 = Mathf.Lerp(corners[0, 1, 0], corners[1, 1, 0], xD); float c11 = Mathf.Lerp(corners[0, 1, 1], corners[1, 1, 1], xD); float c0 = Mathf.Lerp(c00, c10, yD); float c1 = Mathf.Lerp(c01, c11, yD); float c = Mathf.Lerp(c0, c1, zD); return(c); }
public Vector3 GetNormal(HexWorldCoord hex, int forcedLocation = 0) { switch (forcedLocation) { case -1: return(GetNormalBelow(hex)); case 1: return(GetNormalAbove(hex)); default: Vector3 pos = HexToPos(hex); if (pos.y > heightBoundary) { return(GetNormalAbove(hex)); } else { return(GetNormalBelow(hex)); } } }