Jump to content

  • Log In with Google      Sign In   
  • Create Account


#ActualMatthewj234

Posted 03 August 2012 - 03:56 PM

Hey guys, I have been frustrated all day on this issue....

I have been using this code to try and generate a 3D environment. My issue... Everything I try with this just ends up with a massive number of random blocks, with no clear placement. The examples I have seen on youtube and elsewhere have shown a coherent noise generation which is procedural. So my question is this, how would I be able to use the code below, to allow me to generate a 3D environment?

Also, why does this only accept [-1,1]?

Thanks in advance for any help offered.

/*****************************************************************************
*						J3D.org Copyright (c) 2000
*							   Java Source
*
* This source is licensed under the GNU LGPL v2.1
* Please read http://www.gnu.org/copyleft/lgpl.html for more information
*
* This software comes with the standard NO WARRANTY disclaimer for any
* purpose. Use it at your own risk. If there's a problem you get to fix it.
*
****************************************************************************/
package com.Sparked_Studios.Tile_Engine.ContentGenerators;
import java.util.Random;
/**
* Computes Perlin Noise for three dimensions.
* <p>
*
* The result is a continuous function that interpolates a smooth path
* along a series random points. The function is consitent, so given
* the same parameters, it will always return the same value. The smoothing
* function is based on the Improving Noise paper presented at Siggraph 2002.
* <p>
* Computing noise for one and two dimensions can make use of the 3D problem
* space by just setting the un-needed dimensions to a fixed value.
*
* @author Justin Couch
* @version $Revision: 1.4 $
*/
public class PerlinNoiseGenerator
{
	// Constants for setting up the Perlin-1 noise functions
	private static final int B = 0x1000;
	private static final int BM = 0xff;
	private static final int N = 0x1000;
	private static final int NP = 12;   /* 2^N */
	private static final int NM = 0xfff;
	/** Default seed to use for the random number generation */
	private static final int DEFAULT_SEED = 100;
	/** Default sample size to work with */
	private static final int DEFAULT_SAMPLE_SIZE = 256;
	/** The log of 1/2 constant. Used Everywhere */
	private static final float LOG_HALF = (float)Math.log(0.5);
	/** Permutation array for the improved noise function */
	private int[] p_imp;
	/** P array for perline 1 noise */
	private int[] p;
	private float[][] g3;
	private float[][] g2;
	private float[] g1;

