← Back to branch summary

~ubuntu-branches/debian/stretch/insubstantial/stretch

« back to all changes in this revision

Viewing changes to substance/src/main/java/org/pushingpixels/substance/internal/utils/PerlinNoiseGenerator.java

  • Committer: Package Import Robot
  • Author(s): Felix Natter
  • Date: 2016-01-18 20:58:45 UTC
  • Revision ID: package-import@ubuntu.com-20160118205845-crbmrkda61qsi5qa
Tags: upstream-7.3+dfsg2
Import upstream version 7.3+dfsg2

Show diffs side-by-side

added added

removed removed

Lines of Context:
substance/src/main/java/org/pushingpixels/substance/internal/utils/PerlinNoiseGenerator.java
 
1
package org.pushingpixels.substance.internal.utils;
 
2
 
 
3
/**
 
4
 * A class for producing Perlin-inspired noise. The code written by Ken Perlin.
 
5
 * 
 
6
 * @author Ken Perlin http://mrl.nyu.edu/~perlin/
 
7
 */
 
8
public class PerlinNoiseGenerator {
 
9
        /**
 
10
         * Returns noise for the specified coordinates.
 
11
         * 
 
12
         * @param x
 
13
         *            X coordinate.
 
14
         * @param y
 
15
         *            Y coordinate.
 
16
         * @param z
 
17
         *            Z coordinate.
 
18
         * @return Noise for the specified coordinates.
 
19
         */
 
20
        static public double noise(double x, double y, double z) {
 
21
                int X = (int) Math.floor(x) & 255, // FIND UNIT CUBE THAT
 
22
                Y = (int) Math.floor(y) & 255, // CONTAINS POINT.
 
23
                Z = (int) Math.floor(z) & 255;
 
24
                x -= Math.floor(x); // FIND RELATIVE X,Y,Z
 
25
                y -= Math.floor(y); // OF POINT IN CUBE.
 
26
                z -= Math.floor(z);
 
27
                double u = fade(x), // COMPUTE FADE CURVES
 
28
                v = fade(y), // FOR EACH OF X,Y,Z.
 
29
                w = fade(z);
 
30
                int A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z, // HASH COORDINATES
 
31
                // OF
 
32
                B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z; // THE 8 CUBE
 
33
                // CORNERS,
 
34
 
 
35
                return lerp(w, lerp(v, lerp(u, grad(p[AA], x, y, z), // AND ADD
 
36
                                grad(p[BA], x - 1, y, z)), // BLENDED
 
37
                                lerp(u, grad(p[AB], x, y - 1, z), // RESULTS
 
38
                                                grad(p[BB], x - 1, y - 1, z))),// FROM 8
 
39
                                lerp(v, lerp(u, grad(p[AA + 1], x, y, z - 1), // CORNERS
 
40
                                                grad(p[BA + 1], x - 1, y, z - 1)), // OF CUBE
 
41
                                                lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(
 
42
                                                                p[BB + 1], x - 1, y - 1, z - 1))));
 
43
        }
 
44
 
 
45
        /**
 
46
         * Fades the specified value.
 
47
         * 
 
48
         * @param t
 
49
         *            Value to fade.
 
50
         * @return faded value.
 
51
         */
 
52
        static double fade(double t) {
 
53
                return t * t * t * (t * (t * 6 - 15) + 10);
 
54
        }
 
55
 
 
56
        /**
 
57
         * Interpolates the specified value.
 
58
         * 
 
59
         * @param t
 
60
         *            Value.
 
61
         * @param a
 
62
         *            Starting interpolation value.
 
63
         * @param b
 
64
         *            Ending interpolation value.
 
65
         * @return Interpolated value.
 
66
         */
 
67
        static double lerp(double t, double a, double b) {
 
68
                return a + t * (b - a);
 
69
        }
 
70
 
 
71
        /**
 
72
         * @param hash
 
73
         * @param x
 
74
         * @param y
 
75
         * @param z
 
76
         * @return
 
77
         */
 
78
        static double grad(int hash, double x, double y, double z) {
 
79
                int h = hash & 15; // CONVERT LO 4 BITS OF HASH CODE
 
80
                double u = h < 8 ? x : y, // INTO 12 GRADIENT DIRECTIONS.
 
81
                v = h < 4 ? y : (h == 12) || (h == 14) ? x : z;
 
82
                return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
 
83
        }
 
84
 
 
85
        /**
 
86
         * Permutations.
 
87
         */
 
88
        static final int p[] = new int[512];
 
89
 
 
90
        /**
 
91
         * Permutations.
 
92
         */
 
93
        static final int permutation[] = { 151, 160, 137, 91, 90, 15, 131, 13, 201,
 
94
                        95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142, 8, 99, 37,
 
95
                        240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62,
 
96
                        94, 252, 219, 203, 117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56,
 
97
                        87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165, 71, 134, 139,
 
98
                        48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133,
 
99
                        230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25,
 
100
                        63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169, 200,
 
101
                        196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3,
 
102
                        64, 52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255,
 
103
                        82, 85, 212, 207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42,
 
104
                        223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153,
 
105
                        101, 155, 167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79,
 
106
                        113, 224, 232, 178, 185, 112, 104, 218, 246, 97, 228, 251, 34, 242,
 
107
                        193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249,
 
108
                        14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204,
 
109
                        176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93, 222,
 
110
                        114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180 };
 
111
        static {
 
112
                for (int i = 0; i < 256; i++)
 
113
                        p[256 + i] = p[i] = permutation[i];
 
114
        }
 
115
}