public bool ShouldPlaceTree(Vector3 point)
{
this.settings.baseRoughness = 3f;
this.settings.numLayers = 2f;
this.settings.strength = 2f;
this.settings.persistance = 1.6f;
return(noise.Evaluate(settings, point) <= 0.03f);
}
public void Init(int index)
{
ResetMesh();
int startColumn = planet.columnsPerChunk * index;
int endColumn = planet.columnsPerChunk * (index + 1);
endColumn = Mathf.Min(endColumn, planet.tileColumns);
for (float i = startColumn; i < endColumn; i++)
{
float angle = (i / planet.tileColumns) * Mathf.PI * 2f;
float noise = NoiseFilter.Evaluate(planet.features.noiseFeatures, new Vector2(Mathf.Cos(angle) * planet.radius, Mathf.Sin(angle) * planet.radius));
int distance = Mathf.RoundToInt(planet.radius + noise);
for (int j = distance; j > planet.radius - planet.features.crustThickness; j--)
{
Vector2 position = new Vector2(Mathf.Cos(angle) * j, Mathf.Sin(angle) * j);
Color color = planet.features.GetTileColorForHeight(j, distance);
AddQuadToMesh(position, angle, color);
}
}
UpdateMesh();
}
/// <summary>
/// Generates the densities of equidistant points in the cell using a noise function.
/// </summary>
public void GenerateDensities()
{
float stepSize = settings.size / settings.resolution;
// Loop through all points to generate from the position.
for (int x = 0; x < settings.resolution + 1; x++)
{
for (int y = 0; y < settings.resolution + 1; y++)
{
for (int z = 0; z < settings.resolution + 1; z++)
{
Vector3 localPosition = new Vector3(x * stepSize, y * stepSize, z * stepSize);
Vector3 worldPosition = new Vector3(x * stepSize + position.x,
y * stepSize + position.y,
z * stepSize + position.z);
localPoints[x, y, z] = localPosition;
worldPoints[x, y, z] = worldPosition;
// Calculate noise/density at this point.
float density = noise.Evaluate(worldPosition);
densities[x, y, z] = density;
}
}
}
}
public void PositionBasedNoise(Transform tr, Vector3 scaler)
{
for (var i = 0; i < vertices.Length; i++)
{
NoiseSettings test = new NoiseSettings();
float noisePoint = ((noise.Evaluate(tr.TransformPoint(vertices[i]), noiseSettings, true) + 1) * .5f);
vertices[i] = Vector3.Scale(vertices[i], scaler * (1 + noisePoint));
}
}
float[,,] GetDeepNoise(float chunkX, float chunkY)
{
float[,,] noise = new float[chunkSize, chunkSize, chunkHeight];
for (int x = 0; x < chunkSize; x++)
{
for (int y = 0; y < chunkSize; y++)
{
for (int h = 0; h < chunkHeight; h++)
{
float xCoord = (chunkX * chunkSize) + x;
float yCoord = (chunkY * chunkSize) + y;
float hCoord = h;
noise[x, y, h] = noiseFilter.Evaluate(new Vector3(xCoord * noiseScale, hCoord * noiseScale, yCoord * noiseScale));
}
}
}
return(noise);
}
public void PopulateTiles()
{
NoiseFilter noise = new NoiseFilter(new NoiseSettings());
foreach (Tile tile in tiles)
{
Vector3 center = tile.face.Center.normalized;
float value = noise.Evaluate(center);
if (value < mapSettings.percentLand)
{
tile.type = tileSettings.LAND;
}
else
{
tile.type = tileSettings.OCEAN;
}
}
}
public void Generate(WorldSettings aWorldSettings, SystemSettings aSystemSettings)
{
// Initialise
transform.position = Vector3.zero;
worldSettings = aWorldSettings;
systemSettings = aSystemSettings;
sphereCreator = new SphereCreator(worldSettings);
noiseFilter = new NoiseFilter(worldSettings.noiseSettings);
// Generate World
mesh = sphereCreator.CreateSphere();
foreach (Vertice vertice in mesh.vertices)
{
float height = noiseFilter.Evaluate(vertice.position);
vertice.height = height;
}
GetComponent <MeshFilter>().mesh = mesh.Render();
}
private Vector3 PointOnPlanet(Vector3 pointOnUnitSphere, out float elevation)
{
elevation = _radious * (1 + _noiseFilter.Evaluate(pointOnUnitSphere));
return(pointOnUnitSphere * elevation);
}
public float getNoise(Vector3 pointOnUnitSphere)
{
return(noiseFilter.Evaluate(noiseSettings, pointOnUnitSphere));
}
public void Generate(Tile tile)
{
if (tile.Layer < terrainSettings.renderLayer)
{
throw new ArgumentException("Tile cannot be rendered with current render layer.");
}
if (tile.Layer > terrainSettings.renderLayer)
{
foreach (Tile child in tile.Values)
{
Generate(child);
}
return;
}
//TODO: Split meshes into different class
// Group objects by layer
// Hexes do not line up at higher layers. Angle and sizing is slightly off.
GameObject gameObject = new GameObject();
MeshFilter meshFilter = gameObject.AddComponent <MeshFilter>();
MeshRenderer meshRenderer = gameObject.AddComponent <MeshRenderer>();
Vector3 position = tile.Position();
Vector3[] vertices = new Vector3[7];
int[] triangles = new int[18];
float distanceMultiple = Mathf.Pow(Mathf.Sqrt(7), tile.Layer);
float degree_offset = (tile.Layer * 19.11f) - 30;
float noise = noiseFilter.Evaluate(position.x, position.z);
vertices[0] = new Vector3(position.x, noise, position.z);
for (int i = 0; i < 6; i++)
{
float multiple = Mathf.Pow(2.65f, tile.Layer);
float degrees = (60 * i) + degree_offset;
float radians = Mathf.PI / 180 * degrees;
float posX = position.x + multiple * Mathf.Cos(radians);
float posZ = position.z + multiple * Mathf.Sin(radians);
float posY = noiseFilter.Evaluate(posX, posZ);
vertices[i + 1] = new Vector3(posX, posY, posZ);
}
int index = 0;
for (int j = 1; j < 7; j++)
{
triangles[index++] = 0;
if (j != 6)
{
triangles[index++] = j + 1;
}
else
{
triangles[index++] = 1;
}
triangles[index++] = j;
}
gameObject.name = tile.ToString();
gameObject.transform.parent = world.transform;
meshRenderer.sharedMaterial = new Material(Shader.Find("Standard"));
Mesh mesh = new Mesh();
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.RecalculateNormals();
meshFilter.sharedMesh = mesh;
}
public Vector3 CalculatePointOnPlanet(Vector3 pointOnUnitSphere)
{
float elevation = noiseFilter.Evaluate(pointOnUnitSphere);
return(pointOnUnitSphere * settings.radius * (1 + elevation));
}
public Vector3 CalculatePointOnSphere(Vector3 pointOnUnitSphere)
{
var evaluation = noiseFilter.Evaluate(pointOnUnitSphere);
return(pointOnUnitSphere * settings.sphereRadius * (1 + evaluation));
}
public Vector3 calcPoint(Vector3 pointOnSphere)
{
float elevation = noiseFilter.Evaluate(pointOnSphere);
return(pointOnSphere * settings.SphereRadius * (1 + elevation));
}
public Vector3 CalculatePointOnAsteroid(Vector3 pointOnUnitshpere)
{
float noisyElevation = noiseFilter.Evaluate(pointOnUnitshpere);
return(pointOnUnitshpere * shapeSettings.asteroidRadius * (1 + noisyElevation));
}
