I have some problems with the Perlin funcion , it works but not how it should be. if someone have a working example of clouds, marble,wood, using perlin noise and shaders could send it to me?
Thanks bye
What are your problems? glsl has built in noise functions which you could use. Also java source for perlin noise is easily googleable, so it shouldn’t be that hard to convert it into glsl source code.
i dont have expected results modifying frequency , and i don’t know how to add buffer every octave loop.
Anyway this is the code, if you could help me i’ll appreciate really much.
this is the Noise function:
package Util;
public final class ImprovedNoise {
static public double noise(double x, double y, double z) {
int X = (int)Math.floor(x) & 255, // FIND UNIT CUBE THAT
Y = (int)Math.floor(y) & 255, // CONTAINS POINT.
Z = (int)Math.floor(z) & 255;
x -= Math.floor(x); // FIND RELATIVE X,Y,Z
y -= Math.floor(y); // OF POINT IN CUBE.
z -= Math.floor(z);
double u = fade(x), // COMPUTE FADE CURVES
v = fade(y), // FOR EACH OF X,Y,Z.
w = fade(z);
int A = p[X ]+Y, AA = p[A]+Z, AB = p[A+1]+Z, // HASH COORDINATES OF
B = p[X+1]+Y, BA = p[B]+Z, BB = p[B+1]+Z; // THE 8 CUBE CORNERS,
return lerp(w, lerp(v, lerp(u, grad(p[AA ], x , y , z ), // AND ADD
grad(p[BA ], x-1, y , z )), // BLENDED
lerp(u, grad(p[AB ], x , y-1, z ), // RESULTS
grad(p[BB ], x-1, y-1, z ))),// FROM 8
lerp(v, lerp(u, grad(p[AA+1], x , y , z-1 ), // CORNERS
grad(p[BA+1], x-1, y , z-1 )), // OF CUBE
lerp(u, grad(p[AB+1], x , y-1, z-1 ),
grad(p[BB+1], x-1, y-1, z-1 ))));
}
static double fade(double t) { return t * t * t * (t * (t * 6 - 15) + 10); }
static double lerp(double t, double a, double b) { return a + t * (b - a); }
static double grad(int hash, double x, double y, double z) {
int h = hash & 15; // CONVERT LO 4 BITS OF HASH CODE
double u = h<8 ? x : y, // INTO 12 GRADIENT DIRECTIONS.
v = h<4 ? y : h==12||h==14 ? x : z;
return ((h&1) == 0 ? u : -u) + ((h&2) == 0 ? v : -v);
}
static final int p[] = new int[512], permutation[] = { 151,160,137,91,90,15,
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
};
static { for (int i=0; i < 256 ; i++) p[256+i] = p[i] = permutation[i]; }
}
while this method create the texture 3D:
private void createData() {
data = BufferUtil.newByteBuffer(width * height * depth * 4);
int noise3DTexSize = 128;
int f, i, j, k, inc;
int startFrequency = 16;
int numOctaves = 4;
double ni[] = new double[3];
double inci, incj, inck;
int frequency = startFrequency;
double amp = 1;
for (f = 0, inc = 0; f < numOctaves; ++f, frequency *= 1, ++inc, amp *= 0.5) {
ni[0] = ni[1] = ni[2] = 0;
inci = 1.0 / (noise3DTexSize / frequency);
for (i = 0; i < noise3DTexSize; ++i, ni[0] += inci) {
incj = 1.0 / (noise3DTexSize / frequency);
for (j = 0; j < noise3DTexSize; ++j, ni[1] += incj) {
inck = 1.0 / (noise3DTexSize / frequency);
for (k = 0; k < noise3DTexSize; ++k, ni[2] += inck) {
data.put((byte) (((ImprovedNoise.noise(ni[2], ni[1],
ni[0]) + 1) * amp) * 128.0));
}
}
}
}
}AFAIK there is no GPU available with an implemented noise function. On most GPUs you will get 0 as result if you call these functions. But you should find some GLSL noise shaders - just ask google for “simplex noise”.
I’ve never actually used the noise() functions for glsl, good to know.
@omg_meme
I didn’t look through everything that you posted. The first half of your bolded code (ie the stuff in ImprovedNoise) is the exact same basis that I was talking about before. I did notice that in your outer for loop, you’re using freq *= 1. Frequency needs to increase each time to get any good results, I’ve used a doubling frequency each iteration for good results. To add each iteration to the amplitude, all I did was take the previous value at the the point in the buffer and add the new frequency * amplitude to it.