示例#1
0
        public TerrainGenerator(long seed)
        {
            var seededConstant = new SimplexPerlin((int)seed, NoiseQuality.Fast);

            TurbX = new OpenSimplex(seed);
            TurbY = new OpenSimplex(seed);
            Chaos = new RidgedMultiFractal {
                OctaveCount = 7, Primitive2D = seededConstant
            };
            Hill = new OpenSimplex(seed);
            Alt  = new HybridMultiFractal {
                OctaveCount = 8, Gain = 0.1f, Primitive2D = seededConstant
            };
            Temp = new OpenSimplex(seed);
            Dry  = new HeterogeneousMultiFractal()
            {
                Primitive2D = seededConstant
            };
            Small = new HeterogeneousMultiFractal {
                OctaveCount = 2, Primitive2D = seededConstant
            };
            Rock = new HybridMultiFractal()
            {
                Gain = 0.3f, Primitive2D = seededConstant
            };
            Cliff = new HybridMultiFractal()
            {
                Gain = 0.3f, Primitive2D = seededConstant
            };
            Humid = new Billow {
                OctaveCount = 12, Gain = 0.125f, Frequency = 1, Primitive2D = seededConstant
            };
        }
 public HeterogeneousMultiFractal2DPrimitive(double frequency, double scale, int seed, NoiseQuality quality)
 {
     this.frequency = frequency;
     this.scale     = scale;
     noise          = new HeterogeneousMultiFractal {
         Primitive2D = new SimplexPerlin(seed, quality)
     };
 }
示例#3
0
        public IModule3D CreateModule()
        {
            FilterModule filterModule = null;

            switch (filter)
            {
            case NoiseFilter.Pipe:
                filterModule = new Pipe();
                break;

            case NoiseFilter.SumFractal:
                filterModule = new SumFractal();
                break;

            case NoiseFilter.SinFractal:
                filterModule = new SinFractal();
                break;

            case NoiseFilter.MultiFractal:
                filterModule = new MultiFractal();
                break;

            case NoiseFilter.Billow:
                filterModule = new Billow();
                break;

            case NoiseFilter.HeterogeneousMultiFractal:
                filterModule = new HeterogeneousMultiFractal();
                break;

            case NoiseFilter.HybridMultiFractal:
                filterModule = new HybridMultiFractal();
                break;

            case NoiseFilter.RidgedMultiFractal:
                filterModule = new RidgedMultiFractal();
                break;

            case NoiseFilter.Voronoi:
                filterModule = new Voronoi();
                break;
            }
            if (filterModule != null)
            {
                filterModule.Frequency   = frequency;
                filterModule.Lacunarity  = lacunarity;
                filterModule.OctaveCount = (float)octaves;
                filterModule.Offset      = offset;
                filterModule.Gain        = gain;
            }
            return((IModule3D)filterModule);
        }
示例#4
0
文件: FrmMain.cs 项目: ofux/LibNoise
        /// <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;
        }
示例#5
0
        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);
        }