void Start()
{
//Init objects.
chunks = new Dictionary <Vector2Int, GameObject>();
blockChanges = new Dictionary <Vector2Int, Dictionary <Vector3Int, int> >();
toBeLoaded = new Queue <Vector2Int>();
toBeDeleted = new Queue <Vector2Int>();
player = GameObject.FindGameObjectWithTag("Player");
noiseGenerator = new SimplexNoiseGenerator();
playerChunkLoc = Vector2Int.zero;
//On Start, build chunk objects/block data out to the render distance.
for (int x = -renderDistance; x < renderDistance; x++)
{
for (int z = -renderDistance; z < renderDistance; z++)
{
chunks.Add(new Vector2Int(x, z), buildChunkData(x, z));
}
}
//Then, have those chunks build their meshes from block data.
for (int x = -renderDistance; x < renderDistance; x++)
{
for (int z = -renderDistance; z < renderDistance; z++)
{
chunks[new Vector2Int(x, z)].GetComponent <TerrainChunk>().buildMesh();
}
}
}
/// <summary>
/// InitializePlot all required simplex noises
/// </summary>
private void InitializeSimplexNoiseGenerators()
{
sngConstantWind = new SimplexNoiseGenerator();
sngWindGust = new SimplexNoiseGenerator();
sngWindDirectionFluctuation = new SimplexNoiseGenerator();
sngAttitudeDisturbances = new SimplexNoiseGenerator();
}
public SimplexDensityFunction(float delta, float magnification)
{
_delta = delta;
_magnification = magnification;
_noise = new SimplexNoiseGenerator(Environment.TickCount);
}
IEnumerator GenerateTerrain()
{
float t = Time.time;
yield return(new WaitForEndOfFrame());
SimplexNoiseGenerator sng = new SimplexNoiseGenerator(seed);
BinaryImage bi = new BinaryImage(tex.width, tex.height, false);
for (int x = 0; x < tex.width; x++)
{
float height = sng.coherentNoise(x / terrainStretch + (transform.position.x * terrainStretch), 0, 0, 1, 200, 1.75f, 2f, 0.9f);
height += sng.coherentNoise(x / terrainStretch + (transform.position.x * terrainStretch), 0, 0, 2, 25, 0.05f, 2f, 0.9f);
height += sng.coherentNoise(x / terrainStretch + (transform.position.x * terrainStretch), 0, 0, 1, 25, 0.1f, 2f, 0.9f);
for (int y = 0; y < tex.height; y++)
{
if (y < height * tex.height + 500)
{
bi.Set(x, y, true);
}
else
{
break;
}
}
}
binaryImage = bi;
binaryImage = tidyBinaryImage(binaryImage);
updateCollider();
Debug.Log((Time.time - t) * 1000f);
}
public LayerGenerator(int planetScale, BlockLayerInfo info, Entity entity, SimplexNoiseGenerator noiseGen)
{
this.planetScale = planetScale;
this.info = info;
this.entity = entity;
this.noiseGen = noiseGen;
}
private void Awake()
{
ZoomScale = 0.01f;
heightNoiseGen = new SimplexNoiseGenerator(HeightSeed);
moistureNoiseGen = new SimplexNoiseGenerator(MoistSeed);
CreateTerrain();
}
public ComplexClimateMap(ComplexPlanet planet)
{
this.planet = planet;
tempFluctuationGenerator = new SimplexNoiseGenerator(planet.Seed - 1, 1f / 64, 1f / 64)
{
Octaves = 3
};
}
public HighMountainBiome(IPlanet planet, float minValue, float maxValue, float valueRangeOffset, float valueRange)
: base(planet, minValue, maxValue, valueRangeOffset, valueRange)
{
BiomeNoiseGenerator = new SimplexNoiseGenerator(planet.Seed + 2)
{
FrequencyX = 1f / 256, FrequencyY = 1f / 256, FrequencyZ = 1f / 256, Persistance = 0.5f, Octaves = 6, Factor = 1f
};
}
public void Init()
{
ridgedNoise = new RidgidNoiseGenerator(ridgedSettings, seed);
simplexNoise = new SimplexNoiseGenerator(simplexSettings, seed);
GetComponent <MeshRenderer>().sharedMaterial = material;
body.mass = radius * radius * density;
}
public bool Lookup(SimplexNoiseGenerator noiseGen, Vector3 pos)
{
pos.x += PosOffset;
pos.y += PosOffset;
pos.z += PosOffset;
pos *= PosScale;
return(noiseGen.noise(pos.x, pos.y, pos.z) > NoiseThreshold);
}
void Start()
{
float t = Time.time;
SimplexNoiseGenerator noiseGenerator = new SimplexNoiseGenerator();
DestructibleSprite.seed = noiseGenerator.GetSeed();
for (int x = 0; x < 15; x++)
{
Transform block = (Transform)Instantiate(terrainBlock, new Vector3(x, 0) * 2.62f, Quaternion.identity);
}
}
public static void CreateNewSimplexNoiseGenerator(int seed)
{
int[] seedArray = new int[8];
System.Random rand = new System.Random(seed);
for (int i = 0; i < 8; i++)
{
seedArray[i] = rand.Next();
}
simplexNoiseGenerator = new SimplexNoiseGenerator(seedArray);
}
/// <summary>
/// Run the generator against a world.
/// </summary>
/// <param name="world">The world to generate against.</param>
public void RunGeneration(TWorld world)
{
var biasMap = (float[, ])null;
switch (_biasType)
{
case HeightmapBias.CONTINENTS:
biasMap = CreateRandomBias(world, CONTINENT_BIAS_SIZE);
break;
case HeightmapBias.AZEROTH:
biasMap = CreateAzerothBias(world);
break;
case HeightmapBias.ISLANDS:
biasMap = CreateRandomBias(world, ISLAND_BIAS_SIZE);
break;
case HeightmapBias.NONE:
biasMap = CreateNoneBias(world);
break;
case HeightmapBias.LANDMASS:
biasMap = CreateLandmassBias(world);
break;
default:
throw new Exception("Unknown HeightmassBias: " + _biasType);
}
var noise = new SimplexNoiseGenerator(world.Seed + "height".GetHashCode());
var noiseMap = new float[world.Width, world.Height];
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
noiseMap[x, y] = noise.CoherentNoise(x, y, 0, _octaves, _scale, 0.5f, _lacunarity, _persistence);
}
}
noiseMap = MapUtil.Normalize(noiseMap);
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
world.GetCell(x, y).Height = world.MaxElevation * noiseMap[x, y] * biasMap[x, y];
}
}
}
public SurfaceBiomeGenerator(IPlanet planet, int seaLevel)
: base(planet, 0f, 1f)
{
this.SeaLevel = seaLevel;
BiomeNoiseGenerator = new SimplexNoiseGenerator(planet.Seed)
{
FrequencyX = 1f / 10000, FrequencyY = 1f / 10000, Factor = 1f
};
float offset = (float)seaLevel / (Planet.Size.Z * Chunk.CHUNKSIZE_Z);
SubBiomes.Add(new OceanBiomeGenerator(planet, 0f, 0.3f, 0f, offset));
SubBiomes.Add(new LandBiomeGenerator(planet, 0.5f, 1f, offset, 1 - offset));
SortSubBiomes();
}
public void OnValidate()
{
HeightSeed = Math.Max(0, HeightSeed);
MoistSeed = Math.Max(0, MoistSeed);
Octaves = Mathf.Clamp(Octaves, 1, 16);
OctavePersistence = Mathf.Clamp(OctavePersistence, 0.0f, 1.0f);
MeshSideVertices = Mathf.Max(2, MeshSideVertices);
TextureResolution = MeshSideVertices * lod;
ZoomScale = Mathf.Max(0.01f, ZoomScale);
Size = Mathf.Max(0.01f, Size);
//transform.localScale = Vector3.one * Scale * 100;
Biomes.Sort((b1, b2) => b1.StartHeight < b2.StartHeight ? -1 : 1);
heightNoiseGen = new SimplexNoiseGenerator(HeightSeed);
moistureNoiseGen = new SimplexNoiseGenerator(MoistSeed);
}
/// <summary>
/// ######################
/// ######################
/// BEGIN SECTION DEVOTED TO NOISE
/// ######################
/// ######################
/// </summary>
private void createSimplexMatrix()
{
for (int noiseNumber = 0; noiseNumber < matSizes.Length; noiseNumber++)
{
simplex = new SimplexNoiseGenerator((long)(UnityEngine.Random.Range(int.MinValue, int.MaxValue)));
noiseMat.Add(new float[matSizes [noiseNumber], matSizes [noiseNumber]]);
for (int y = 0; y < matSizes[noiseNumber]; y++)
{
for (int x = 0; x < matSizes[noiseNumber]; x++)
{
//noiseMat [noiseNumber] [y, x] = (float)(simplex.Evaluate (x, y));
noiseMat [noiseNumber] [y, x] = (float)(UnityEngine.Random.Range(-1, 1));
}
}
}
}
public LandBiomeGenerator(IPlanet planet, float minVal, float maxVal, float valueRangeOffset, float valueRange)
: base(planet, valueRangeOffset, valueRange)
{
BiomeNoiseGenerator = new SimplexNoiseGenerator(planet.Seed + 1)
{
FrequencyX = 1f / 1000, FrequencyY = 1f / 1000, Persistance = 0.25f, Octaves = 5, Factor = 1f
};
MinValue = minVal;
MaxValue = maxVal;
SubBiomes.Add(new FlatlandBiome(planet, 0f, 0.2f, 0f, 0.1f));
SubBiomes.Add(new HillsBiome(planet, 0.3f, 0.5f, 0.1f, 0.4f));
SubBiomes.Add(new HighMountainBiome(planet, 0.8f, 1f, 0.2f, 0.8f));
SortSubBiomes();
}
void Prepare()
{
var sn = new SimplexNoiseGenerator();
for (int x = 0; x < lEdge; x++)
{
for (int y = 0; y < lEdge; y++)
{
for (int z = 0; z < lEdge; z++)
{
var i = x + lEdge * y + lEdge * lEdge * z;
var val = sn.noise(x, y, z);
data[i] = new Vector4(x, y, z, val);
}
}
}
}
//##
//END OF TEST METHODS
//##
/// <summary>
/// ######################
/// ######################
/// BEGIN SECTION DEVOTED TO NOISE
/// ######################
/// ######################
/// </summary>
private void createSimplexMatrix()
{
noiseMat = new List <float[, ]>();
for (int noiseNumber = 0; noiseNumber < 8; noiseNumber++)
{
simplex = new SimplexNoiseGenerator((long)(UnityEngine.Random.Range(int.MinValue, int.MaxValue)));
noiseMat.Add(new float[matSizes[noiseNumber], matSizes[noiseNumber]]);
for (int y = 0; y < matSizes[noiseNumber]; y++)
{
for (int x = 0; x < matSizes[noiseNumber]; x++)
{
//finalHeightMap[y, x] = (float)((heightMap[y, x]+minValue)/(maxValue+Math.Abs(minValue)));
noiseMat[noiseNumber][y, x] = (float)(simplex.Evaluate(x, y));
}
}
}
}
private float[,] CreateRandomBias(TWorld world, int biasGridSize)
{
var noise = new SimplexNoiseGenerator(world.Seed + "height_bias".GetHashCode());
var biasGrid = new float[biasGridSize, biasGridSize];
for (int x = 0; x < biasGridSize; x++)
{
for (int y = 0; y < biasGridSize; y++)
{
biasGrid[x, y] = noise.CoherentNoise(x, y, 0, 1, 3, 0.5f, 2, 0.9f);
}
}
biasGrid = MapUtil.Normalize(biasGrid);
for (int x = 0; x < biasGridSize; x++)
{
for (int y = 0; y < biasGridSize; y++)
{
if (x <= 0 || x >= biasGridSize - 1 || y <= 0 || y >= biasGridSize - 1)
{
//Force a bias of zero at the edges.
biasGrid[x, y] = 0;
}
else
{
//select high points
if (biasGrid[x, y] > 0.6)
{
biasGrid[x, y] = 1;
}
else
{
biasGrid[x, y] = 0;
}
}
}
}
return(ExpandBiasGridToMap(world, biasGrid, biasGridSize));
}
//##
//END OF TEST METHODS
//##
/// <summary>
/// ######################
/// ######################
/// BEGIN SECTION DEVOTED TO NOISE
/// ######################
/// ######################
/// </summary>
private void createSimplexMatrix()
{
noiseMat = new List <float[, ]>();
for (int noiseNumber = 1; noiseNumber < 2; noiseNumber++)
{
simplex = new SimplexNoiseGenerator((long)(UnityEngine.Random.Range(int.MinValue, int.MaxValue)));
noiseMat.Add(new float[noiseNumber * 128, noiseNumber * 128]);
print(noiseMat[noiseNumber - 1].Length);
for (int y = 0; y < noiseNumber * 128; y++)
{
for (int x = 0; x < (noiseNumber * 128); x++)
{
//finalHeightMap[y, x] = (float)((heightMap[y, x]+minValue)/(maxValue+Math.Abs(minValue)));
noiseMat[noiseNumber - 1][y, x] = (float)(simplex.Evaluate(x, y));
}
}
}
}
void timerTest()
{
print("starting Timer");
timer.Start();
//time assigning single float random number
simplex = new SimplexNoiseGenerator((long)(UnityEngine.Random.Range(int.MinValue, int.MaxValue)));
float simplexNumber = 0;
for (long x = 0; x < 22400000; x++)
{
simplexNumber = (float)(simplex.Evaluate(x, 0));
}
//print times
print("Time: " + timer.ElapsedMilliseconds);
print("final Number:" + simplexNumber);
timer.Reset();
//timer for
timer.Start();
createSimplexMatrix();
print("Time for full simplex: " + timer.ElapsedMilliseconds);
}
/// <summary>
/// Run the generator against a world.
/// </summary>
/// <param name="world">The world to generate against.</param>
public void RunGeneration(TWorld world)
{
var noiseMap = new float[world.Width, world.Height];
var mountainNoise = new SimplexNoiseGenerator(world.Seed + "mountain_ridge".GetHashCode());
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
noiseMap[x, y] = Math.Abs(mountainNoise.CoherentNoise(x, y, 0, 1, 250, 0.5f, 2, 0.4f));
}
}
noiseMap = MapUtil.Normalize(noiseMap);
var newHeightMap = new float[world.Width, world.Height];
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
var noiseValue = 1 - (noiseMap[x, y] - 0.2f) * 1.25f;
var percHeight = world.GetCell(x, y).Height / world.MaxElevation;
newHeightMap[x, y] = 0.7f * percHeight + 0.3f * noiseValue * (0.5f + percHeight / 2);
}
}
newHeightMap = MapUtil.Normalize(newHeightMap);
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
world.GetCell(x, y).Height = world.MaxElevation * newHeightMap[x, y];
}
}
}
public static Planet Generate(int radius, int terrainHeight, int?heightLimit0 = null)
{
int numDivisions = (int)Mathf.Sqrt((Mathf.PI * Mathf.Pow(radius, 2)) / 5);
int heightLimit = (heightLimit0 == null) ? terrainHeight + 20 : (int)heightLimit0;
Hexasphere hexasphere = new Hexasphere(radius, numDivisions);
Region[] regions = hexasphere.Regions;
var noiseGenerator = new SimplexNoiseGenerator();
foreach (var region in regions)
{
region.GenerateTerrain(noiseGenerator, terrainHeight, heightLimit, radius);
}
var planet = new Planet(radius, terrainHeight);
planet.Regions = regions;
return(planet);
}
static void TestSimplexNoise()
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
SimplexNoiseGenerator sng = new SimplexNoiseGenerator(Environment.TickCount);
sw.Start();
for (int x = 0; x < 16; x++)
{
for (int y = 0; y < 128; y++)
{
for (int z = 0; z < 16; z++)
{
sng.noise3d(x, y, z);
}
}
}
sw.Stop();
Console.WriteLine("Done in {0}ms.", sw.ElapsedMilliseconds);
Console.ReadKey();
}
/// <summary>
/// Run the generator against a world.
/// </summary>
/// <param name="world">The world to generate against.</param>
public void RunGeneration(TWorld world)
{
var oceanBiaser = new OceanBiaser <TWorld, TCell>();
oceanBiaser.CreateBiasPoints(world, 25);
var noise = new SimplexNoiseGenerator(world.Seed + "temperature".GetHashCode());
var noiseMap = new float[world.Width, world.Height];
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
noiseMap[x, y] = noise.CoherentNoise(x, y, 0, 3, 100, 0.5f, 2, 0.4f);
}
}
noiseMap = MapUtil.Normalize(noiseMap);
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
var baseT = y / (float)world.Height * 2;
if (y > world.Height / 2)
{
baseT = (world.Height - y) / (float)world.Height * 2;
}
var oceanBias = 1f - 0.3f * oceanBiaser.OceanBiasAt(new CellAddress(x, y));
world.GetCell(x, y).Temperature = (0.8f * baseT + 0.2f * noiseMap[x, y]) * oceanBias;
}
}
}
/// <summary>
/// Run the generator against a world.
/// </summary>
/// <param name="world">The world to generate against.</param>
public void RunGeneration(TWorld world)
{
var oceanBiaser = new OceanBiaser <TWorld, TCell>();
oceanBiaser.CreateBiasPoints(world, 25);
var noise = new SimplexNoiseGenerator(world.Seed + "rain".GetHashCode());
var rainfallMap = new float[world.Width, world.Height];
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
var bias = (float)(-1 * Math.Cos(y / Math.PI / (world.Height / 6f)) / 2 + 0.5f);
bias = 0.75f * bias + 0.25f;
rainfallMap[x, y] = noise.CoherentNoise(x, y, 0, 3, 75, 0.5f, 2, 0.4f) * bias;
}
}
rainfallMap = MapUtil.Normalize(rainfallMap);
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
if (!IsOcean(x, y, world))
{
var oceanBias = oceanBiaser.OceanBiasAt(new CellAddress(x, y));
world.GetCell(x, y).Rainfall = 0.8f * rainfallMap[x, y] + 0.2f * oceanBias;
}
}
}
}
/// <summary>
/// Run the generator against a world.
/// </summary>
/// <param name="world">The world to generate against.</param>
public void RunGeneration(TWorld world)
{
var noise = new SimplexNoiseGenerator(world.Seed + "rain".GetHashCode());
var noiseMap = new float[world.Width, world.Height];
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
noiseMap[x, y] = noise.CoherentNoise(x, y, 0, _octaves, _scale, 0.5f, _lacunarity, _persistence);
}
}
noiseMap = MapUtil.Normalize(noiseMap);
for (int x = 0; x < world.Width; x++)
{
for (int y = 0; y < world.Height; y++)
{
world.GetCell(x, y).Rainfall = noiseMap[x, y];
}
}
}
public void GenerateTerrain(SimplexNoiseGenerator noiseGenerator, int terrainHeight, int heightLimit, int planetRadius)
{
var chunkHeight = Mathf.CeilToInt(heightLimit / Chunk.CHUNK_HEIGHT);
Chunks = new Chunk[chunkHeight];
for (var i = 0; i < chunkHeight; i++)
{
Chunks[i] = new Chunk(Center + Center.normalized * Chunk.CHUNK_HEIGHT * i, Tiles.Count, i, this);
}
for (var i = 0; i < Tiles.Count; i++)
{
var tile = Tiles[i];
var height = Mathf.Max(terrainHeight - noiseGenerator.getDensity(tile.Center.AsVector(), 0, terrainHeight, octaves: 3, persistence: 0.60f, multiplier: planetRadius / 2), 0);
for (var j = 0; j < Chunks.Length; j++)
{
for (var h = 0; h < Chunk.CHUNK_HEIGHT; h++)
{
if (j == 0 && h == 0)
{
Chunks[j].SetBlock(i, h, 1, false);
}
else if (j * Chunk.CHUNK_HEIGHT + h < height)
{
Chunks[j].SetBlock(i, h, 2, false);
}
else
{
Chunks[j].SetBlock(i, h, 0, false);
}
}
Chunks[j].CheckForEmptiness();
}
}
}
public Texture3D GenerateNoise()
{
SimplexNoiseGenerator noise = new SimplexNoiseGenerator();
Color[] colorArray = new Color[_textureSize * _textureSize * _textureSize];
Texture3D texture = new Texture3D(_textureSize, _textureSize, _textureSize, _format, false);
for (int x = 0; x < _textureSize; x++)
{
for (int y = 0; y < _textureSize; y++)
{
for (int z = 0; z < _textureSize; z++)
{
float value = noise.coherentNoise(x, y, z, _octaves, _multiplier, _amplitude, _lacunarity, _persistence);
Color c = new Color(value, 0.0f, 0.0f, 1.0f);
colorArray[x + (y * _textureSize) + (z * _textureSize * _textureSize)] = c;
}
}
}
texture.SetPixels(colorArray);
texture.Apply();
return(texture);
}
void generateTerrainSimplex()
{
simplexNoise = new SimplexNoiseGenerator (Random.Range (0, 10000).ToString ());
float[] heightMap;
heightMap = new float[loadDistance * loadDistance];
diamondSquare.GRAIN = GRAIN;
diamondSquare.mountainHeight = mountainHeight;
diamondSquare.generateHeightMap (loadDistance, loadDistance, heightMap);
float seedX = Random.Range (5f, 10f);
float seedY = Random.Range (1f, 10f);
float seed = 1f;
/*
for (int i = 0; i < loadDistance; i+= iteratorCount) {
for (int j = 0; j< loadDistance; j+= iteratorCount) {
//int density = (int)(Mathf.PerlinNoise (((float)i / (float)loadDistance) * (loadDistance / 75.0f) * frequency*((i/(float)loadDistance)% (loadDistance/5.0f)), ((j / (float)loadDistance)) * (loadDistance / 75.0f)* frequency*((j/(float)loadDistance)% (loadDistance/5.0f))) * mountainHeight);
// int density = (int)(heightMap[j + i*loadDistance]*mountainHeight);
//int density = mountainHeight;
//int density = (int)(perlin.perlin((i/(float)loadDistance), 0, (j/(float)loadDistance))*mountainHeight);
//int density = (int)(Mathf.PerlinNoise((i/(float)loadDistance)* (loadDistance / 75.0f)*frequency, (j/(float)loadDistance)* (loadDistance / 75.0f)*frequency)*mountainHeight);
int density = (int)(perlin.OctavePerlin((i/(float)loadDistance)*frequency, 0, (j/(float)loadDistance)*frequency, 4, 0.5f)*mountainHeight);
for (int k = 1; k < density; k++) {
//worldScript.set_voxel (i, loadDistance + k, j, 1);
if(perlin.OctavePerlin((i/(float)loadDistance)*4, k/(float)density, j/(float)loadDistance*4, 8, 0.3f) > 0.5f){
//if (simplexNoise.noise ((i / (float)loadDistance) , (k / (float)density)*5, (j / (float)loadDistance)) > 0.0f) {
worldScript.set_voxel (i, loadDistance + k, j, 1);
}
}
worldScript.set_voxel (i, loadDistance, j, 5);
}
}
*/
}