	/**
	 * Create a new noise creator with the default seed value
	 */
	public PerlinNoiseGenerator()
	{
		this(DEFAULT_SEED);
	}
	/**
	 * Create a new noise creator with the given seed value for the randomness
	 *
	 * @param seed The seed value to use
	 */
	public PerlinNoiseGenerator(int seed)
	{
		p_imp = new int[DEFAULT_SAMPLE_SIZE << 1];
		int i, j, k;
		Random rand = new Random(seed);
		// Calculate the table of psuedo-random coefficients.
		for(i = 0; i < DEFAULT_SAMPLE_SIZE; i++)
			p_imp[i] = i;
		// generate the psuedo-random permutation table.
		while(--i > 0)
		{
			k = p_imp[i];
			j = (int)(rand.nextLong() & DEFAULT_SAMPLE_SIZE);
			p_imp[i] = p_imp[j];
			p_imp[j] = k;
		}
		initPerlin1();
	}
	/**
	 * Computes noise function for three dimensions at the point (x,y,z).
	 *
	 * @param x x dimension parameter
	 * @param y y dimension parameter
	 * @param z z dimension parameter
	 * @return the noise value at the point (x, y, z)
	 */
	public double improvedNoise(double x, double y, double z)
	{
		// Constraint the point to a unit cube
		int uc_x = (int)Math.floor(x) & 255;
		int uc_y = (int)Math.floor(y) & 255;
		int uc_z = (int)Math.floor(z) & 255;
		// Relative location of the point in the unit cube
		double xo = x - Math.floor(x);
		double yo = y - Math.floor(y);
		double zo = z - Math.floor(z);
		// Fade curves for x, y and z
		double u = fade(xo);
		double v = fade(yo);
		double w = fade(zo);
		// Generate a hash for each coordinate to find out where in the cube
		// it lies.
		int a =  p_imp[uc_x] + uc_y;
		int aa = p_imp[a] + uc_z;
		int ab = p_imp[a + 1] + uc_z;
		int b =  p_imp[uc_x + 1] + uc_y;
		int ba = p_imp[b] + uc_z;
		int bb = p_imp[b + 1] + uc_z;
		// blend results from the 8 corners based on the noise function
		double c1 = grad(p_imp[aa], xo, yo, zo);
		double c2 = grad(p_imp[ba], xo - 1, yo, zo);
		double c3 = grad(p_imp[ab], xo, yo - 1, zo);
		double c4 = grad(p_imp[bb], xo - 1, yo - 1, zo);
		double c5 = grad(p_imp[aa + 1], xo, yo, zo - 1);
		double c6 = grad(p_imp[ba + 1], xo - 1, yo, zo - 1);
		double c7 = grad(p_imp[ab + 1], xo, yo - 1, zo - 1);
		double c8 = grad(p_imp[bb + 1], xo - 1, yo - 1, zo - 1);
		return lerp(w, lerp(v, lerp(u, c1, c2), lerp(u, c3, c4)),
					   lerp(v, lerp(u, c5, c6), lerp(u, c7, c8)));
	}
	/**
	 * 1-D noise generation function using the original perlin algorithm.
	 *
	 * @param x Seed for the noise function
	 * @return The noisy output
	 */
	public float noise1(float x)
	{
		float t = x + N;
		int bx0 = ((int) t) & BM;
		int bx1 = (bx0 + 1) & BM;
		float rx0 = t - (int) t;
		float rx1 = rx0 - 1;
		float sx = sCurve(rx0);
		float u = rx0 * g1[p[bx0]];
		float v = rx1 * g1[p[bx1]];
		return lerp(sx, u, v);
	}
	/**
	 * Create noise in a 2D space using the orignal perlin noise algorithm.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @return A noisy value at the given position
	 */
	public float noise2(float x, float y)
	{
		float t = x + N;
		int bx0 = ((int)t) & BM;
		int bx1 = (bx0 + 1) & BM;
		float rx0 = t - (int)t;
		float rx1 = rx0 - 1;
		t = y + N;
		int by0 = ((int)t) & BM;
		int by1 = (by0 + 1) & BM;
		float ry0 = t - (int)t;
		float ry1 = ry0 - 1;
		int i = p[bx0];
		int j = p[bx1];
		int b00 = p[i + by0];
		int b10 = p[j + by0];
		int b01 = p[i + by1];
		int b11 = p[j + by1];
		float sx = sCurve(rx0);
		float sy = sCurve(ry0);
		float[] q = g2[b00];
		float u = rx0 * q[0] + ry0 * q[1];
		q = g2[b10];
		float v = rx1 * q[0] + ry0 * q[1];
		float a = lerp(sx, u, v);
		q = g2[b01];
		u = rx0 * q[0] + ry1 * q[1];
		q = g2[b11];
		v = rx1 * q[0] + ry1 * q[1];
		float b = lerp(sx, u, v);
		return lerp(sy, a, b);
	}
	/**
	 * Create noise in a 3D space using the orignal perlin noise algorithm.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param z The Z coordinate of the location to sample
	 * @return A noisy value at the given position
	 */
	public float noise3(float x, float y, float z)
	{
	 float t = x + (float)N;
		int bx0 = ((int)t) & BM;
		int bx1 = (bx0 + 1) & BM;
		float rx0 = (float)(t - (int)t);
		float rx1 = rx0 - 1;
		t = y + (float)N;
		int by0 = ((int)t) & BM;
		int by1 = (by0 + 1) & BM;
		float ry0 = (float)(t - (int)t);
		float ry1 = ry0 - 1;
		t = z + (float)N;
		int bz0 = ((int)t) & BM;
		int bz1 = (bz0 + 1) & BM;
		float rz0 = (float)(t - (int)t);
		float rz1 = rz0 - 1;
		int i = p[bx0];
		int j = p[bx1];
		int b00 = p[i + by0];
		int b10 = p[j + by0];
		int b01 = p[i + by1];
		int b11 = p[j + by1];
		t  = sCurve(rx0);
		float sy = sCurve(ry0);
		float sz = sCurve(rz0);
		float[] q = g3[b00 + bz0];
		float u = (rx0 * q[0] + ry0 * q[1] + rz0 * q[2]);
		q = g3[b10 + bz0];
		float v = (rx1 * q[0] + ry0 * q[1] + rz0 * q[2]);
		float a = lerp(t, u, v);
		q = g3[b01 + bz0];
		u = (rx0 * q[0] + ry1 * q[1] + rz0 * q[2]);
		q = g3[b11 + bz0];
		v = (rx1 * q[0] + ry1 * q[1] + rz0 * q[2]);
		float b = lerp(t, u, v);
		float c = lerp(sy, a, b);
		q = g3[b00 + bz1];
		u = (rx0 * q[0] + ry0 * q[1] + rz1 * q[2]);
		q = g3[b10 + bz1];
		v = (rx1 * q[0] + ry0 * q[1] + rz1 * q[2]);
		a = lerp(t, u, v);
		q = g3[b01 + bz1];
		u = (rx0 * q[0] + ry1 * q[1] + rz1 * q[2]);
		q = g3[b11 + bz1];
		v = (rx1 * q[0] + ry1 * q[1] + rz1 * q[2]);
		b = lerp(t, u, v);
		float d = lerp(sy, a, b);
		return lerp(sz, c, d);
	}
	/**
	 * Create a turbulent noise output based on the core noise function. This
	 * uses the noise as a base function and is suitable for creating clouds,
	 * marble and explosion effects. For example, a typical marble effect would
	 * set the colour to be:
	 * <pre>
	 *	sin(point + turbulence(point) * point.x);
	 * </pre>
	 */
	public double imporvedTurbulence(double x,
									 double y,
									 double z,
									 float loF,
									 float hiF)
	{
		double p_x = x + 123.456f;
		double p_y = y;
		double p_z = z;
		double t = 0;
		double f;
		for(f = loF; f < hiF; f *= 2)
		{
			t += Math.abs(improvedNoise(p_x, p_y, p_z)) / f;
			p_x *= 2;
			p_y *= 2;
			p_z *= 2;
		}
		return t - 0.3;
	}
	/**
	 * Create a turbulance function in 2D using the original perlin noise
	 * function.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param freq The frequency of the turbluance to create
	 * @return The value at the given coordinates
	 */
	public float turbulence2(float x, float y, float freq)
	{
		float t = 0;
		do
		{
			t += noise2(freq * x, freq * y) / freq;
			freq *= 0.5f;
		}
		while (freq >= 1);
		return t;
	}
	/**
	 * Create a turbulance function in 3D using the original perlin noise
	 * function.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param z The Z coordinate of the location to sample
	 * @param freq The frequency of the turbluance to create
	 * @return The value at the given coordinates
	 */
	public float turbulence3(float x, float y, float z, float freq)
	{
		float t = 0;
		do
		{
			t += noise3(freq * x, freq * y, freq * z) / freq;
			freq *= 0.5f;
		}
		while (freq >= 1);
		return t;
	}
	/**
	 * Create a 1D tileable noise function for the given width.
	 *
	 * @param x The X coordinate to generate the noise for
	 * @param w The width of the tiled block
	 * @return The value of the noise at the given coordinate
	 */
	public float tileableNoise1(float x, float w)
	{
		return (noise1(x)	 * (w - x) +
				noise1(x - w) *	  x) / w;
	}
	/**
	 * Create a 2D tileable noise function for the given width and height.
	 *
	 * @param x The X coordinate to generate the noise for
	 * @param y The Y coordinate to generate the noise for
	 * @param w The width of the tiled block
	 * @param h The height of the tiled block
	 * @return The value of the noise at the given coordinate
	 */
	public float tileableNoise2(float x, float y, float w, float h)
	{
		return (noise2(x,	 y)	 * (w - x) * (h - y) +
				noise2(x - w, y)	 *	  x  * (h - y) +
				noise2(x,	 y - h) * (w - x) *	  y  +
				noise2(x - w, y - h) *	  x  *	  y) / (w * h);
	}
	/**
	 * Create a 3D tileable noise function for the given width, height and
	 * depth.
	 *
	 * @param x The X coordinate to generate the noise for
	 * @param y The Y coordinate to generate the noise for
	 * @param z The Z coordinate to generate the noise for
	 * @param w The width of the tiled block
	 * @param h The height of the tiled block
	 * @param d The depth of the tiled block
	 * @return The value of the noise at the given coordinate
	 */
	public float tileableNoise3(float x,
								float y,
								float z,
								float w,
								float h,
								float d)
	{
		return (noise3(x,	 y,	 z)	 * (w - x) * (h - y) * (d - z) +
				noise3(x - w, y,	 z)	 *	  x  * (h - y) * (d - z) +
				noise3(x,	 y - h, z)	 * (w - x) *	  y  * (d - z) +
				noise3(x - w, y - h, z)	 *	  x  *	  y  * (d - z) +
				noise3(x,	 y,	 z - d) * (w - x) * (h - y) *	  z  +
				noise3(x - w, y,	 z - d) *	  x  * (h - y) *	  z  +
				noise3(x,	 y - h, z - d) * (w - x) *	  y  *	  z  +
				noise3(x - w, y - h, z - d) *	  x  *	  y  *	  z) /
				(w * h * d);
	}
	/**
	 * Create a turbulance function that can be tiled across a surface in 2D.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param w The width to tile over
	 * @param h The height to tile over
	 * @param freq The frequency of the turbluance to create
	 * @return The value at the given coordinates
	 */
	public float tileableTurbulence2(float x,
									 float y,
									 float w,
									 float h,
									 float freq)
	{
		float t = 0;
		do
		{
			t += tileableNoise2(freq * x, freq * y, w * freq, h * freq) / freq;
			freq *= 0.5f;
		}
		while (freq >= 1);
		return t;
	}
	/**
	 * Create a turbulance function that can be tiled across a surface in 3D.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param z The Z coordinate of the location to sample
	 * @param w The width to tile over
	 * @param h The height to tile over
	 * @param d The depth to tile over
	 * @param freq The frequency of the turbluance to create
	 * @return The value at the given coordinates
	 */
	public float tileableTurbulence3(float x,
									 float y,
									 float z,
									 float w,
									 float h,
									 float d,
									 float freq)
	{
		float t = 0;
		do
		{
			t += tileableNoise3(freq * x,
								freq * y,
								freq * z,
								w * freq,
								h * freq,
								d * freq) / freq;
			freq *= 0.5f;
		}
		while (freq >= 1);
		return t;
	}

