Beispiel #1
0
        /// <summary>
        /// Build the noise tree used for terrain generation
        /// </summary>
        private Module BuildModuleTree()
        {
            var mountainTerrain = new RidgedMulti()
            {
                Seed = this.Seed
            };

            var baseFlatTerrain = new Billow()
            {
                Seed      = this.Seed,
                Frequency = 2
            };

            var flatTerrain = new ScaleBias()
            {
                Source0 = baseFlatTerrain,
                Scale   = 0.125,
                Bias    = -0.75
            };

            var terrainType1 = new Perlin()
            {
                Frequency   = 0.5,
                Persistence = 0.25,
                Seed        = this.Seed
            };

            var terrainType2 = new Perlin()
            {
                Frequency   = 0.5,
                Persistence = 0.25,
                Seed        = this.Seed + 1337
            };

            var terrainType = new Multiply()
            {
                Source0 = terrainType1,
                Source1 = terrainType2
            };

            var terrainSelector = new Select()
            {
                Source0     = flatTerrain,
                Source1     = mountainTerrain,
                Control     = terrainType,
                LowerBound  = 0,
                UpperBound  = 1000,
                EdgeFalloff = 0.125
            };

            var finalTerrain = new Turbulence()
            {
                Source0   = terrainSelector,
                Frequency = 4,
                Power     = 0.125,
                Seed      = this.Seed
            };

            return(finalTerrain);
        }
Beispiel #2
0
    // Use this for initialization
    void Start()
    {
        IModule mountainTerrain = new RidgedMulti();
        IModule baseFlatTerrain = new Billow();

        ((Billow)baseFlatTerrain).Frequency = 2.0;
        IModule flatTerrain = new ScaleBias(baseFlatTerrain, 0.125, -0.75);
        IModule terrainType = new Perlin();

        ((Perlin)terrainType).Frequency   = 0.5;
        ((Perlin)terrainType).Persistence = 0.25;
        IModule finalTerrain = new Select(flatTerrain, mountainTerrain, terrainType);

        ((Select)finalTerrain).SetBounds(0.0, 1000.0);
        ((Select)finalTerrain).SetEdgeFallOff(0.125);
        NoiseMapBuilderPlane heightMapBuilder = new NoiseMapBuilderPlane(256, 256);

        heightMapBuilder.SetBounds(6.0, 10.0, 1.0, 5.0);
        heightMapBuilder.Build(finalTerrain);
        RendererImage render = new RendererImage();

        render.SourceNoiseMap = heightMapBuilder.Map;
        render.ClearGradient();
        render.AddGradientPoint(-1.0000, new Color32(32, 160, 0, 255));
        render.AddGradientPoint(-0.2500, new Color32(224, 224, 0, 255));
        render.AddGradientPoint(0.2500, new Color32(128, 128, 128, 255));
        render.AddGradientPoint(1.0000, new Color32(255, 255, 255, 255));
        render.IsLightEnabled  = true;
        render.LightContrast   = 3.0;
        render.LightBrightness = 2.0;
        render.Render();
        tex = render.GetTexture();
    }
Beispiel #3
0
 public Biome(float _airLandCutoff, float _topLayerCutoff, float _secLayerCutoff, float _yMulti, float _pFreq, float _pLac, int _pOct, float _pPers)
 {
     this.AirAndLandIntersectionCutoff = _airLandCutoff;
     this.LandTopLayerCutoff           = _topLayerCutoff;
     this.Land2NDLayerCutoff           = _secLayerCutoff;
     this.YMultiplier       = _yMulti;
     this.PerlinFrequency   = _pFreq;
     this.PerlinLacunarity  = _pLac;
     this.PerlinOctaveCount = _pOct;
     this.PerlinPersistence = _pPers;
     this.Perlin            = new Perlin()
     {
         Quality     = SharpNoise.NoiseQuality.Fast,
         Frequency   = this.PerlinFrequency,
         Lacunarity  = this.PerlinLacunarity,
         OctaveCount = this.PerlinOctaveCount,
         Persistence = this.PerlinPersistence,
         Seed        = GameManager.WorldSeed
     };
     this.Ridged = new RidgedMulti()
     {
         Quality     = SharpNoise.NoiseQuality.Fast,
         Frequency   = this.RidgedFrequency,
         Lacunarity  = this.RidgedLacunarity,
         OctaveCount = this.RidgedOctaveCount,
         Seed        = GameManager.WorldSeed,
     };
 }
