Hi there!
I’ve been searching the whole day for some pieces of code about noises like perlin noise or tutorials about them. I found some, but they are not what I thought it would be. To be honest, I would like something as Minecraft’s terrain (I’m using voxels). The real problem is that I totally don’t understand how noises work. That’s why I’m asking you if you know good tutorials for noobs with noises? It would be really helpful thank you! 
I finally found the magic noise library libnoise! There’s still a problem, I don’t know how to use 3D noises at all. D:
agree same thing happened to me when i used perlin noise.
My map that i managed to generate after many hours was a crappy, usual boring heightmap. I wanted a “3d” map that has holes, and height can be really high. I dont want the map to be even, i wanted it to have floating islands, secret caves, etc.
After two days of work, this is what I got. Even if it’s getting closer to my goal, I really need to understand and study more libnoise and how noises work.
EggsWorth did long time ago a lib to generate different kind of noise
http://hub.jmonkeyengine.org/groups/user-code-projects/forum/topic/java-noise-jnoise/
maybe you should look into it
I tried his library before libnoise, but I wasn’t even able to make something as smooth as my picture. I don’t understand how to make a Minecraft-like terrain with 3D perlin noise! D:
When I committed TerrainGrid I also added a noise library I created to jme3, so it’s already included in the dependencies. A usage example is also available in the TerrainFractalGridTest class.
1 Like
When I tried the TerrainFractalGridTest I falled through the map. lol Does the noise library supports 3D noise? 
(I see the this.base.value(x, y, z) function).
I keep getting 0s when I try this ‘‘perlin.getValue(x, y, z)’’ with my libnoise’s perlin. ._.
The pictures at the end of the tutorial is really close to what I need: http://www.gamedev.net/blog/33/entry-2227887-more-on-minecraft-type-world-gen/
I found a tutorial and the code about Simplex noise, but my problem is that I don’t want it to be static; I would like it to have a seed, a frequency, a number of octave fractal and a turbulence:
[java]public class SimplexNoise { // Simplex noise in 2D, 3D and 4D
private static int grad3[][] = {{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},
{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},
{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}};
private static int grad4[][]= {{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
{0,-1,1,1}, {0,-1,1,-1}, {0,-1,-1,1}, {0,-1,-1,-1},
{1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
{-1,0,1,1}, {-1,0,1,-1}, {-1,0,-1,1}, {-1,0,-1,-1},
{1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
{-1,1,0,1}, {-1,1,0,-1}, {-1,-1,0,1}, {-1,-1,0,-1},
{1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
{-1,1,1,0}, {-1,1,-1,0}, {-1,-1,1,0}, {-1,-1,-1,0}};
private static int p[] = {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};
// To remove the need for index wrapping, double the permutation table length
private static int perm[] = new int[512];
static { for(int i=0; i<512; i++) perm=p; }
// A lookup table to traverse the simplex around a given point in 4D.
// Details can be found where this table is used, in the 4D noise method.
private static int simplex[][] = {
{0,1,2,3},{0,1,3,2},{0,0,0,0},{0,2,3,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,2,3,0},
{0,2,1,3},{0,0,0,0},{0,3,1,2},{0,3,2,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,3,2,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{1,2,0,3},{0,0,0,0},{1,3,0,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,3,0,1},{2,3,1,0},
{1,0,2,3},{1,0,3,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,0,3,1},{0,0,0,0},{2,1,3,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,1,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,0,1,2},{3,0,2,1},{0,0,0,0},{3,1,2,0},
{2,1,0,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,1,0,2},{0,0,0,0},{3,2,0,1},{3,2,1,0}};
// This method is a lot faster than using (int)Math.floor(x)
private static int fastfloor(double x) {
return x>0 ? (int)x : (int)x-1;
}
private static double dot(int g[], double x, double y) {
return g[0]x + g[1]y; }
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 dot(int g[], double x, double y, double z, double w) {
return g[0]x + g[1]y + g[2]z + g[3]w; }
// 2D simplex noise
public static double noise(double xin, double yin) {
double n0, n1, n2; // Noise contributions from the three corners
// Skew the input space to determine which simplex cell we’re in
final double F2 = 0.5(Math.sqrt(3.0)-1.0);
double s = (xin+yin)F2; // Hairy factor for 2D
int i = fastfloor(xin+s);
int j = fastfloor(yin+s);
final double G2 = (3.0-Math.sqrt(3.0))/6.0;
double t = (i+j)G2;
double X0 = i-t; // Unskew the cell origin back to (x,y) space
double Y0 = j-t;
double x0 = xin-X0; // The x,y distances from the cell origin
double y0 = yin-Y0;
// For the 2D case, the simplex shape is an equilateral triangle.
// Determine which simplex we are in.
int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
if(x0>y0) {i1=1; j1=0;} // lower triangle, XY order: (0,0)->(1,0)->(1,1)
else {i1=0; j1=1;} // upper triangle, YX order: (0,0)->(0,1)->(1,1)
// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
// c = (3-sqrt(3))/6
double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
double y1 = y0 - j1 + G2;
double x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
double y2 = y0 - 1.0 + 2.0 * G2;
// Work out the hashed gradient indices of the three simplex corners
int ii = i & 255;
int jj = j & 255;
int gi0 = perm[ii+perm[jj]] % 12;
int gi1 = perm[ii+i1+perm[jj+j1]] % 12;
int gi2 = perm[ii+1+perm[jj+1]] % 12;
// Calculate the contribution from the three corners
double t0 = 0.5 - x0x0-y0y0;
if(t0<0) n0 = 0.0;
else {
t0 = t0;
n0 = t0 * t0 * dot(grad3[gi0], x0, y0); // (x,y) of grad3 used for 2D gradient
}
double t1 = 0.5 - x1x1-y1y1;
if(t1<0) n1 = 0.0;
else {
t1 = t1;
n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
}
double t2 = 0.5 - x2x2-y2y2;
if(t2<0) n2 = 0.0;
else {
t2 = t2;
n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to return values in the interval [-1,1].
return 70.0 * (n0 + n1 + n2);
}
// 3D simplex noise
public static double noise(double xin, double yin, double zin) {
double n0, n1, n2, n3; // Noise contributions from the four corners
// Skew the input space to determine which simplex cell we’re in
final double F3 = 1.0/3.0;
double s = (xin+yin+zin)F3; // Very nice and simple skew factor for 3D
int i = fastfloor(xin+s);
int j = fastfloor(yin+s);
int k = fastfloor(zin+s);
final double G3 = 1.0/6.0; // Very nice and simple unskew factor, too
double t = (i+j+k)G3;
double X0 = i-t; // Unskew the cell origin back to (x,y,z) space
double Y0 = j-t;
double Z0 = k-t;
double x0 = xin-X0; // The x,y,z distances from the cell origin
double y0 = yin-Y0;
double z0 = zin-Z0;
// For the 3D case, the simplex shape is a slightly irregular tetrahedron.
// Determine which simplex we are in.
int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
if(x0>=y0) {
if(y0>=z0)
{ i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; } // X Y Z order
else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; } // X Z Y order
else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; } // Z X Y order
}
else { // x0<y0
if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; } // Z Y X order
else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; } // Y Z X order
else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; } // Y X Z order
}
// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
// c = 1/6.
double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
double y1 = y0 - j1 + G3;
double z1 = z0 - k1 + G3;
double x2 = x0 - i2 + 2.0G3; // Offsets for third corner in (x,y,z) coords
double y2 = y0 - j2 + 2.0G3;
double z2 = z0 - k2 + 2.0G3;
double x3 = x0 - 1.0 + 3.0G3; // Offsets for last corner in (x,y,z) coords
double y3 = y0 - 1.0 + 3.0G3;
double z3 = z0 - 1.0 + 3.0G3;
// Work out the hashed gradient indices of the four simplex corners
int ii = i & 255;
int jj = j & 255;
int kk = k & 255;
int gi0 = perm[ii+perm[jj+perm[kk]]] % 12;
int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1]]] % 12;
int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2]]] % 12;
int gi3 = perm[ii+1+perm[jj+1+perm[kk+1]]] % 12;
// Calculate the contribution from the four corners
double t0 = 0.6 - x0x0 - y0y0 - z0z0;
if(t0<0) n0 = 0.0;
else {
t0 = t0;
n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
}
double t1 = 0.6 - x1x1 - y1y1 - z1z1;
if(t1<0) n1 = 0.0;
else {
t1 = t1;
n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
}
double t2 = 0.6 - x2x2 - y2y2 - z2z2;
if(t2<0) n2 = 0.0;
else {
t2 = t2;
n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
}
double t3 = 0.6 - x3x3 - y3y3 - z3z3;
if(t3<0) n3 = 0.0;
else {
t3 = t3;
n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
}
// Add contributions from each corner to get the final noise value.
// The result is scaled to stay just inside [-1,1]
return 32.0(n0 + n1 + n2 + n3);
}
// 4D simplex noise
double noise(double x, double y, double z, double w) {
// The skewing and unskewing factors are hairy again for the 4D case
final double F4 = (Math.sqrt(5.0)-1.0)/4.0;
final double G4 = (5.0-Math.sqrt(5.0))/20.0;
double n0, n1, n2, n3, n4; // Noise contributions from the five corners
// Skew the (x,y,z,w) space to determine which cell of 24 simplices we’re in
double s = (x + y + z + w) * F4; // Factor for 4D skewing
int i = fastfloor(x + s);
int j = fastfloor(y + s);
int k = fastfloor(z + s);
int l = fastfloor(w + s);
double t = (i + j + k + l) * G4; // Factor for 4D unskewing
double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
double Y0 = j - t;
double Z0 = k - t;
double W0 = l - t;
double x0 = x - X0; // The x,y,z,w distances from the cell origin
double y0 = y - Y0;
double z0 = z - Z0;
double w0 = w - W0;
// For the 4D case, the simplex is a 4D shape I won’t even try to describe.
// To find out which of the 24 possible simplices we’re in, we need to
// determine the magnitude ordering of x0, y0, z0 and w0.
// The method below is a good way of finding the ordering of x,y,z,w and
// then find the correct traversal order for the simplex we’re in.
// First, six pair-wise comparisons are performed between each possible pair
// of the four coordinates, and the results are used to add up binary bits
// for an integer index.
int c1 = (x0 > y0) ? 32 : 0;
int c2 = (x0 > z0) ? 16 : 0;
int c3 = (y0 > z0) ? 8 : 0;
int c4 = (x0 > w0) ? 4 : 0;
int c5 = (y0 > w0) ? 2 : 0;
int c6 = (z0 > w0) ? 1 : 0;
int c = c1 + c2 + c3 + c4 + c5 + c6;
int i1, j1, k1, l1; // The integer offsets for the second simplex corner
int i2, j2, k2, l2; // The integer offsets for the third simplex corner
int i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
// simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
// Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
// impossible. Only the 24 indices which have non-zero entries make any sense.
// We use a thresholding to set the coordinates in turn from the largest magnitude.
// The number 3 in the “simplex” array is at the position of the largest coordinate.
i1 = simplex[c][0]>:3 ? 1 : 0;
j1 = simplex[c][1]>:3 ? 1 : 0;
k1 = simplex[c][2]>:3 ? 1 : 0;
l1 = simplex[c][3]>:3 ? 1 : 0;
// The number 2 in the “simplex” array is at the second largest coordinate.
i2 = simplex[c][0]>=2 ? 1 : 0;
j2 = simplex[c][1]>=2 ? 1 : 0;
k2 = simplex[c][2]>=2 ? 1 : 0;
l2 = simplex[c][3]>=2 ? 1 : 0;
// The number 1 in the “simplex” array is at the second smallest coordinate.
i3 = simplex[c][0]>=1 ? 1 : 0;
j3 = simplex[c][1]>=1 ? 1 : 0;
k3 = simplex[c][2]>=1 ? 1 : 0;
l3 = simplex[c][3]>=1 ? 1 : 0;
// The fifth corner has all coordinate offsets = 1, so no need to look that up.
double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
double y1 = y0 - j1 + G4;
double z1 = z0 - k1 + G4;
double w1 = w0 - l1 + G4;
double x2 = x0 - i2 + 2.0G4; // Offsets for third corner in (x,y,z,w) coords
double y2 = y0 - j2 + 2.0G4;
double z2 = z0 - k2 + 2.0G4;
double w2 = w0 - l2 + 2.0G4;
double x3 = x0 - i3 + 3.0G4; // Offsets for fourth corner in (x,y,z,w) coords
double y3 = y0 - j3 + 3.0G4;
double z3 = z0 - k3 + 3.0G4;
double w3 = w0 - l3 + 3.0G4;
double x4 = x0 - 1.0 + 4.0G4; // Offsets for last corner in (x,y,z,w) coords
double y4 = y0 - 1.0 + 4.0G4;
double z4 = z0 - 1.0 + 4.0G4;
double w4 = w0 - 1.0 + 4.0G4;
// Work out the hashed gradient indices of the five simplex corners
int ii = i & 255;
int jj = j & 255;
int kk = k & 255;
int ll = l & 255;
int gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
int gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
int gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
// Calculate the contribution from the five corners
double t0 = 0.6 - x0x0 - y0y0 - z0z0 - w0w0;
if(t0<0) n0 = 0.0;
else {
t0 = t0;
n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
}
double t1 = 0.6 - x1x1 - y1y1 - z1z1 - w1w1;
if(t1<0) n1 = 0.0;
else {
t1 = t1;
n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
}
double t2 = 0.6 - x2x2 - y2y2 - z2z2 - w2w2;
if(t2<0) n2 = 0.0;
else {
t2 = t2;
n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
}
double t3 = 0.6 - x3x3 - y3y3 - z3z3 - w3w3;
if(t3<0) n3 = 0.0;
else {
t3 = t3;
n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
}
double t4 = 0.6 - x4x4 - y4y4 - z4z4 - w4w4;
if(t4<0) n4 = 0.0;
else {
t4 *= t4;
n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
}
// Sum up and scale the result to cover the range [-1,1]
return 27.0 * (n0 + n1 + n2 + n3 + n4);
}
}[/java]
It’s time for the strange question! yay:
Is it possible to make a cube planet with the 3D noise with caves and use the noise to generate the surface of all the 6 faces of the cube?
PS: What’s the difference between ‘‘addPreFilter’’ and ‘‘addPostFilter’’? O_O
Thank you!
Sorry for double postin, my old post is getting really big
Okay forgot what I said ‘‘I keep getting 0s when I try this ”perlin.getValue(x, y, z)” with my libnoise’s perlin. ._.’’ because I found that if I put integeters it’ll zero everytime that’s why I did this: ‘‘perlin.getValue(x + 0.5, y + 0.5, z + 0.5)’’
Now I have 2 other problems:
1)My code is really slow to generate a 5050*50 cube (it took 1 minute). Even if I could could optimize a lot my way to show the perlin noise (I actually put a cube at x, y, z if perlin.getValue(x + 0.5, y + 0.5, z + 0.5) > 0), I still think a 3D Simplex noise would be better than a 3D Perlin noise. I’ve read that the Simplex noise start to get really effective at the third dimension.
2) I need to figure out how to do a Minecraft-like terrain generator on a giant cube (generator a terrain like a heightmap but in 3D on each 6 surfaces of the cube and add caves in the giant cube).
Generating a cube with noise heightmap on each face will not be easy. Another thing I see in the article you linked to is that it does not use a heightmap like jme does with terrain. It seems like it treats the big box as it’s made up of small, equal sized boxes, and then removes the ones that are above the generated “heightmap”. Caves are done the same way.
One feature of perlin noise is that it return 0 in all integer coords. If you wish to create more interesting landscapes then perlin noise is just the basis of the function you need to create. You can build any type of fractal based on this simple input, and you can fine tune the result with a bunch of parameters (octaves, roughness, lacunarity, frequency and amplitude are the most common). But regarding to Ken Perlin’s own articles on the subject, he tries to encourage everyone to experiment with the possibilities.
anthyon said:It seems like it treats the big box as it's made up of small, equal sized boxes, and then removes the ones that are above the generated "heightmap". Caves are done the same way.
''removes the ones that are above the generated "heightmap".'' When you say above, you mean that the given value of the noise at a certain point is higher than a number choosen by the programmer such as 0.5? Anyway, you seem to understand it more than me. ;) I think I'll have to work again on that. One other thing about the article, I can't figure out with libnoise how to dow a gradient function on an axis like they did. Do you know how I can do that?
You can build any type of fractal based on this simple input, and you can fine tune the result with a bunch of parameters (octaves, roughness, lacunarity, frequency and amplitude are the most common). But regarding to Ken Perlin’s own articles on the subject, he tries to encourage everyone to experiment with the possibilities.
Right now I am playing with the frequency, the octave count, the persistence and the lacunarity.
Generating a cube with noise heightmap on each face will not be easy.
I have an idea how to do this. My real problem will be to make that the cliffs near the borders of each surface fit with the cliffs of the adjacent surfaces and also to add the caves in the middle of the giant cube.
let’s imagine your box is of size 256x256x256 and centered around the origo, so you have 256 small cubes somewhere between -128…127. the noise function gives you a float value at a given 3D location. You can use it two ways to get the meaning:
- You use only a 2d noise having the 3rd parameter (z) as something like offset or time. You can create very impressive animations by using this method, as if you slide the z with smooth non-integer - eg 0.1f - interval, you can create an animated surface. Or you can fine tune your noise with the z value. you can interpret it any way you want. The result of the function can be interpreted as a height value, it will range from -1…1. you can scale it by 128, take the x,y coords of your cube, and remove all small cubes above this value.
- You can use real 3D noise this way the functions result can be interpreted as a density function. You can assign each x,y,z triple a small cube from your big one, and if density <= 0 then remove the small cube. This way you dont have to care for six sides, as this implementation takes care of the whole space instead of planes.
Only the second approach can get you caves and overhangs.
1 Like
What I want is your second option. Actually, in the link I provided before, to make the ‘‘heightmap’’ at the surface along the y axis, the author use a gradient function. With some research, I found the same author giving his code:
http://webcache.googleusercontent.com/search?q=cache:67gsKLW3PWQJ:www.thermite3d.org/phpBB3/viewtopic.php%3Ff%3D2%26t%3D93+libnoise+gradient+module&cd=6&hl=en&ct=clnk&lr=lang_fr|lang_en&source=www.google.com
[java]double dx=x-m_gx1;
double dy=y-m_gy1;
double dz=z-m_gz1;
double dp=dxm_dx+dym_dy+dz*m_dz;
dp=clamp(dp/m_vlen,0.0,1.0);
return lerp(dp,1.0,-1.0);[/java]
I tried to implement it but I can’t figure out how to calculate or get those variables: m_gx1, m_gy1, gz1, m_dy, m_dz and m_vlen. 
Hi again!
I finally fixed my last problem with the gradient, here is my code:
[java]public class Gradient extends ModuleBase
{
public double m_gx1, m_gy1, m_gz1, m_gx2, m_gy2, m_gz2;
public double m_dx, m_dy, m_dz;
public double m_vlen;
public Gradient()
{
}
public Gradient(double _m_gx1, double _m_gy1, double _m_gz1,
double _m_gx2, double _m_gy2, double _m_gz2) throws ExceptionInvalidParam
{
m_gx1 = _m_gx1;
m_gy1 = _m_gy1;
m_gz1 = _m_gz1;
m_gx2 = _m_gx2;
m_gy2 = _m_gy2;
m_gz2 = m_gz2;
m_dx = m_gx2 - m_gx1;
m_dy = m_gy2 - m_gy1;
m_dz = m_gz2 - m_gz1;
m_vlen = (m_gx2 - m_gx1) + (m_gy2 - m_gy1) + (m_gz2 - m_gz1);
}
@Override
public double getValue (double x, double y, double z)
{
double dx=x-m_gx1;
double dy=y-m_gy1;
double dz=z-m_gz1;
double dp=dxm_dx+dym_dy+dz*m_dz;
dp = clamp(dp/m_vlen,0.0,1.0);
return Lerp(dp, 1.0, -1.0);
}
public double clamp(double a, double value, double b)
{
return Math.max(a, Math.min(b, value));
}
public double Lerp(double t, double a, double b)
{
return a + t * (b - a);
}
}[/java]
I have a new problem --
I’m getting this:
Instead of this:
This is my init code:[java]Gradient groundGradient = new Gradient(0, 0, 0, 0, 1, 0);
Const constant1 = new Const(1);
Const constantNeg = new Const(-1);
RidgedMulti groundShape = new RidgedMulti(0.5, 1.1, NoiseQuality.QUALITY_STD, 2, (int)System.nanoTime());
TurbulenceRidgedMulti groundTurb = new TurbulenceRidgedMulti(groundGradient, (int)System.nanoTime(), 1.1, 3, 2);
groundTurb.yDistortModule = groundShape;
Select groundBase = new Select(constant1, constantNeg, groundTurb);
groundBase.setEdgeFalloff(0.2);[/java]
and this is how I get the value
[java]if(groundBase.getValue(x + 0.5, y + 0.5, z + 0.5) <= 0.5)
{
AddBox(new Vector3f(x, y, z), rootNode);
}[/java]
With many tests, I found that groundGradient is always giving me -1 or 1. What is my error?