	/**
	 * Simple lerp function using doubles.
	 */
	private double lerp(double t, double a, double b)
	{
		return a + t * (b - a);
	}
	/**
	 * Simple lerp function using floats.
	 */
	private float lerp(float t, float a, float b)
	{
		return a + t * (b - a);
	}
	/**
	 * Fade curve calculation which is 6t^5 - 15t^4 + 10t^3. This is the new
	 * algorithm, where the old one used to be 3t^2 - 2t^3.
	 *
	 * @param t The t parameter to calculate the fade for
	 * @return the drop-off amount.
	 */
	private double fade(double t)
	{
		return t * t * t * (t * (t * 6 - 15) + 10);
	}
	/**
	 * Calculate the gradient function based on the hash code.
	 */
	private double grad(int hash, double x, double y, double z)
	{
		// Convert low 4 bits of hash code into 12 gradient directions.
		int h = hash & 15;
		double u = (h < 8 || h == 12 || h == 13) ? x : y;
		double v = (h < 4 || h == 12 || h == 13) ? y : z;
		return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
	}
	/**
	 * Simple bias generator using exponents.
	 */
	private float bias(float a, float b)
	{
		return (float)Math.pow(a, Math.log(b) / LOG_HALF);
	}

	/*
	 * Gain generator that caps to the range of [0, 1].
	 */
	private float gain(float a, float b)
	{
		if(a < 0.001f)
			return 0;
		else if (a > 0.999f)
			return 1.0f;
		double p = Math.log(1.0f - b) / LOG_HALF;
		if(a < 0.5f)
			return (float)(Math.pow(2 * a, p) / 2);
		else
			return 1 - (float)(Math.pow(2 * (1.0f - a), p) / 2);
	}
	/**
	 * S-curve function for value distribution for Perlin-1 noise function.
	 */
	private float sCurve(float t)
	{
		return (t * t * (3 - 2 * t));
	}
	/**
	 * 2D-vector normalisation function.
	 */
	private void normalize2(float[] v)
	{
		float s = (float)(1 / Math.sqrt(v[0] * v[0] + v[1] * v[1]));
		v[0] *= s;
		v[1] *= s;
	}
	/**
	 * 3D-vector normalisation function.
	 */
	private void normalize3(float[] v)
	{
		float s = (float)(1 / Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]));
		v[0] *= s;
		v[1] *= s;
		v[2] *= s;
	}
	/**
	 * Initialise the lookup arrays used by Perlin 1 function.
	 */
	private void initPerlin1()
	{
		p = new int[B + B + 2];
		g3 = new float[B + B + 2][3];
		g2 = new float[B + B + 2][2];
		g1 = new float[B + B + 2];
		int i, j, k;
		for(i = 0; i < B; i++)
		{
			p[i] = i;
			g1[i] = (float)(((Math.random() * Integer.MAX_VALUE) % (B + B)) - B) / B;
			for(j = 0; j < 2; j++)
				g2[i][j] = (float)(((Math.random() * Integer.MAX_VALUE) % (B + B)) - B) / B;
			normalize2(g2[i]);
			for(j = 0; j < 3; j++)
				g3[i][j] = (float)(((Math.random() * Integer.MAX_VALUE) % (B + B)) - B) / B;
			normalize3(g3[i]);
		}
		while(--i > 0)
		{
			k = p[i];
			j = (int)((Math.random() * Integer.MAX_VALUE) % B);
			p[i] = p[j];
			p[j] = k;
		}
		for(i = 0; i < B + 2; i++)
		{
			p[B + i] = p[i];
			g1[B + i] = g1[i];
			for(j = 0; j < 2; j++)
				g2[B + i][j] = g2[i][j];
			for(j = 0; j < 3; j++)
				g3[B + i][j] = g3[i][j];
		}
	}
}


