Provides a two-dimensional noise map.
Inheritance: IDisposable
Exemple #1
0
    public void DrawMesh(LibNoise.Unity.Noise2D noiseMap, Texture2D texture, float hMultiplier, AnimationCurve curve, int lod)
    {
        ChunkManager chunkMang = FindObjectOfType <ChunkManager>();

        chunkMang.SplitWorldMap(texture, noiseMap, chunkRows, chunkCols);
        chunkMang.GenerateAllChunks(hMultiplier, curve, lod);
    }
Exemple #2
0
    public void GenerateHeightMap()
    {
        var perlin = new LibNoise.Unity.Generator.Perlin(Frequency, Lacunarity, Persistence, Octaves, Seed, LibNoise.Unity.QualityMode.High);
        //var ridged = new LibNoise.Unity.Generator.RidgedMultifractal(Frequency, Lacunarity, Octaves, Seed, LibNoise.Unity.QualityMode.Medium);
        //var turb = new LibNoise.Unity.Operator.Turbulence(0.25, perlin);
        //var layered = new LibNoise.Unity.Operator.Multiply(perlin, ridged);
        //var
        var scaled = new LibNoise.Unity.Operator.ScaleBias(Scaling, ScaleBias, perlin);
        var final = new LibNoise.Unity.Operator.Terrace(false, scaled);

        //for (float  i = 0; i < 50; i += 10)
        final.Add(0f);
        final.Add(10f);
        final.Add(100f);

        var noise = new LibNoise.Unity.Noise2D(TotalSize, final);
        noise.GeneratePlanar(ClipX, ClipX + (ClipSize * ChunksPerSide), ClipY, ClipY + (ClipSize * ChunksPerSide));

        GameObject.Destroy(HeightMap);
        HeightMap = noise.GetTexture(LibNoise.Unity.Gradient.Grayscale);
        HeightMap.Apply();

        GameObject.Destroy(NormalMap);
        NormalMap = noise.GetNormalMap(1f);
        NormalMap.Apply();

        floatMap = new float[TotalSize * TotalSize];
        for (int y = 0; y < TotalSize; y++)
            for (int x = 0; x < TotalSize; x++)
                floatMap[y * TotalSize + x] = noise[x, y];
    }
Exemple #3
0
    public void Generate()
    {
        // Create the module network
            ModuleBase moduleBase;
            switch(noise) {
                case NoiseType.Billow:
                moduleBase = new Billow();
                break;

                case NoiseType.RiggedMultifractal:
                moduleBase = new RiggedMultifractal();
                break;

                case NoiseType.Voronoi:
                moduleBase = new Voronoi();
                break;

              	case NoiseType.Mix:
                Perlin perlin = new Perlin();
                RiggedMultifractal rigged = new RiggedMultifractal();
                moduleBase = new Add(perlin, rigged);
                break;

                default:
                moduleBase = new Perlin();
                break;

            }

            // Initialize the noise map
            this.m_noiseMap = new Noise2D(resolution, resolution, moduleBase);
            this.m_noiseMap.GeneratePlanar(
            offset + -1 * 1/zoom,
            offset + offset + 1 * 1/zoom,
            offset + -1 * 1/zoom,
            offset + 1 * 1/zoom);

        Debug.Log (moduleBase.GetValue (0, 0, UnityEngine.Random.value));

            // Generate the textures
            this.m_textures[0] = this.m_noiseMap.GetTexture(LibNoise.Unity.Gradient.Grayscale);
            this.m_textures[0].Apply();

            this.m_textures[1] = this.m_noiseMap.GetTexture(LibNoise.Unity.Gradient.Terrain);
            this.m_textures[1].Apply();

            this.m_textures[2] = this.m_noiseMap.GetNormalMap(3.0f);
            this.m_textures[2].Apply();

             //display on plane
             GetComponent<Renderer>().material.mainTexture = m_textures[0];

            //write images to disk
            File.WriteAllBytes(Application.dataPath + "/../Gray.png", m_textures[0].EncodeToPNG() );
            File.WriteAllBytes(Application.dataPath + "/../Terrain.png", m_textures[1].EncodeToPNG() );
            File.WriteAllBytes(Application.dataPath + "/../Normal.png", m_textures[2].EncodeToPNG() );

            Debug.Log("Wrote Textures out to "+Application.dataPath + "/../");
    }
