public void CreateTerrain() { float x = 0f; float[] height = new float[256 * 256]; ImprovedPerlin improvedPerlin = new ImprovedPerlin(0, LibNoise.NoiseQuality.Best); for (int i = 0; i < 256 * 256; i++) { height[i] = improvedPerlin.GetValue(x / 10, x / 10, x * 100) / 3.5f + 1; //if (height[i] > 1.1f) //{ // height[i] = height[i] * 0.8f; //} //else if (height[i] < 0.9f) //{ // height[i] = height[i] * 1.2f; //} x += 0.001f; } SendMessageAndOnResponse(mainCommand.TerrainAdd(new int[] { 256, 256 }, height, "terrain"), "terrain", (message) => { SendMessageAndOnResponse(mainCommand.renderTerrain("renderTerrain"), "renderTerrain", (message) => { terrainId = JSONParser.GetTerrainID(message); string addLayerMsg = mainCommand.AddLayer(terrainId, "addLayer"); SendMessageAndOnResponse(addLayerMsg, "addLayer", (message) => Console.WriteLine("")); }); }); }
public static T[,] CreateTileDistribution <T>(int width, int height, float scale, float coverage) { T[,] output = new T[width, height]; //generate noise ImprovedPerlin perlin = new ImprovedPerlin(); MultiFractal fractal = new MultiFractal(); fractal.Primitive2D = perlin; fractal.Primitive3D = perlin; //scale the noise ScalePoint scaledNoise = new ScalePoint(fractal, scale, scale, scale); //create output distribution map from scaled noise + coverage for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { float val = scaledNoise.GetValue(x, y, 0.1f); if (val < coverage) { output[x, y] = (T)Activator.CreateInstance(typeof(T)); } } } return(output); }
public void StartSimulation() { Console.WriteLine("simulating bike..."); //Example BLE Message //4A-09-4E-05-19-16-00-FF-28-00-00-20-F0 this.running = true; float x = 0.0f; //Perlin for Random values ImprovedPerlin improvedPerlin = new ImprovedPerlin(0, LibNoise.NoiseQuality.Best); while (this.running) { CalculateVariables(improvedPerlin.GetValue(x) + 1); //Simulate sending data foreach (IDataReceiver dataReceiver in this.dataReceivers) { dataReceiver.Bike(GenerateBike0x19()); dataReceiver.Bike(GenerateBike0x10()); dataReceiver.BPM(GenerateHeart()); } Thread.Sleep(1000); x += 0.1f; eventCounter++; elapsedTime++; } }
public Region(int seed, int size = 4096) { Seed = seed; RegionSize = size; Chunks = new Dictionary <Tuple <int, int>, Chunk>(); _perlin = new ImprovedPerlin(Seed, NoiseQuality.Best); }
private void GenWorld() { // Create rotation for noise (so they are less likely to be integers) Quaternion rot = Quaternion.Euler(45, 45, 45); // Create new grid grid = new float[width, height]; /*Vector3 initialArgs = * new Vector3((transform.position.x / transform.lossyScale.x) * (float)width, * (transform.position.y / transform.lossyScale.y) * (float)height, * seed); * * Vector3 diff = new Vector3(1, 1, 0);*/ Vector3 initialArgs = transform.position; initialArgs.z = Seed; Vector3 diff = new Vector3(transform.lossyScale.x / (float)width, transform.lossyScale.y / (float)height, 0); for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) { // Initialise perlin arguments //Vector3 perlinArgs = // new Vector3(x / (float)width, y / (float)height, seed); /*Vector3 perlinArgs = * new Vector3(x, y, seed); * * perlinArgs.x += (transform.position.x / transform.lossyScale.x) * (float)width; * perlinArgs.y += (transform.position.y / transform.lossyScale.y) * (float)height;*/ Vector3 perlinArgs = initialArgs + new Vector3(diff.x * x, diff.y * y, 0); perlinArgs.Scale(noiseScale); // Rotate perlin args so they're unlikely to be integers perlinArgs = rot * perlinArgs; // Generate perlin noise float perlin = ImprovedPerlin.Noise(perlinArgs.x, perlinArgs.y, perlinArgs.z); // Set grid values to noise grid[x, y] = perlin; } } }
public float getValue(Vector2 cubeWorldPosition) { this.frequency = 0.5f; this.lacunarity = 2; this.offset = 1; this.gain = 2; this.exponent = 1f; this.octaveCount = 4f; ImprovedPerlin perlin = new ImprovedPerlin(seed, NoiseQuality.Standard); return(this.finalModule.GetValue(cubeWorldPosition.X, cubeWorldPosition.Y)); }
public string RouteCommand(string serialToSend) { ImprovedPerlin improvedPerlin = new ImprovedPerlin(4325, LibNoise.NoiseQuality.Best); Random r = new Random(); dynamic payload = new { id = "route/add", serial = serialToSend, data = new { nodes = new dynamic[] { new { /*pos = GetPos(0.6f, improvedPerlin)*/ pos = new int[] { 0, 0, 5 }, dir = new int[] { r.Next(20, 100), 0, -r.Next(20, 100) } }, new { //pos = GetPos(1.6f, improvedPerlin), pos = new int[] { 50, 0, 0 }, dir = new int[] { r.Next(20, 100), 0, r.Next(20, 100) } }, new { //pos = GetPos(2.654f, improvedPerlin), pos = new int[] { 20, 0, 20 }, dir = new int[] { r.Next(20, 100), 0, r.Next(20, 100) } }, new { //pos = GetPos(3.6543f, improvedPerlin), pos = new int[] { 10, 0, 50 }, dir = new int[] { -r.Next(3, 7), 0, r.Next(3, 7) } }, new { pos = new int[] { 0, 0, 50 }, dir = new int[] { -r.Next(20, 50), 0, -r.Next(20, 50) } } } } }; //Console.WriteLine("route command: " + JsonConvert.SerializeObject(Payload(payload))); return(JsonConvert.SerializeObject(Payload(payload))); }
// Use this for initialization void Start() { if (targetTerrain == null) { targetTerrain = Terrain.activeTerrain; } if (targetTerrain == null) { Debug.LogError("Please add a terrain object to the scene."); } terrainData = targetTerrain.terrainData; resolution = terrainData.heightmapResolution; cacheHeights = new float[resolution, resolution]; perlin = new ImprovedPerlin(); }
// Use this for initialization void Start() { // generate the mesh planeMesh = PlaneHelper.CreatePlane(resolution, resolution); // add this whenever you'll be updating the mesh frequently planeMesh.MarkDynamic(); // add these components for our GameObject to be able to display meshes MeshFilter mf = gameObject.AddComponent <MeshFilter>(); MeshRenderer mr = gameObject.AddComponent <MeshRenderer>(); // assign our new mesh to this gameobject // sharedMesh means the data will be a pointer instead of copied mf.sharedMesh = planeMesh; mr.material = material; // cache the vertex array so we won't need to allocate each frame cacheVertices = planeMesh.vertices; perlin = new ImprovedPerlin(); }
public IModule3D CreateModule(int globalSeed) { PrimitiveModule primitiveModule = null; switch (primative) { case NoisePrimitive.Constant: primitiveModule = new Constant(offset); break; case NoisePrimitive.Cylinders: primitiveModule = new Cylinders(offset); break; case NoisePrimitive.Spheres: primitiveModule = new Spheres(offset); break; case NoisePrimitive.BevinsGradient: primitiveModule = new BevinsGradient(); break; case NoisePrimitive.BevinsValue: primitiveModule = new BevinsValue(); break; case NoisePrimitive.ImprovedPerlin: primitiveModule = new ImprovedPerlin(); break; case NoisePrimitive.SimplexPerlin: primitiveModule = new SimplexPerlin(); break; } primitiveModule.Quality = quality; primitiveModule.Seed = globalSeed + seed; return((IModule3D)primitiveModule); }
private void Awake() { StartCoroutine(Generate()); perlin = new ImprovedPerlin(); }
private void Awake() { StartCoroutine(Generate()); perlin = new ImprovedPerlin (); }
protected override void CreateNoise(IGH_DataAccess DA, int seed, NoiseQuality noiseQuality) { noise = new ImprovedPerlin(seed, noiseQuality); }
internal static HeightMapModel Create(WorldModel world) { var terrainNames = TerrainType.GetTypes() .OrderBy(x => x.BaseHeight) .ToArray(); var noiseMap = new LibNoise.Builder.NoiseMap(world.Width, world.Height) { BorderValue = 0.0f }; var noise = new ImprovedPerlin() { Quality = LibNoise.NoiseQuality.Best, Seed = DateTime.Now.Millisecond }; var noiseBuilder = new LibNoise.Builder.NoiseMapBuilderPlane(0.0f, 3.0f, 0.0f, 3.0f, true) { SourceModule = new HybridMultiFractal { Primitive3D = noise, //Lacunarity = 1.8f, //Frequency =2.0f }, //SourceModule = new Turbulence //{ // Power = 0.125f, // XDistortModule = noise, // YDistortModule = noise, // ZDistortModule = noise, // SourceModule = new ScaleBias() // { // Scale = 10.0f, // //Bias = 8.0f, // SourceModule = new LibNoise.Modifier.Select( // controlModule: new Pipe() // { // Frequency = 0.5f, // Lacunarity = 0.25f, // Primitive3D = noise // }, // leftModule: new ScaleBias // { // Scale = 0.125f, // Bias = -0.75f, // SourceModule = new Billow // { // Frequency = 2.0f, // Primitive3D = noise // } // }, // rightModule: new RidgedMultiFractal // { // Primitive3D = noise, // Lacunarity = 2.0f, // }, // edge: 0.125f, // lower: 0.0f, // upper: 1000.0f // ) // } //}, NoiseMap = noiseMap }; noiseBuilder.SetSize(world.Width, world.Height); noiseBuilder.Build(); var heights = noiseMap.Share().Select(x => (double)x).ToList(); //float max = 0.0f, min = 0.0f; //noiseMap.MinMax(out min, out max); return(new HeightMapModel { Heights = heights.ToArray(), TerrainTypes = heights.Select(x => { var selected = terrainNames.SkipWhile(terrain => terrain.BaseHeight <= x).FirstOrDefault(); return selected ?? terrainNames.Last(); }).Select(x => x.Id).ToArray(), Width = world.Width, Height = world.Height }); }
private static ushort[] GenerateLandmass(Vector2I chunkCoords) { float globalScale = 1.0F; float baseLandmassScale = 0.005F; // lower => wider. yeah ik. float detailBias = 0.0F; float oceanLevel = 63; float landDeformity = 40; float oceanDeformity = 20; float landMaxHeight = oceanLevel + landDeformity; float oceanMaxDepth = oceanLevel - oceanDeformity; float mountainsDeformity = 10; float moutainsScale = 0.01F; float maxLevel = 63 + 40; // this is meant to be used as a 2D base for continents apparently unused \/ IModule3D baseLandmass = new ImprovedPerlin(World.Seed.Value, NoiseQuality.Best); var billow = new Billow { Primitive3D = baseLandmass, OctaveCount = 5.0F, Frequency = 0.9F, }; IModule3D detailsLandmass = new ImprovedPerlin(World.Seed.Value * 123456, NoiseQuality.Best); detailsLandmass = new ScaleBias(detailsLandmass, .2F, detailBias); baseLandmass = new Add(billow, detailsLandmass); //LibNoise.Modifier.Exponent baseLandExp = new Exponent(baseLandmass, 1.0F); //var combiner = new LibNoise.Combiner.Add(baseLandmass1, baseLandmass1); float oceanCoverage = 0.5F; ushort airID = ItemCache.GetIndex("winecrash:air"); ushort stoneID = ItemCache.GetIndex("winecrash:stone"); ushort[] indices = new ushort[Chunk.Width * Chunk.Height * Chunk.Depth]; Vector3F shift = Vector3F.Zero; Vector3F basePos = new Vector3F((chunkCoords.X * Chunk.Width) + shift.X, shift.Y, (chunkCoords.Y * Chunk.Depth) + shift.Z); for (int i = 0; i < Chunk.Width * Chunk.Height * Chunk.Depth; i++) { //Parallel.For(0, Chunk.Width * Chunk.Height * Chunk.Depth, i => //{ indices[i] = airID; // get, from index, the x,y,z coordinates of the block. Then move it from the basePos x scale. WMath.FlatTo3D(i, Chunk.Width, Chunk.Height, out int x, out int y, out int z); if (y > maxLevel) { continue; } Vector3F finalPos = new Vector3F((basePos.X + x) * baseLandmassScale, basePos.Y + y, (basePos.Z + z) * baseLandmassScale) * globalScale; float landMassPct = baseLandmass.GetValue(finalPos.X, 0, finalPos.Z); // retreive the 2D base land value (as seen from top). If under land cap, it's ocean. bool isLand = landMassPct > oceanCoverage; float landPct = (float)Math.Pow(WMath.Remap(landMassPct, oceanCoverage, 1.0F, 0.0F, 1.0F), 2F); float waterPct = WMath.Remap(landMassPct, 0.0F, oceanCoverage, 0.0F, 1.0F); float landMassHeight = oceanLevel + (landPct * landDeformity); int finalLandMassHeight = (int)landMassHeight; float waterHeight = oceanMaxDepth + (waterPct * oceanDeformity); int finalWaterHeight = (int)waterHeight; if (isLand) { if (y < finalLandMassHeight) { indices[i] = stoneID; } } else if (y == oceanLevel - 1) { //indices[i] = waterID; } else if (y < oceanLevel - 1) { if (y > finalWaterHeight) { //indices[i] = waterID; } else { indices[i] = stoneID; } } // debug: display this as grass / sand. //indices[i] = y == 63 ? (isLand ? grassID : sandID) : (y > 63 ? airID : debugID);//debug.GetValue(finalPos.X, finalPos.Y, finalPos.Z) < cap ? stoneID : airID; //}); } return(indices); }
/// <summary> /// /// </summary> protected void GenerateNoise() { EnabledInterface(false); // Parse input ------------------------------------------------------------------------------------ int seed = ParseInt(_tbxSeed.Text, PrimitiveModule.DefaultSeed); double frequency = ParseDouble(_tbxFrequency.Text, FilterModule.DEFAULT_FREQUENCY); double lacunarity = ParseDouble(_tbxLacunarity.Text, FilterModule.DEFAULT_LACUNARITY); double gain = ParseDouble(_tbxGain.Text, FilterModule.DEFAULT_GAIN); double offset = ParseDouble(_tbxOffset.Text, FilterModule.DEFAULT_OFFSET); double exponent = ParseDouble(_tbxExponent.Text, FilterModule.DEFAULT_SPECTRAL_EXPONENT); var octaveCount = (int)_nstpOctave.Value; bool seamless = _chkbx.Checked; GradientColor gradient = GradientColors.Grayscale; NoiseQuality quality = PrimitiveModule.DefaultQuality; var primitive = NoisePrimitive.ImprovedPerlin; var filter = NoiseFilter.SumFractal; try { quality = (NoiseQuality)Enum.Parse(typeof(NoiseQuality), _cbxQuality.Text); } catch { MessageBox.Show( String.Format("Unknown quality '{0}'", _cbxQuality.Text), "Libnoise Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); EnabledInterface(true); return; } try { primitive = (NoisePrimitive)Enum.Parse(typeof(NoisePrimitive), _cbxPrimitive.Text); } catch { MessageBox.Show( String.Format("Unknown primitive '{0}'", _cbxPrimitive.Text), "Libnoise Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); EnabledInterface(true); return; } try { filter = (NoiseFilter)Enum.Parse(typeof(NoiseFilter), _cbxFilter.Text); } catch { MessageBox.Show( String.Format("Unknown filter '{0}'", _cbxFilter.Text), "Libnoise Error", MessageBoxButtons.OK, MessageBoxIcon.Error ); EnabledInterface(true); return; } switch (_cbxGradient.Text) { case "Grayscale": gradient = GradientColors.Grayscale; break; case "Terrain": gradient = GradientColors.Terrain; break; } // Create module tree ------------------------------------------------------------------------------------ PrimitiveModule pModule = null; switch (primitive) { case NoisePrimitive.Constant: pModule = new Constant(offset); break; case NoisePrimitive.Cylinders: pModule = new Cylinders(offset); seamless = false; break; case NoisePrimitive.Spheres: pModule = new Spheres(offset); seamless = false; break; case NoisePrimitive.BevinsGradient: pModule = new BevinsGradient(); break; case NoisePrimitive.BevinsValue: pModule = new BevinsValue(); break; case NoisePrimitive.ImprovedPerlin: pModule = new ImprovedPerlin(); break; case NoisePrimitive.SimplexPerlin: pModule = new SimplexPerlin(); break; } pModule.Quality = quality; pModule.Seed = seed; FilterModule fModule = null; ScaleBias scale = null; switch (filter) { case NoiseFilter.Pipe: fModule = new Pipe(); break; case NoiseFilter.SumFractal: fModule = new SumFractal(); break; case NoiseFilter.SinFractal: fModule = new SinFractal(); break; case NoiseFilter.MultiFractal: fModule = new MultiFractal(); // Used to show the difference with our gradient color (-1 + 1) scale = new ScaleBias(fModule, 1, -0.8); break; case NoiseFilter.Billow: fModule = new Billow(); ((Billow)fModule).Bias = -0.2; ((Billow)fModule).Scale = 2; break; case NoiseFilter.HeterogeneousMultiFractal: fModule = new HeterogeneousMultiFractal(); // Used to show the difference with our gradient color (-1 + 1) scale = new ScaleBias(fModule, -1, 2); break; case NoiseFilter.HybridMultiFractal: fModule = new HybridMultiFractal(); // Used to show the difference with our gradient color (-1 + 1) scale = new ScaleBias(fModule, 0.7, -2); break; case NoiseFilter.RidgedMultiFractal: fModule = new RidgedMultiFractal(); // Used to show the difference with our gradient color (-1 + 1) scale = new ScaleBias(fModule, 0.9, -1.25); break; case NoiseFilter.Voronoi: fModule = new Voronoi(); break; } fModule.Frequency = frequency; fModule.Lacunarity = lacunarity; fModule.OctaveCount = octaveCount; fModule.Offset = offset; fModule.Offset = offset; fModule.Gain = gain; fModule.Primitive3D = (IModule3D)pModule; IModule3D finalModule; if (scale == null) { finalModule = (IModule3D)fModule; } else { finalModule = scale; } NoiseMapBuilder projection; switch (_cbxProjection.Text) { case "Spherical": projection = new NoiseMapBuilderSphere(); ((NoiseMapBuilderSphere)projection).SetBounds(-90, 90, -180, 180); // degrees break; case "Cylindrical": projection = new NoiseMapBuilderCylinder(); ((NoiseMapBuilderCylinder)projection).SetBounds(-180, 180, -10, 10); break; case "Planar": default: double bound = 2; projection = new NoiseMapBuilderPlane(bound, bound * 2, bound, bound * 2, seamless); //projection = new NoiseMapBuilderPlane(-bound, bound, -bound, bound, seamless); //projection = new NoiseMapBuilderPlane(0, bound, 0, bound, seamless); break; } int width = 0; int height = 0; switch (_cbxSize.Text) { case "256 x 256": width = 256; height = 256; break; case "512 x 512": width = 512; height = 512; break; case "1024 x 1024": width = 1024; height = 1024; break; case "256 x 128": width = 256; height = 128; break; case "512 x 256": width = 512; height = 256; break; case "1024 x 512": width = 1024; height = 512; break; case "2048 x 1024": width = 2048; height = 1024; break; default: case "128 x 128": width = 128; height = 128; break; } // ------------------------------------------------------------------------------------------------ // 0 - Initializing _prbarRenderProgression.Visible = true; _lblProgressPercent.Visible = true; _prbarRenderProgression.Value = 0; ; _lblProgressPercent.Text = ""; _lblLog.Text = String.Format("Create a {0} image with a {1} projection\n", _cbxSize.Text, _cbxProjection.Text); var watchDog = new Stopwatch(); TimeSpan ts; double elaspedTime = 0; // // ------------------------------------------------------------------------------------------------ // 1 - Build the noise map watchDog.Reset(); _prbarRenderProgression.Value = 0; _lblLog.Text += "Building noise map ... "; var noiseMap = new NoiseMap(); /* * // ShapeFilter test * Bitmap bmpShape = new Bitmap("smileyShape.bmp"); * BitmapAdaptater bmShapeAdaptater = new BitmapAdaptater(bmpShape); * * ShapeFilter shapeFilter = new ShapeFilter(); * shapeFilter.Shape = bmShapeAdaptater; * * projection.Filter = shapeFilter; */ projection.SetSize(width, height); projection.SourceModule = finalModule; projection.NoiseMap = noiseMap; projection.CallBack = delegate(int line) { line++; watchDog.Stop(); //Process message Application.DoEvents(); _prbarRenderProgression.Value = (line * 100 / height); _lblProgressPercent.Text = String.Format("{0} % - {1} line(s)", _prbarRenderProgression.Value, line); watchDog.Start(); }; watchDog.Start(); projection.Build(); watchDog.Stop(); ts = watchDog.Elapsed; elaspedTime += ts.TotalMilliseconds; _lblLog.Text += String.Format("{0:00}:{1:00} {2:00},{3:0000}\n", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds * 10 ); // ------------------------------------------------------------------------------------------------ // 2 - Render image // Create a renderer, BitmapAdaptater create a System.Drawing.Bitmap on the fly watchDog.Reset(); _prbarRenderProgression.Value = 0; _lblLog.Text += "Rendering image ... "; var renderer = new ImageRenderer(); renderer.NoiseMap = noiseMap; renderer.Gradient = gradient; renderer.LightBrightness = 2; renderer.LightContrast = 8; //renderer.LightEnabled = true; // Libnoise image struct strategy //Graphics.Tools.Noise.Renderer.Image image = new Graphics.Tools.Noise.Renderer.Image(); //renderer.Image = image; // Dotnet Bitmap Strategy var bmpAdaptater = new BitmapAdaptater(width, height); renderer.Image = bmpAdaptater; renderer.CallBack = delegate(int line) { line++; watchDog.Stop(); //Process message Application.DoEvents(); _prbarRenderProgression.Value = (line * 100 / height); _lblProgressPercent.Text = String.Format("{0} % - {1} line(s)", _prbarRenderProgression.Value, line); watchDog.Start(); }; // Render the texture. watchDog.Start(); renderer.Render(); watchDog.Stop(); ts = watchDog.Elapsed; elaspedTime += ts.TotalMilliseconds; _lblLog.Text += String.Format("{0:00}:{1:00} {2:00},{3:0000}\n", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds * 10 ); //---------------------------------------- // Normalmap rendering test // /* * BitmapAdaptater nmapAdaptater = new BitmapAdaptater(width, height); * NormalMapRenderer nmap = new NormalMapRenderer(); * nmap.Image = nmapAdaptater; * nmap.BumpHeight = 30.0; * nmap.NoiseMap = noiseMap; * nmap.Render(); * nmapAdaptater.Bitmap.Save("normalMap.png", ImageFormat.Png); */ //---------------------------------------- /* * Heightmap8 heightmap8 = new Heightmap8(); * Heightmap8Renderer heightmapRenderer = new Heightmap8Renderer(); * heightmapRenderer.Heightmap = heightmap8; */ /* * Heightmap16 heightmap16 = new Heightmap16(); * Heightmap16Renderer heightmapRenderer = new Heightmap16Renderer(); * heightmapRenderer.Heightmap = heightmap16; */ /* * Heightmap32 heightmap32 = new Heightmap32(); * Heightmap32Renderer heightmapRenderer = new Heightmap32Renderer(); * heightmapRenderer.Heightmap = heightmap32; */ /* * heightmapRenderer.NoiseMap = noiseMap; * heightmapRenderer.ExactFit(); * heightmapRenderer.Render(); */ /* * Heightmap16RawWriter rawWriter = new Heightmap16RawWriter(); * rawWriter.Heightmap = heightmap16; * rawWriter.Filename = "heightmap16.raw"; * rawWriter.WriteFile(); */ // ------------------------------------------------------------------------------------------------ // 3 - Painting // Save the file //bmpAdaptater.Bitmap.Save("rendered.png",ImageFormat.Png); _imageRendered.Width = width; _imageRendered.Height = height; //_imageRendered.Image = _bitmap; _imageRendered.Image = bmpAdaptater.Bitmap; if (_imageRendered.Width > _panImageViewport.Width) { _imageRendered.Left = 0; } else { _imageRendered.Left = (_panImageViewport.Width - _imageRendered.Width) / 2; } if (_imageRendered.Height > _panImageViewport.Height) { _imageRendered.Top = 0; } else { _imageRendered.Top = (_panImageViewport.Height - _imageRendered.Height) / 2; } if (_imageRendered.Width > _panImageViewport.Width || _imageRendered.Height > _panImageViewport.Height) { _imageRendered.Anchor = (AnchorStyles.Left | AnchorStyles.Top); _panImageViewport.AutoScroll = true; } else { _panImageViewport.AutoScroll = false; } // ---------------------------------------------------------------- ts = TimeSpan.FromMilliseconds(elaspedTime); // Format and display the TimeSpan value. _lblLog.Text += String.Format("Duration : {0:00}:{1:00} {2:00},{3:0000}\n", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds * 10 ); EnabledInterface(true); _prbarRenderProgression.Value = 0; _lblProgressPercent.Text = ""; _prbarRenderProgression.Visible = false; _lblProgressPercent.Visible = false; }
private float[] GetPos(float n, ImprovedPerlin improvedPerlin) { float[] res = new float[] { improvedPerlin.GetValue(n) * 50, 0, improvedPerlin.GetValue(n) * 50 }; return(res); }
public Perlin2DPrimitive(double frequency, double scale, int seed, NoiseQuality quality) { this.frequency = frequency; this.scale = scale; perlin = new ImprovedPerlin(seed, quality); }
public NoiseMap Render() { PrimitiveModule primitive = null; switch (this.Primitive) { case NoisePrimitive.Constant: primitive = new Constant(this.Offset); break; case NoisePrimitive.Cylinders: primitive = new Cylinders(this.Offset); this.Seamless = false; break; case NoisePrimitive.Spheres: primitive = new Spheres(this.Offset); this.Seamless = false; break; case NoisePrimitive.BevinsGradient: primitive = new BevinsGradient(); break; case NoisePrimitive.BevinsValue: primitive = new BevinsValue(); break; case NoisePrimitive.ImprovedPerlin: primitive = new ImprovedPerlin(); break; case NoisePrimitive.SimplexPerlin: primitive = new SimplexPerlin(); break; } primitive.Seed = this.Seed; primitive.Quality = this.NoiseQuality; FilterModule filter = null; ScaleBias scale = null; switch (this.Filter) { case NoiseFilter.Pipe: filter = new Pipe(); break; case NoiseFilter.SumFractal: filter = new SumFractal(); break; case NoiseFilter.SinFractal: filter = new SinFractal(); break; case NoiseFilter.MultiFractal: filter = new MultiFractal(); // Used to show the difference with our gradient color (-1 + 1) scale = new ScaleBias(filter, 1f, -0.8f); break; case NoiseFilter.Billow: filter = new Billow(); ((Billow)filter).Bias = -0.2f; ((Billow)filter).Scale = 2f; break; case NoiseFilter.HeterogeneousMultiFractal: filter = new HeterogeneousMultiFractal(); // Used to show the difference with our gradient color (-1 + 1) scale = new ScaleBias(filter, -1f, 2f); break; case NoiseFilter.HybridMultiFractal: filter = new HybridMultiFractal(); // Used to show the difference with our gradient color (-1 + 1) scale = new ScaleBias(filter, 0.7f, -2f); break; case NoiseFilter.RidgedMultiFractal: filter = new RidgedMultiFractal(); // Used to show the difference with our gradient color (-1 + 1) scale = new ScaleBias(filter, 0.9f, -1.25f); break; case NoiseFilter.Voronoi: filter = new Voronoi(); break; } filter.Frequency = this.Frequency; filter.Lacunarity = this.Lacunarity; filter.OctaveCount = this.OctaveCount; filter.Offset = this.Offset; filter.Gain = this.Gain; filter.Primitive3D = (IModule3D)primitive; IModule3D final = scale ?? (IModule3D)filter; NoiseMapBuilder projection; switch (this.Projection) { case NoiseMapProjection.Spherical: projection = new NoiseMapBuilderSphere(); ((NoiseMapBuilderSphere)projection).SetBounds(-90f, 90f, -180f, 180f); // degrees break; case NoiseMapProjection.Cylindrical: projection = new NoiseMapBuilderCylinder(); ((NoiseMapBuilderCylinder)projection).SetBounds(-180f, 180f, -10f, 10f); break; case NoiseMapProjection.Planar: default: float bound = 2f; projection = new NoiseMapBuilderPlane(bound, bound * 2, bound, bound * 2, this.Seamless); break; } NoiseMap noise = new NoiseMap(); projection.SetSize(this.Width, this.Height); projection.SourceModule = final; projection.NoiseMap = noise; projection.Build(); float min, max; noise.MinMax(out min, out max); this.Map = noise; return(noise); }