My current implementation.
public void initChunk(PerlinNoiseGenerator png) {
	  
		for (int x = 0; x < 16; x++) {
			for (int z = 0; z < 16; z++) {
				for (int y = 0; y < 256; y++) {
					double noise = ImprovedNoise.noise(x*0.4, y*0.4, z*0.4);
					//log(noise);
					if (noise < 0) noise = -noise;
					if (noise >0.5) chunkVoxels[x][y][z] = new VoxelRef(x + xPos, y, z + zPos, 1, 1, 1, 1);
				}
			}
		}
}

#1Matthewj234

Posted 03 August 2012 - 03:54 PM

Hey guys, I have been frustrated all day on this issue....

I have been using this code to try and generate a 3D environment. My issue... Everything I try with this just ends up with a massive number of random blocks, with no clear placement. The examples I have seen on youtube and elsewhere have shown a coherent noise generation which is procedural. So my question is this, how would I be able to use the code below, to allow me to generate a 3D environment?

Also, why does this only accept [-1,1]?

Thanks in advance for any help offered.

/*****************************************************************************
*					    J3D.org Copyright (c) 2000
*							   Java Source
*
* This source is licensed under the GNU LGPL v2.1
* Please read http://www.gnu.org/copyleft/lgpl.html for more information
*
* This software comes with the standard NO WARRANTY disclaimer for any
* purpose. Use it at your own risk. If there's a problem you get to fix it.
*
****************************************************************************/
package com.Sparked_Studios.Tile_Engine.ContentGenerators;
import java.util.Random;
/**
* Computes Perlin Noise for three dimensions.
* <p>
*
* The result is a continuous function that interpolates a smooth path
* along a series random points. The function is consitent, so given
* the same parameters, it will always return the same value. The smoothing
* function is based on the Improving Noise paper presented at Siggraph 2002.
* <p>
* Computing noise for one and two dimensions can make use of the 3D problem
* space by just setting the un-needed dimensions to a fixed value.
*
* @author Justin Couch
* @version $Revision: 1.4 $
*/
public class PerlinNoiseGenerator
{
    // Constants for setting up the Perlin-1 noise functions
    private static final int B = 0x1000;
    private static final int BM = 0xff;
    private static final int N = 0x1000;
    private static final int NP = 12;   /* 2^N */
    private static final int NM = 0xfff;
    /** Default seed to use for the random number generation */
    private static final int DEFAULT_SEED = 100;
    /** Default sample size to work with */
    private static final int DEFAULT_SAMPLE_SIZE = 256;
    /** The log of 1/2 constant. Used Everywhere */
    private static final float LOG_HALF = (float)Math.log(0.5);
    /** Permutation array for the improved noise function */
    private int[] p_imp;
    /** P array for perline 1 noise */
    private int[] p;
    private float[][] g3;
    private float[][] g2;
    private float[] g1;