Exemple #4
0
 public void SplitWorldMap(Texture2D wMap, LibNoise.Unity.Noise2D nMap, int rows, int cols)
 {
     chunkCols = cols;
     chunkRows = rows;
     worldMap  = wMap;
     noiseMap  = nMap;
     SplitTexture();
 }
	public MakePerlin(float seed) {	

		perlin = new Texture2D (256, 256);
		ModuleBase moduleBase;
		moduleBase = new Perlin(m_frequency, m_lacunarity, m_persistence, m_octaveCount, (int)seed, m_quality);
		noiseMap = new Noise2D(perlin.width, perlin.height, moduleBase);

		float zoom = 1f; 
		float offset = 0f;
		noiseMap.GeneratePlanar(
			offset + -1 * 1/zoom, 
			offset + offset + 1 * 1/zoom, 
			offset + -1 * 1/zoom,
			offset + 1 * 1/zoom);

		perlin = noiseMap.GetTexture ();
	}
Exemple #6
0
    // Generate noise map

    //mapSizeSqrt, mapSizeSqrt, seed, side, offset, octaves, persistence, lacunarity, noiseSource

    public static float[,] GenerateNoiseMap(int seed, Vector3 offset, GPUNoiseGenerator.NoiseData noise, float scale, NoiseSource source, int?meshGridSize = null, float zoom = 1, int performanceTestLoops = 1, float radius = 100)
    {
        int mapSizeSqrt = (int)noise.resolution;

        float[,] noiseMap = new float[mapSizeSqrt, mapSizeSqrt];

        System.Diagnostics.Stopwatch st = new System.Diagnostics.Stopwatch();
        st.Start();
        for (int performanceLoopIndex = 0; performanceLoopIndex < performanceTestLoops; ++performanceLoopIndex)
        {
            switch (source)
            {
            case NoiseSource.Unity:
                #region [ - Unity Noise - ]

                Vector2 chunkOffset = offset;

                //GenerateFalloffMap(ref falloffMap, mapChunkSize);

                /* Generate Height Map
                 *      (mapSide tarkottaa yhen spherical cuben reunan HeightMapin kokoa)
                 *         [5]
                 *         [4]
                 *      [1][2][3]
                 *         [0]
                 */

                // Laskee sphericalCuben valitun lähtöpisteen
                for (int i = 0, len = int.Parse(((int)noise.side).ToString()); i <= len; ++i)
                {
                    switch (i)
                    {
                    case 0:
                        chunkOffset.x += mapSizeSqrt;
                        break;

                    case 1:
                        chunkOffset.x -= mapSizeSqrt;
                        chunkOffset.y += mapSizeSqrt;
                        break;

                    case 2:
                        chunkOffset.x += mapSizeSqrt;
                        break;

                    case 3:
                        chunkOffset.x += mapSizeSqrt;
                        break;

                    case 4:
                        chunkOffset.x -= mapSizeSqrt;
                        chunkOffset.y += mapSizeSqrt;
                        break;

                    case 5:
                        chunkOffset.y += mapSizeSqrt;
                        break;
                    }
                }
                // Laskee quartereitten (..quartereitten (..quartereitten (..jne))) lähtöpisteen
                int quarterSize = mapSizeSqrt;

                for (int i = 0, len = noise.quarter.Length; i < len; ++i)
                {
                    //quarterSize /= 2; // quarterin leveys\korkeus
                    scale *= 2;

                    switch (noise.quarter[i])
                    {
                    case '0':                                     // vasenala
                        // -> piste ei liiku minnekkään
                        Debug.Log("scale: " + scale + ", quarter size: " + quarterSize + ", side:" + noise.quarter[i] + ", offset: " + chunkOffset.x + " | " + chunkOffset.y);
                        break;

                    case '1':                                     // oikeeala
                        chunkOffset.x += quarterSize / scale;
                        Debug.Log("scale: " + scale + ", quarter size: " + quarterSize + ", side:" + noise.quarter[i] + ", offset: " + chunkOffset.x + " | " + chunkOffset.y);
                        break;

                    case '2':                                     // vasenylä
                        chunkOffset.y += quarterSize / scale;
                        Debug.Log("scale: " + scale + ", quarter size: " + quarterSize + ", side:" + noise.quarter[i] + ", offset: " + chunkOffset.x + " | " + chunkOffset.y);
                        break;

                    case '3':                                     // oikeeylä
                        chunkOffset.x += quarterSize / scale;
                        chunkOffset.y += quarterSize / scale;
                        Debug.Log("scale: " + scale + ", quarter size: " + quarterSize + ", side:" + noise.quarter[i] + ", offset: " + chunkOffset.x + " | " + chunkOffset.y);
                        break;
                    }
                }



                Vector2[] octaveOffset = new Vector2[noise.octaves];

                maxPossibleHeight = 0;
                noise.amplitude   = 1;
                noise.frequency   = 1;

                NormalizeMode normalizeMode        = NormalizeMode.Global;
                System.Random prng                 = new System.Random(seed);
                Vector2       randomOffsetFromSeed = new Vector2(prng.Next(-100000, 100000) - chunkOffset.x, prng.Next(-100000, 100000) - chunkOffset.y);

                for (i = 0; i < noise.octaves; ++i)
                {
                    octaveOffset[i] = randomOffsetFromSeed;

                    maxPossibleHeight += noise.amplitude;
                    noise.amplitude   *= noise.persistence;
                }

                if (scale <= 0)
                {
                    scale = 0.0001f;
                }

                maxLocalNoiseHeight = float.MinValue;
                minLocalNoiseHeight = float.MaxValue;

                halfWidth  = mapSizeSqrt / 2f;
                halfHeight = mapSizeSqrt / 2f;

                for (y = 0; y < mapSizeSqrt; ++y)
                {
                    for (x = 0; x < mapSizeSqrt; ++x)
                    {
                        noise.amplitude = 1;
                        noise.frequency = 1;
                        noiseHeight     = 0;

                        for (i = 0; i < noise.octaves; ++i)                                   // Oktaavien teko kuluttaa sikana eli tarkkana
                        {
                            sampleX = (x - mapSizeSqrt) / scale * noise.frequency + octaveOffset[i].x * noise.frequency;
                            sampleY = (y - mapSizeSqrt) / scale * noise.frequency + octaveOffset[i].y * noise.frequency;

                            perlinValue  = Mathf.PerlinNoise(sampleX, sampleY) * 2 - 1;                                    // tää on raskas, * 2 - 1 tekee sen että se menee [-1, 1])
                            noiseHeight += perlinValue * noise.amplitude;
                            //Debug.Log("X: " + x + ", Y: " + y + " | " + perlinValue + " | " + amplitude);

                            noise.amplitude *= noise.persistence;
                            noise.frequency *= noise.lacunarity;
                        }

                        if (noiseHeight > maxLocalNoiseHeight)
                        {
                            maxLocalNoiseHeight = noiseHeight;
                        }
                        else if (noiseHeight < minLocalNoiseHeight)
                        {
                            minLocalNoiseHeight = noiseHeight;
                        }

                        noiseMap[x, y] = noiseHeight;

                        //Debug.Log("X: " + x + ", Y: " + y + " | " + noiseMap[x, y]);
                        //noiseMap[x, y] = Mathf.InverseLerp(minLocalNoiseHeight, maxLocalNoiseHeight, noiseMap[x, y]);
                    }
                }
                for (int y = 0; y < mapSizeSqrt; ++y)
                {
                    for (int x = 0; x < mapSizeSqrt; ++x)
                    {
                        if (normalizeMode == NormalizeMode.Local)
                        {
                            noiseMap[x, y] = Mathf.InverseLerp(minLocalNoiseHeight, maxLocalNoiseHeight, noiseMap[x, y]);
                        }
                        else
                        {
                            float normalizedHeight = (noiseMap[x, y] + 1) / (maxPossibleHeight / 0.9f);
                            noiseMap[x, y] = Mathf.Clamp(normalizedHeight, 0, int.MaxValue);
                        }
                    }
                }
                #endregion
                break;

            case NoiseSource.LibNoise:
                #region [ - LibNoise - ]

                Perlin perlinNoise = new Perlin {
                    Quality     = QualityMode.Medium,
                    OctaveCount = noise.octaves,
                    Lacunarity  = noise.lacunarity,
                    Seed        = seed,
                    Persistence = noise.persistence,
                    Frequency   = noise.frequency
                };

                LibNoise.Unity.ModuleBase moduleBase;
                moduleBase = perlinNoise;

                Noise2D noise2D = new LibNoise.Unity.Noise2D((int)noise.resolution, (int)noise.resolution, moduleBase);
                //noise.GeneratePlanar((double)offset.x, (double)(offset.x + mapWidth), (double)(offset.y + mapHeight), (double)offset.y);
                noise2D.GeneratePlanar((int)noise.resolution, 0, (int)noise.resolution, 0);

                noiseMap = noise2D.m_data;
                #endregion
                break;


            case NoiseSource.GPU_2DFloatArray:
                #region [ - GPU 2D Float Array - ]
                noiseMap = GPUNoiseGenerator.GenerateNoiseArray(seed, noise, radius, meshGridSize, offset, zoom);
                #endregion
                break;

            case NoiseSource.GPU_RenderTextureTo2DFloatArray:
                #region [ - GPU Render Texture to 2D Float Array - ]
                noiseMap = GPUNoiseGenerator.GenerateNoiseArrayFromRenderTexture(seed, noise);
                #endregion
                break;

            default:
                return(null);
            }
        }
        st.Stop();
        if (performanceTestLoops > 1)
        {
            Debug.Log(string.Format("Generated noise with {0} {1} times and it took {2} ms to complete.", source.ToString(), performanceTestLoops, st.ElapsedMilliseconds));
        }

        return(noiseMap);
    }