Perlin Class Reference

Public Member Functions
	__construct (Random $random, $octaves, $persistence, $expansion=1)
	getNoise3D ($x, $y, $z)
	getNoise2D ($x, $y)
Public Member Functions inherited from Noise
	getNoise2D ($x, $z)
	getNoise3D ($x, $y, $z)
	noise2D ($x, $z, $normalized=false)
	noise3D ($x, $y, $z, $normalized=false)
	setOffset ($x, $y, $z)

Static Public Attributes
static	$grad3

Additional Inherited Members
Static Public Member Functions inherited from Noise
static	floor ($x)
static	fade ($x)
static	lerp ($x, $y, $z)
static	linearLerp ($x, $x1, $x2, $q0, $q1)
static	bilinearLerp ($x, $y, $q00, $q01, $q10, $q11, $x1, $x2, $y1, $y2)
static	trilinearLerp ($x, $y, $z, $q000, $q001, $q010, $q011, $q100, $q101, $q110, $q111, $x1, $x2, $y1, $y2, $z1, $z2)
static	grad ($hash, $x, $y, $z)
Protected Attributes inherited from Noise
	$perm = []
	$offsetX = 0
	$offsetY = 0
	$offsetZ = 0
	$octaves = 8
	$persistence
	$expansion

Constructor & Destructor Documentation

__construct()

__construct	(	Random	$random,
			$octaves,
			$persistence,
			$expansion = 1
	)

Perlin constructor.

Parameters

Random	$random
	$octaves
	$persistence
int	$expansion

                                                                                       {
        $this->octaves = $octaves;
        $this->persistence = $persistence;
        $this->expansion = $expansion;
        $this->offsetX = $random->nextFloat() * 256;
        $this->offsetY = $random->nextFloat() * 256;
        $this->offsetZ = $random->nextFloat() * 256;

        for($i = 0; $i < 512; ++$i){
            $this->perm[$i] = 0;
        }

        for($i = 0; $i < 256; ++$i){
            $this->perm[$i] = $random->nextBoundedInt(256);
        }

        for($i = 0; $i < 256; ++$i){
            $pos = $random->nextBoundedInt(256 - $i) + $i;
            $old = $this->perm[$i];

            $this->perm[$i] = $this->perm[$pos];
            $this->perm[$pos] = $old;
            $this->perm[$i + 256] = $this->perm[$i];
        }

    }

Member Function Documentation

getNoise2D()

getNoise2D	(		$x,
			$y
	)

Parameters

$x
$y

Returns

mixed

                                      {
        return $this->getNoise3D($x, $y, 0);
    }

getNoise3D()

getNoise3D	(		$x,
			$y,
			$z
	)

Parameters

$x
$y
$z

Returns

mixed

                                          {
        $x += $this->offsetX;
        $y += $this->offsetY;
        $z += $this->offsetZ;

        $floorX = (int) $x;
        $floorY = (int) $y;
        $floorZ = (int) $z;

        $X = $floorX & 0xFF;
        $Y = $floorY & 0xFF;
        $Z = $floorZ & 0xFF;

        $x -= $floorX;
        $y -= $floorY;
        $z -= $floorZ;

        //Fade curves
        //$fX = self::fade($x);
        //$fY = self::fade($y);
        //$fZ = self::fade($z);
        $fX = $x * $x * $x * ($x * ($x * 6 - 15) + 10);
        $fY = $y * $y * $y * ($y * ($y * 6 - 15) + 10);
        $fZ = $z * $z * $z * ($z * ($z * 6 - 15) + 10);

        //Cube corners
        $A = $this->perm[$X] + $Y;
        $B = $this->perm[$X + 1] + $Y;

        $AA = $this->perm[$A] + $Z;
        $AB = $this->perm[$A + 1] + $Z;
        $BA = $this->perm[$B] + $Z;
        $BB = $this->perm[$B + 1] + $Z;

        $AA1 = self::grad($this->perm[$AA], $x, $y, $z);
        $BA1 = self::grad($this->perm[$BA], $x - 1, $y, $z);
        $AB1 = self::grad($this->perm[$AB], $x, $y - 1, $z);
        $BB1 = self::grad($this->perm[$BB], $x - 1, $y - 1, $z);
        $AA2 = self::grad($this->perm[$AA + 1], $x, $y, $z - 1);
        $BA2 = self::grad($this->perm[$BA + 1], $x - 1, $y, $z - 1);
        $AB2 = self::grad($this->perm[$AB + 1], $x, $y - 1, $z - 1);
        $BB2 = self::grad($this->perm[$BB + 1], $x - 1, $y - 1, $z - 1);

        $xLerp11 = $AA1 + $fX * ($BA1 - $AA1);

        $zLerp1 = $xLerp11 + $fY * ($AB1 + $fX * ($BB1 - $AB1) - $xLerp11);

        $xLerp21 = $AA2 + $fX * ($BA2 - $AA2);

        return $zLerp1 + $fZ * ($xLerp21 + $fY * ($AB2 + $fX * ($BB2 - $AB2) - $xLerp21) - $zLerp1);

        /*
        return self::lerp(
            $fZ,
            self::lerp(
                $fY,
                self::lerp(
                    $fX,
                    self::grad($this->perm[$AA], $x, $y, $z),
                    self::grad($this->perm[$BA], $x - 1, $y, $z)
                ),
                self::lerp(
                    $fX,
                    self::grad($this->perm[$AB], $x, $y - 1, $z),
                    self::grad($this->perm[$BB], $x - 1, $y - 1, $z)
                )
            ),
            self::lerp(
                $fY,
                self::lerp(
                    $fX,
                    self::grad($this->perm[$AA + 1], $x, $y, $z - 1),
                    self::grad($this->perm[$BA + 1], $x - 1, $y, $z - 1)
                ),
                self::lerp(
                    $fX,
                    self::grad($this->perm[$AB + 1], $x, $y - 1, $z - 1),
                    self::grad($this->perm[$BB + 1], $x - 1, $y - 1, $z - 1)
                )
            )
        );
        */
    }

Field Documentation

$grad3

$grad3

static

Initial value:

= [
        [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]
    ]

---

The documentation for this class was generated from the following file:

• src/pocketmine/level/generator/noise/Perlin.php