    /**
	 * Create a new noise creator with the default seed value
	 */
    public PerlinNoiseGenerator()
    {
	    this(DEFAULT_SEED);
    }
    /**
	 * Create a new noise creator with the given seed value for the randomness
	 *
	 * @param seed The seed value to use
	 */
    public PerlinNoiseGenerator(int seed)
    {
	    p_imp = new int[DEFAULT_SAMPLE_SIZE << 1];
	    int i, j, k;
	    Random rand = new Random(seed);
	    // Calculate the table of psuedo-random coefficients.
	    for(i = 0; i < DEFAULT_SAMPLE_SIZE; i++)
		    p_imp[i] = i;
	    // generate the psuedo-random permutation table.
	    while(--i > 0)
	    {
		    k = p_imp[i];
		    j = (int)(rand.nextLong() & DEFAULT_SAMPLE_SIZE);
		    p_imp[i] = p_imp[j];
		    p_imp[j] = k;
	    }
	    initPerlin1();
    }
    /**
	 * Computes noise function for three dimensions at the point (x,y,z).
	 *
	 * @param x x dimension parameter
	 * @param y y dimension parameter
	 * @param z z dimension parameter
	 * @return the noise value at the point (x, y, z)
	 */
    public double improvedNoise(double x, double y, double z)
    {
	    // Constraint the point to a unit cube
	    int uc_x = (int)Math.floor(x) & 255;
	    int uc_y = (int)Math.floor(y) & 255;
	    int uc_z = (int)Math.floor(z) & 255;
	    // Relative location of the point in the unit cube
	    double xo = x - Math.floor(x);
	    double yo = y - Math.floor(y);
	    double zo = z - Math.floor(z);
	    // Fade curves for x, y and z
	    double u = fade(xo);
	    double v = fade(yo);
	    double w = fade(zo);
	    // Generate a hash for each coordinate to find out where in the cube
	    // it lies.
	    int a =  p_imp[uc_x] + uc_y;
	    int aa = p_imp[a] + uc_z;
	    int ab = p_imp[a + 1] + uc_z;
	    int b =  p_imp[uc_x + 1] + uc_y;
	    int ba = p_imp[b] + uc_z;
	    int bb = p_imp[b + 1] + uc_z;
	    // blend results from the 8 corners based on the noise function
	    double c1 = grad(p_imp[aa], xo, yo, zo);
	    double c2 = grad(p_imp[ba], xo - 1, yo, zo);
	    double c3 = grad(p_imp[ab], xo, yo - 1, zo);
	    double c4 = grad(p_imp[bb], xo - 1, yo - 1, zo);
	    double c5 = grad(p_imp[aa + 1], xo, yo, zo - 1);
	    double c6 = grad(p_imp[ba + 1], xo - 1, yo, zo - 1);
	    double c7 = grad(p_imp[ab + 1], xo, yo - 1, zo - 1);
	    double c8 = grad(p_imp[bb + 1], xo - 1, yo - 1, zo - 1);
	    return lerp(w, lerp(v, lerp(u, c1, c2), lerp(u, c3, c4)),
					   lerp(v, lerp(u, c5, c6), lerp(u, c7, c8)));
    }
    /**
	 * 1-D noise generation function using the original perlin algorithm.
	 *
	 * @param x Seed for the noise function
	 * @return The noisy output
	 */
    public float noise1(float x)
    {
	    float t = x + N;
	    int bx0 = ((int) t) & BM;
	    int bx1 = (bx0 + 1) & BM;
	    float rx0 = t - (int) t;
	    float rx1 = rx0 - 1;
	    float sx = sCurve(rx0);
	    float u = rx0 * g1[p[bx0]];
	    float v = rx1 * g1[p[bx1]];
	    return lerp(sx, u, v);
    }
    /**
	 * Create noise in a 2D space using the orignal perlin noise algorithm.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @return A noisy value at the given position
	 */
    public float noise2(float x, float y)
    {
	    float t = x + N;
	    int bx0 = ((int)t) & BM;
	    int bx1 = (bx0 + 1) & BM;
	    float rx0 = t - (int)t;
	    float rx1 = rx0 - 1;
	    t = y + N;
	    int by0 = ((int)t) & BM;
	    int by1 = (by0 + 1) & BM;
	    float ry0 = t - (int)t;
	    float ry1 = ry0 - 1;
	    int i = p[bx0];
	    int j = p[bx1];
	    int b00 = p[i + by0];
	    int b10 = p[j + by0];
	    int b01 = p[i + by1];
	    int b11 = p[j + by1];
	    float sx = sCurve(rx0);
	    float sy = sCurve(ry0);
	    float[] q = g2[b00];
	    float u = rx0 * q[0] + ry0 * q[1];
	    q = g2[b10];
	    float v = rx1 * q[0] + ry0 * q[1];
	    float a = lerp(sx, u, v);
	    q = g2[b01];
	    u = rx0 * q[0] + ry1 * q[1];
	    q = g2[b11];
	    v = rx1 * q[0] + ry1 * q[1];
	    float b = lerp(sx, u, v);
	    return lerp(sy, a, b);
    }
    /**
	 * Create noise in a 3D space using the orignal perlin noise algorithm.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param z The Z coordinate of the location to sample
	 * @return A noisy value at the given position
	 */
    public float noise3(float x, float y, float z)
    {
	 float t = x + (float)N;
	    int bx0 = ((int)t) & BM;
	    int bx1 = (bx0 + 1) & BM;
	    float rx0 = (float)(t - (int)t);
	    float rx1 = rx0 - 1;
	    t = y + (float)N;
	    int by0 = ((int)t) & BM;
	    int by1 = (by0 + 1) & BM;
	    float ry0 = (float)(t - (int)t);
	    float ry1 = ry0 - 1;
	    t = z + (float)N;
	    int bz0 = ((int)t) & BM;
	    int bz1 = (bz0 + 1) & BM;
	    float rz0 = (float)(t - (int)t);
	    float rz1 = rz0 - 1;
	    int i = p[bx0];
	    int j = p[bx1];
	    int b00 = p[i + by0];
	    int b10 = p[j + by0];
	    int b01 = p[i + by1];
	    int b11 = p[j + by1];
	    t  = sCurve(rx0);
	    float sy = sCurve(ry0);
	    float sz = sCurve(rz0);
	    float[] q = g3[b00 + bz0];
	    float u = (rx0 * q[0] + ry0 * q[1] + rz0 * q[2]);
	    q = g3[b10 + bz0];
	    float v = (rx1 * q[0] + ry0 * q[1] + rz0 * q[2]);
	    float a = lerp(t, u, v);
	    q = g3[b01 + bz0];
	    u = (rx0 * q[0] + ry1 * q[1] + rz0 * q[2]);
	    q = g3[b11 + bz0];
	    v = (rx1 * q[0] + ry1 * q[1] + rz0 * q[2]);
	    float b = lerp(t, u, v);
	    float c = lerp(sy, a, b);
	    q = g3[b00 + bz1];
	    u = (rx0 * q[0] + ry0 * q[1] + rz1 * q[2]);
	    q = g3[b10 + bz1];
	    v = (rx1 * q[0] + ry0 * q[1] + rz1 * q[2]);
	    a = lerp(t, u, v);
	    q = g3[b01 + bz1];
	    u = (rx0 * q[0] + ry1 * q[1] + rz1 * q[2]);
	    q = g3[b11 + bz1];
	    v = (rx1 * q[0] + ry1 * q[1] + rz1 * q[2]);
	    b = lerp(t, u, v);
	    float d = lerp(sy, a, b);
	    return lerp(sz, c, d);
    }
    /**
	 * Create a turbulent noise output based on the core noise function. This
	 * uses the noise as a base function and is suitable for creating clouds,
	 * marble and explosion effects. For example, a typical marble effect would
	 * set the colour to be:
	 * <pre>
	 *    sin(point + turbulence(point) * point.x);
	 * </pre>
	 */
    public double imporvedTurbulence(double x,
									 double y,
									 double z,
									 float loF,
									 float hiF)
    {
	    double p_x = x + 123.456f;
	    double p_y = y;
	    double p_z = z;
	    double t = 0;
	    double f;
	    for(f = loF; f < hiF; f *= 2)
	    {
		    t += Math.abs(improvedNoise(p_x, p_y, p_z)) / f;
		    p_x *= 2;
		    p_y *= 2;
		    p_z *= 2;
	    }
	    return t - 0.3;
    }
    /**
	 * Create a turbulance function in 2D using the original perlin noise
	 * function.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param freq The frequency of the turbluance to create
	 * @return The value at the given coordinates
	 */
    public float turbulence2(float x, float y, float freq)
    {
	    float t = 0;
	    do
	    {
		    t += noise2(freq * x, freq * y) / freq;
		    freq *= 0.5f;
	    }
	    while (freq >= 1);
	    return t;
    }
    /**
	 * Create a turbulance function in 3D using the original perlin noise
	 * function.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param z The Z coordinate of the location to sample
	 * @param freq The frequency of the turbluance to create
	 * @return The value at the given coordinates
	 */
    public float turbulence3(float x, float y, float z, float freq)
    {
	    float t = 0;
	    do
	    {
		    t += noise3(freq * x, freq * y, freq * z) / freq;
		    freq *= 0.5f;
	    }
	    while (freq >= 1);
	    return t;
    }
    /**
	 * Create a 1D tileable noise function for the given width.
	 *
	 * @param x The X coordinate to generate the noise for
	 * @param w The width of the tiled block
	 * @return The value of the noise at the given coordinate
	 */
    public float tileableNoise1(float x, float w)
    {
	    return (noise1(x)	 * (w - x) +
			    noise1(x - w) *	  x) / w;
    }
    /**
	 * Create a 2D tileable noise function for the given width and height.
	 *
	 * @param x The X coordinate to generate the noise for
	 * @param y The Y coordinate to generate the noise for
	 * @param w The width of the tiled block
	 * @param h The height of the tiled block
	 * @return The value of the noise at the given coordinate
	 */
    public float tileableNoise2(float x, float y, float w, float h)
    {
	    return (noise2(x,	 y)	 * (w - x) * (h - y) +
			    noise2(x - w, y)	 *	  x  * (h - y) +
			    noise2(x,	 y - h) * (w - x) *	  y  +
			    noise2(x - w, y - h) *	  x  *	  y) / (w * h);
    }
    /**
	 * Create a 3D tileable noise function for the given width, height and
	 * depth.
	 *
	 * @param x The X coordinate to generate the noise for
	 * @param y The Y coordinate to generate the noise for
	 * @param z The Z coordinate to generate the noise for
	 * @param w The width of the tiled block
	 * @param h The height of the tiled block
	 * @param d The depth of the tiled block
	 * @return The value of the noise at the given coordinate
	 */
    public float tileableNoise3(float x,
							    float y,
							    float z,
							    float w,
							    float h,
							    float d)
    {
	    return (noise3(x,	 y,	 z)	 * (w - x) * (h - y) * (d - z) +
			    noise3(x - w, y,	 z)	 *	  x  * (h - y) * (d - z) +
			    noise3(x,	 y - h, z)	 * (w - x) *	  y  * (d - z) +
			    noise3(x - w, y - h, z)	 *	  x  *	  y  * (d - z) +
			    noise3(x,	 y,	 z - d) * (w - x) * (h - y) *	  z  +
			    noise3(x - w, y,	 z - d) *	  x  * (h - y) *	  z  +
			    noise3(x,	 y - h, z - d) * (w - x) *	  y  *	  z  +
			    noise3(x - w, y - h, z - d) *	  x  *	  y  *	  z) /
			    (w * h * d);
    }
    /**
	 * Create a turbulance function that can be tiled across a surface in 2D.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param w The width to tile over
	 * @param h The height to tile over
	 * @param freq The frequency of the turbluance to create
	 * @return The value at the given coordinates
	 */
    public float tileableTurbulence2(float x,
									 float y,
									 float w,
									 float h,
									 float freq)
    {
	    float t = 0;
	    do
	    {
		    t += tileableNoise2(freq * x, freq * y, w * freq, h * freq) / freq;
		    freq *= 0.5f;
	    }
	    while (freq >= 1);
	    return t;
    }
    /**
	 * Create a turbulance function that can be tiled across a surface in 3D.
	 *
	 * @param x The X coordinate of the location to sample
	 * @param y The Y coordinate of the location to sample
	 * @param z The Z coordinate of the location to sample
	 * @param w The width to tile over
	 * @param h The height to tile over
	 * @param d The depth to tile over
	 * @param freq The frequency of the turbluance to create
	 * @return The value at the given coordinates
	 */
    public float tileableTurbulence3(float x,
									 float y,
									 float z,
									 float w,
									 float h,
									 float d,
									 float freq)
    {
	    float t = 0;
	    do
	    {
		    t += tileableNoise3(freq * x,
							    freq * y,
							    freq * z,
							    w * freq,
							    h * freq,
							    d * freq) / freq;
		    freq *= 0.5f;
	    }
	    while (freq >= 1);
	    return t;
    }