Beispiel #4
0
        public override Module GetModule()
        {
            int n = 2 + (int)Mathf.Log(_height, 2);

            var mountainTerrain = new RidgedMulti()
            {
                Frequency   = 1,
                Lacunarity  = 1.9532562354f,
                OctaveCount = n,
                Seed        = _seed + 2 * _offset
            };

            var baseFlatTerrain = new Billow()
            {
                Frequency   = 2,
                Lacunarity  = 2.031242124f,
                OctaveCount = n,
                Seed        = _seed + 1 * _offset,
            };

            var flatTerrain = new ScaleBias()
            {
                Source0 = baseFlatTerrain,
                Scale   = 0.75,
                Bias    = -0.25,
            };

            var terrainType = new Perlin()
            {
                Frequency   = _frequency,
                Lacunarity  = 2.1023423f,
                Persistence = 0.25,
                OctaveCount = n,
                Seed        = _seed
            };

            var terrainSelector = new Select()
            {
                Source0     = flatTerrain,
                Source1     = mountainTerrain,
                Control     = terrainType,
                LowerBound  = 0,
                UpperBound  = 1000,
                EdgeFalloff = 0.125,
            };

            var finalTerrain = new Turbulence()
            {
                Source0   = terrainSelector,
                Frequency = 4,
                Roughness = 8,
                Power     = 0.125,
            };

            return(finalTerrain);
        }
Beispiel #5
0
        public TerrainConfigurationComponent()
        {
            Width          = Height = 256;
            TextureRepeat  = 8 * 2;// * 4
            IsModified     = true;
            Correction     = 20;
            ElevationPower = 1;

            Mountain = new RidgedMulti()
            {
                Seed        = 0,
                Frequency   = 1,
                Lacunarity  = 2,
                OctaveCount = 6
            };

            Flat = new Billow()
            {
                Frequency   = 2,
                Seed        = 0,
                Lacunarity  = 2,
                OctaveCount = 3
            };

            FlatScale = new ScaleBias()
            {
                //Scale = 0.125,
                //Bias = -0.75,
                Bias  = 0.05,
                Scale = 0.12,
            };

            Noise = new Perlin()
            {
                Frequency   = 0.5,
                Persistence = 0.25,
                Seed        = 0,
                OctaveCount = 6
            };

            Select = new Select()
            {
                LowerBound  = 0,
                UpperBound  = 1000,
                EdgeFalloff = 0.125,
            };

            Turbulence = new Turbulence()
            {
                Frequency = 1.6,
                Power     = 0.125,
                Roughness = 2,
            };
        }
Beispiel #6
0
        public TemperatureMapGenerator()
        {
            var noise = new RidgedMulti();

            noise.Seed        = new Random().Next();
            noise.Frequency   = .25f;
            noise.OctaveCount = 4;

            var clamper = new Clamp();

            clamper.LowerBound = 0;
            clamper.UpperBound = 1;
            clamper.Source0    = noise;

            Module = clamper;
        }
Beispiel #7
0
        public override Module GetModule()
        {
            int octaves = 2 + (int)Mathf.Log(_height, 2);

            var map = new RidgedMulti()
            {
                Frequency   = _frequency,
                Lacunarity  = _lacunarity,
                OctaveCount = octaves,
                Gain        = _ridgness,
                Offset      = _roughness,
                Seed        = _seed
            };

            return(map);
        }
        static Module CreateTerrainNoise()
        {
            var mountainTerrain = new RidgedMulti()
            {
            };

            var baseFlatTerrain = new Billow()
            {
                Frequency = 2,
            };

            var flatTerrain = new ScaleBias()
            {
                Source0 = baseFlatTerrain,
                Scale   = 0.125,
                Bias    = -0.75,
            };

            var terrainType = new Perlin()
            {
                Frequency   = 0.5,
                Persistence = 0.25,
            };

            var terrainSelector = new Select()
            {
                Source0     = flatTerrain,
                Source1     = mountainTerrain,
                Control     = terrainType,
                LowerBound  = 0,
                UpperBound  = 1000,
                EdgeFalloff = 0.125,
            };

            var finalTerrain = new Turbulence()
            {
                Source0   = terrainSelector,
                Frequency = 4,
                Power     = 0.125,
            };

            return(finalTerrain);
        }
Beispiel #9
0
        // Get noise tree generation
        public float GetNoise(float px, float py, float pz)
        {
            //Perlin perlin = new Perlin()
            //{
            //    Frequency = STATICPerlinFrequency,
            //    Lacunarity = STATICPerlinLacunarity,
            //    OctaveCount = STATICPerlinOctaveCount,
            //    Persistence = STATICPerlinPersistance,
            //    Seed = STATICPerlinSeed,
            //};

            RidgedMulti ridged = new RidgedMulti()
            {
                Frequency   = RidgedFrequency,
                Lacunarity  = RidgedLacunarity,
                OctaveCount = RidgedOctaveCount,
                Seed        = RidgedSeed,
            };

            return((float)ridged.GetValue(px, py, pz));
        }