Perlin Noise

Naučíme tě pracovat na home-office.

Více info »

c-sharp

    // TerrainNoise
    // Generates the perlin noise for the terrain heightmap
    class TerrainNoise
    {
        private static int[][] grad3 = new int[][] 
        {
            new int[] {1, 1, 0}, 
            new int[] {-1, 1, 0}, 
            new int[] {1, -1, 0}, 
            new int[] {-1, -1, 0}, 
		    new int[] {1, 0, 1}, 
            new int[] {-1, 0, 1}, 
            new int[] {1, 0, -1}, 
            new int[] {-1, 0, -1}, 
		    new int[] {0, 1, 1}, 
            new int[] {0, -1, 1}, 
            new int[] {0, 1, -1}, 
            new int[] {0, -1, -1}
        };

        private static int[] p = new int[256];
        private static int[] perm = new int[512];
        private static Random random = new Random();

        public TerrainNoise()
        {
            for (int i = 0; i < 256; i++)
            {
                p[i] = fastfloor(random.NextDouble() * 256);
            }

            for (int i = 0; i < 512; i++)
            {
                perm[i] = p[i&255];
            }
        }

        private static int fastfloor(double x)
        {
            return x > 0 ? (int)x : (int)x - 1;
        }

        private static double dot(int[] g, double x, double y, double z)
        {
            return g[0] * x + g[1] * y + g[2] * z;
        }

        private static double mix(double a, double b, double t)
        {
            return (1 - t) * a + t * b;
        }

        private static double fade(double t)
        {
            return t * t * t * (t * (t * 6 - 15) + 10);
        }

        public double PerlinNoise3D(double x, double y, double z)
        {
            int X = fastfloor(x);
            int Y = fastfloor(y);
            int Z = fastfloor(z);

            x = x - X;
            y = y - Y;
            z = z - Z;

            X = X & 255;
            Y = Y & 255;
            Z = Z & 255;

            int gi000 = perm[X + perm[Y + perm[Z]]] % 12;
            int gi001 = perm[X + perm[Y + perm[Z + 1]]] % 12;
            int gi010 = perm[X + perm[Y + 1 + perm[Z]]] % 12;
            int gi011 = perm[X + perm[Y + 1 + perm[Z + 1]]] % 12;
            int gi100 = perm[X + 1 + perm[Y + perm[Z]]] % 12;
            int gi101 = perm[X + 1 + perm[Y + perm[Z + 1]]] % 12;
            int gi110 = perm[X + 1 + perm[Y + 1 + perm[Z]]] % 12;
            int gi111 = perm[X + 1 + perm[Y + 1 + perm[Z + 1]]] % 12;

            double n000 = dot(grad3[gi000], x, y, z);
            double n100 = dot(grad3[gi100], x - 1, y, z);
            double n010 = dot(grad3[gi010], x, y - 1, z);
            double n110 = dot(grad3[gi110], x - 1, y - 1, z);
            double n001 = dot(grad3[gi001], x, y, z - 1);
            double n101 = dot(grad3[gi101], x - 1, y, z - 1);
            double n011 = dot(grad3[gi011], x, y - 1, z - 1);
            double n111 = dot(grad3[gi111], x - 1, y - 1, z - 1);

            double u = fade(x);
            double v = fade(y);
            double w = fade(z);

            double nx00 = mix(n000, n100, u);
            double nx01 = mix(n001, n101, u);
            double nx10 = mix(n010, n110, u);
            double nx11 = mix(n011, n111, u);

            double nxy0 = mix(nx00, nx10, v);
            double nxy1 = mix(nx01, nx11, v);

            double nxyz = mix(nxy0, nxy1, w);
            return nxyz;
        }
    }

Neformátovaný

Přidáno: 9.6.2013
Expirace: Neuvedeno

Autor: Michael Olšavský