    /**
	 * Simple lerp function using doubles.
	 */
    private double lerp(double t, double a, double b)
    {
	    return a + t * (b - a);
    }
    /**
	 * Simple lerp function using floats.
	 */
    private float lerp(float t, float a, float b)
    {
	    return a + t * (b - a);
    }
    /**
	 * Fade curve calculation which is 6t^5 - 15t^4 + 10t^3. This is the new
	 * algorithm, where the old one used to be 3t^2 - 2t^3.
	 *
	 * @param t The t parameter to calculate the fade for
	 * @return the drop-off amount.
	 */
    private double fade(double t)
    {
	    return t * t * t * (t * (t * 6 - 15) + 10);
    }
    /**
	 * Calculate the gradient function based on the hash code.
	 */
    private double grad(int hash, double x, double y, double z)
    {
	    // Convert low 4 bits of hash code into 12 gradient directions.
	    int h = hash & 15;
	    double u = (h < 8 || h == 12 || h == 13) ? x : y;
	    double v = (h < 4 || h == 12 || h == 13) ? y : z;
	    return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
    }
    /**
	 * Simple bias generator using exponents.
	 */
    private float bias(float a, float b)
    {
	    return (float)Math.pow(a, Math.log(b) / LOG_HALF);
    }

    /*
	 * Gain generator that caps to the range of [0, 1].
	 */
    private float gain(float a, float b)
    {
	    if(a < 0.001f)
		    return 0;
	    else if (a > 0.999f)
		    return 1.0f;
	    double p = Math.log(1.0f - b) / LOG_HALF;
	    if(a < 0.5f)
		    return (float)(Math.pow(2 * a, p) / 2);
	    else
		    return 1 - (float)(Math.pow(2 * (1.0f - a), p) / 2);
    }
    /**
	 * S-curve function for value distribution for Perlin-1 noise function.
	 */
    private float sCurve(float t)
    {
	    return (t * t * (3 - 2 * t));
    }
    /**
	 * 2D-vector normalisation function.
	 */
    private void normalize2(float[] v)
    {
	    float s = (float)(1 / Math.sqrt(v[0] * v[0] + v[1] * v[1]));
	    v[0] *= s;
	    v[1] *= s;
    }
    /**
	 * 3D-vector normalisation function.
	 */
    private void normalize3(float[] v)
    {
	    float s = (float)(1 / Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]));
	    v[0] *= s;
	    v[1] *= s;
	    v[2] *= s;
    }
    /**
	 * Initialise the lookup arrays used by Perlin 1 function.
	 */
    private void initPerlin1()
    {
	    p = new int[B + B + 2];
	    g3 = new float[B + B + 2][3];
	    g2 = new float[B + B + 2][2];
	    g1 = new float[B + B + 2];
	    int i, j, k;
	    for(i = 0; i < B; i++)
	    {
		    p[i] = i;
		    g1[i] = (float)(((Math.random() * Integer.MAX_VALUE) % (B + B)) - B) / B;
		    for(j = 0; j < 2; j++)
			    g2[i][j] = (float)(((Math.random() * Integer.MAX_VALUE) % (B + B)) - B) / B;
		    normalize2(g2[i]);
		    for(j = 0; j < 3; j++)
			    g3[i][j] = (float)(((Math.random() * Integer.MAX_VALUE) % (B + B)) - B) / B;
		    normalize3(g3[i]);
	    }
	    while(--i > 0)
	    {
		    k = p[i];
		    j = (int)((Math.random() * Integer.MAX_VALUE) % B);
		    p[i] = p[j];
		    p[j] = k;
	    }
	    for(i = 0; i < B + 2; i++)
	    {
		    p[B + i] = p[i];
		    g1[B + i] = g1[i];
		    for(j = 0; j < 2; j++)
			    g2[B + i][j] = g2[i][j];
		    for(j = 0; j < 3; j++)
			    g3[B + i][j] = g3[i][j];
	    }
    }
}


My current implementation.

public void initChunk(PerlinNoiseGenerator png) {

for (int x = 0; x < 16; x++) {
for (int z = 0; z < 16; z++) {
for (int y = 0; y < 256; y++) {
double noise = ImprovedNoise.noise(x*0.4, y*0.4, z*0.4);
//log(noise);
if (noise < 0) noise = -noise;
if (noise >0.5) chunkVoxels[x][y][z] = new VoxelRef(x + xPos, y, z + zPos, 1, 1, 1, 1);
}
}
}
}

PARTNERS