public void Generate() { if (generator == Generator.PerlinNoise) { map = PerlinNoise.Generate(size, scale, octaves, persistence, lacunarity); } else if (generator == Generator.ExponentiallyDistributedNoise) { map = ExponentiallyDistributedNoise.Generate(size, scale, octaves, persistence, lacunarity); } else if (generator == Generator.Geneveaux) { map = GeneveauxTerrain.Generate(size, riverCount); } foreach (Modifier mod in modifiers) { if (mod == Modifier.BeyerHydraulicErosion) { map = BeyerErosion.Erode(map, erosions); } } if (container == Container.Texture) { Texture2D tex = HeightMap2Texture(map); tex.Apply(); tex.name = "Texture"; AssetDatabase.AddObjectToAsset(tex, this); AssetDatabase.SetMainObject(this, AssetDatabase.GetAssetPath(this)); // This is disgusting and it is the only way I can get the asset to reload and show the texture AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(this)); } else if (container == Container.Mesh) { if (obj != null) { DestroyImmediate(obj); } /* GameObject obj = new GameObject(); * Mesh mesh = HeightMap2Mesh(map); * * MeshFilter filter = obj.AddComponent<MeshFilter>(); * filter.sharedMesh = mesh; * * MeshRenderer renderer = obj.AddComponent<MeshRenderer>(); * renderer.sharedMaterial = new Material(Shader.Find("Specular")); * * AssetDatabase.AddObjectToAsset(obj, this); * AssetDatabase.AddObjectToAsset(mesh, this); */ obj = HeightMap2Mesh(map); obj.name = "Terrain"; // PrefabUtility.SaveAsPrefabAsset(obj, "Assets/terrain.prefab"); // AssetDatabase.AddObjectToAsset(obj, this); // AssetDatabase.SetMainObject(obj, AssetDatabase.GetAssetPath(this)); } }
/// <summary> /// Applies the filter to the specified image. /// </summary> /// <param name="image">The image.</param> /// <param name="targetLocation">The target location.</param> /// <returns>The image</returns> public unsafe Image Apply(Image image, Rectangle targetLocation = default(Rectangle)) { targetLocation = targetLocation == default(Rectangle) ? new Rectangle(0, 0, image.Width, image.Height) : targetLocation.Clamp(image); var Result = new Color[image.Pixels.Length]; Array.Copy(image.Pixels, Result, Result.Length); var XNoise = PerlinNoise.Generate(image.Width, image.Height, 255, 0, 0.0625f, 1.0f, 0.5f, Roughness, Seed); var YNoise = PerlinNoise.Generate(image.Width, image.Height, 255, 0, 0.0625f, 1.0f, 0.5f, Roughness, Seed * 2); Parallel.For(targetLocation.Bottom, targetLocation.Top, y => { fixed(Color * TargetPointer = &image.Pixels[(y * image.Width) + targetLocation.Left]) { Color *TargetPointer2 = TargetPointer; for (int x = targetLocation.Left; x < targetLocation.Right; ++x) { float XDistortion = x + (XNoise.Pixels[(y * image.Width) + x].Red * Power); float YDistortion = y + (YNoise.Pixels[(y * image.Width) + x].Red * Power); var X1 = (int)XDistortion.Clamp(0, image.Width - 1); var Y1 = (int)YDistortion.Clamp(0, image.Height - 1); int ResultOffset = ((y * image.Width) + x); int SourceOffset = ((Y1 * image.Width) + X1); Result[ResultOffset] = image.Pixels[SourceOffset]; } } }); return(image.ReCreate(image.Width, image.Height, Result)); }
private Bitmap FillBitmap(int width, int height, double scale, double offsetX, double offsetY, double offsetZ, double persistence, int octaves) { PerlinNoise perlinNoise = new PerlinNoise { scale = scale, offsetX = offsetX, offsetY = offsetY, offsetZ = offsetZ, octaves = octaves, persistence = persistence }; DirectBitmap directBitmap = new DirectBitmap(width, height); Parallel.For(0, width, (x, state) => { if (generateToken.IsCancellationRequested) { state.Break(); } for (int y = 0; y < height; y++) { int value = (int)(perlinNoise.Generate((double)x / width, (double)y / height) * 255); directBitmap.SetPixel(x, y, Color.FromArgb(value, value, value)); } }); if (generateToken.IsCancellationRequested) { directBitmap.Dispose(); throw new TaskCanceledException(); } Bitmap result = directBitmap.Bitmap; directBitmap.Dispose(); return(result); }
private void Start() { heightmap = PerlinNoise.Generate(width, height, scale, octaves, persistance, lacunarity); Terrain.terrainData.SetHeights(0, 0, heightmap); Debug.Log(LocalToWorldFlat(IndicesToLocalFlat(512, 512))); }
public void KeyMoreThanDataTest() { const int _keyLength = 25; const int _dataLength = 12; var _noiser = new PerlinNoise(); var _secretData = _noiser.Generate(_dataLength); var _crypter = new CryptoProvider(); _crypter.Key = _noiser.Generate(_keyLength); var _crypted = _crypter.Encode(_secretData); var _deCrypted = _crypter.Decode(_crypted); CollectionAssert.AreEqual(_secretData, _deCrypted); }
private bool GenerateIronSample(BlockSpacePosition blockPosition) { double calcX = blockPosition.x * 0.1 + 20.0; double calcY = blockPosition.y * 0.05 - 20.0; double calcZ = blockPosition.z * 0.1; double noiseSample = PerlinNoise.Generate(calcX, calcY + 0.01, calcZ); return(noiseSample < -7.5); }
private bool GenerateCoalSample(BlockSpacePosition blockPosition) { double calcX = blockPosition.x * 0.20; double calcY = blockPosition.y * 0.20 + 5.0; double calcZ = blockPosition.z * 0.20; double noiseSample = PerlinNoise.Generate(calcX, calcY + 0.01, calcZ); return(noiseSample < -0.465); }
private bool GenerateRockSample(BlockSpacePosition blockPosition) { double calcX = blockPosition.x * 0.018; double calcY = blockPosition.y * 0.020; double calcZ = blockPosition.z * 0.018; double noiseSample = PerlinNoise.Generate(calcX, calcY + 0.01, calcZ); return((1.0 + noiseSample - ((double)blockPosition.y / 32.0)) > -1.45 || noiseSample < -0.3); }
/// <summary> /// Generate Perlin Noise procedurally /// /// </summary> /// <param name="width"></param> /// <param name="height"></param> /// <param name="octavesPercent"></param> /// <param name="percentFrequency"></param> /// <returns>Bitmap stream in jpg format</returns> public async Task <Stream> GetPerlinNoise(int width, int height, int octavesPercent, int percentFrequency) { if ((octavesPercent < 1) || (octavesPercent > 100)) { throw new ArgumentException(nameof(octavesPercent) + " must between 1 and 100"); } if ((percentFrequency < 1) || (percentFrequency > 100)) { throw new ArgumentException(nameof(percentFrequency) + " must between 1 and 100"); } return(await Task.Run(() => { return GetStreamFromBitmap(PerlinNoise.Generate(Width: width, Height: height, Octaves: (int)Math.Ceiling(octavesPercent / 33d), Frequency: (float)new Random().NextDouble() + new Random().Next((int)Math.Ceiling(percentFrequency / 25d)), Amplitude: 1f, Persistance: 1f, MinRGBValue: 0, MaxRGBValue: 255, Seed: Guid.NewGuid().GetHashCode())); })); }
public override ChunkData[,] Generate(World world, int seed) { var size = world.WorldWidth * world.ChunkSize; var noise = PerlinNoise.Generate(size, size, octaveCount, amplitude, seed); for (int exp = 0; exp < ExplosionsCount; exp++) { int randomExpX = Random.Range(0, size); int randomExpZ = Random.Range(0, size); var selection = Selections.SelectSphere( new Vector3Int(randomExpX, (int)(world.ChunkHeight * 0.25f), randomExpZ), ExplosionsSize).ToList(); for (int i = 0; i < selection.Count; i++) { if (selection[i].x < 0 || selection[i].x >= size || selection[i].z < 0 || selection[i].z >= size) { continue; } noise[selection[i].x, selection[i].z] = 0; } } for (int x = 0; x < size; x++) { for (int z = 0; z < size; z++) { noise[x, z] *= CurveX.Evaluate((float)x / size) * CurveZ.Evaluate((float)z / size); } } var data = new ChunkData[world.WorldWidth, world.WorldDepth]; for (byte i = 0; i < world.WorldWidth; i++) { for (byte j = 0; j < world.WorldDepth; j++) { var chunk = new ChunkData(world.ChunkSize, world.ChunkHeight); FillChunk(world, chunk, noise, i, j); data[i, j] = chunk; } } return(data); }
public HeightMap(bool pPerlin, int pSize) { _size = pSize; if (pPerlin) { var n = new PerlinNoise(pSize); _map = n.Generate(4, .7f, .4f, .3f, .1f); } else { var n = new DiamondSquareNoise(pSize); _map = n.Generate(0, 5, .5f); float maxHeight = 0; float maxDepth = 1; for (int x = 0; x < pSize; x++) { for (int y = 0; y < pSize; y++) { if (_map[x, y] > maxHeight) { maxHeight = _map[x, y]; } if (_map[x, y] < maxDepth) { maxDepth = _map[x, y]; } } } //Scale all points so they are within max/min maxDepth = Math.Abs(maxDepth); for (int x = 0; x < pSize; x++) { for (int y = 0; y < pSize; y++) { if (_map[x, y] < 0) { _map[x, y] = _map[x, y] / maxDepth; } else if (_map[x, y] > 0) { _map[x, y] = _map[x, y] / maxHeight; } } } } }
private void Reload() { var matrix = PerlinNoise.Generate(Width, Height, OctavesCount, Amplitude, 0); var maxX = matrix.GetLength(0); var maxY = matrix.GetLength(1); perlin = new float[maxX * maxY]; for (var i = 0; i < maxX; i++) { for (var j = 0; j < maxY; j++) { var index = j * maxX + i; perlin[index] = matrix[i, j]; } } }
public void CryptStringTest() { const int _keyLength = 12; var _noiser = new PerlinNoise(); var _secretData = "Однажды, в студеную зимнюю пору я из лесу вышел; был сильный мороз."; var _crypter = new CryptoProvider(); _crypter.Key = _noiser.Generate(_keyLength); var _crypted = _crypter.Encode(_secretData); var _deCrypted = _crypter.DecodeToString(_crypted); Assert.AreEqual(_secretData, _deCrypted); }
//public float z = 0.5f; private void OnDrawGizmosSelected() { Gizmos.color = Color.blue; for (float x = 0.0f; x < 5; x += 0.1f) { for (float z = 0.0f; z < 5; z += 0.1f) { } } for (int i = 0; i < 10000; i++) { var p = UnityEngine.Random.insideUnitSphere; var noise = PerlinNoise.Generate(p.x + 0.5f, p.y + 0.5f, p.z + 0.5f); p = p * (20 + noise); Gizmos.DrawSphere(p, 0.1f); } }
void Generate() { perlinGenerator.Generate(); gridSpawner.Generate(); }
public void GenerateReturnsArrayOfData() { PerlinNoise tm = new PerlinNoise(); float[][] data = tm.Generate(0, 10, 0, 20, 10, 8, 128, 4); }
// генерирует карту высот с размером SizeX, SizeY, по методу LandGenMethod c коэффициентами Convs, со сглаживанием или нет (Smoothing) с долинизацией (Valley) public void GenerateHeightmap(int SizeX, int SizeY, GenMethod LandGenMethod, Convolution[] Convs, bool Smoothing, bool Valley, bool Island) { this.SizeX = SizeX; this.SizeY = SizeY; Heightmap = new double[SizeX, SizeY]; PerlinNoise Noise = new PerlinNoise(256); double min = 99999; double max = -99999; double[,] ar = new double[SizeX, SizeY]; if (LandGenMethod == GenMethod.Perlin) { for (int i = 0; i < SizeX; i++) { for (int j = 0; j < SizeY; j++) { for (int l = 0; l < Convs.Length; l++) { if (Convs[l].Operation == Operation.Plus) { if (Convs[l].Coef != 0) { ar[i, j] += Noise.Generate(i, j, Convs[l].Coef); } else if (Convs[l].Coef != 0) { ar[i, j] *= Noise.Generate(i, j, Convs[l].Coef); } } } if (max < ar[i, j]) { max = ar[i, j]; } if (min > ar[i, j]) { min = ar[i, j]; } } } } else { Random rand = new Random(); double theta; double distanceX, distanceY; double Radius; double x, y; double t; min = 0; for (int k = 0; k < Convs[0].Coef; k++) { Radius = rand.NextDouble() * (SizeX * Convs[1].Coef); if (Island) { theta = rand.NextDouble() * Math.PI * 2; t = rand.NextDouble(); distanceX = t * (SizeX * Convs[2].Coef - Radius); distanceY = t * (SizeY * Convs[2].Coef - Radius); x = SizeX / 2.0 + Math.Cos(theta) * distanceX; y = SizeY / 2.0 + Math.Sin(theta) * distanceY; } else { x = SizeX * rand.NextDouble(); y = SizeY * rand.NextDouble(); } for (int i = 0; i < SizeX; i++) { for (int j = 0; j < SizeY; j++) { t = Radius * Radius - ((i - x) * (i - x) + (j - y) * (j - y)); if (t > 0) { ar[i, j] += t; } if (max < ar[i, j]) { max = ar[i, j]; } //if (min > ar[i, j]) min = ar[i, j]; } } } } double coef = 1 / ((max - min)); for (int i = 1; i < SizeX - 1; i++) { for (int j = 1; j < SizeY - 1; j++) { if (Smoothing) { Heightmap[i, j] = (ar[i - 1, j - 1] + ar[i - 1, j] + ar[i - 1, j + 1] + ar[i, j - 1] + ar[i, j] + ar[i, j + 1] + ar[i + 1, j - 1] + ar[i + 1, j] + ar[i + 1, j + 1] - 9.0 * min) / (9.0 * (max - min)); } else { Heightmap[i, j] = (ar[i, j] - min) * coef; } if (Valley) { Heightmap[i, j] = Math.Sqrt(Heightmap[i, j]); } } } }