Noise Class Reference

Public Member Functions
	getNoise2D ($x, $z)
	getNoise3D ($x, $y, $z)
	noise2D ($x, $z, $normalized=false)
	noise3D ($x, $y, $z, $normalized=false)
	setOffset ($x, $y, $z)

Static Public Member Functions
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
	$perm = []
	$offsetX = 0
	$offsetY = 0
	$offsetZ = 0
	$octaves = 8
	$persistence
	$expansion

Member Function Documentation

bilinearLerp()

static bilinearLerp (   $x,   $y,   $q00,   $q01,   $q10,   $q11,   $x1,   $x2,   $y1,   $y2  )

static

Parameters

$x
$y
$q00
$q01
$q10
$q11
$x1
$x2
$y1
$y2

Returns

float|int

                                                                                           {
        $dx1 = (($x2 - $x) / ($x2 - $x1));
        $dx2 = (($x - $x1) / ($x2 - $x1));

        return (($y2 - $y) / ($y2 - $y1)) * (
                $dx1 * $q00 + $dx2 * $q10
            ) + (($y - $y1) / ($y2 - $y1)) * (
                $dx1 * $q01 + $dx2 * $q11
            );
    }

fade()

static fade (   $x )

static

Parameters

$x

Returns

mixed

                                   {
        return $x * $x * $x * ($x * ($x * 6 - 15) + 10);
    }

floor()

static floor (   $x )

static

Parameters

$x

Returns

int

                                    {
        return $x >= 0 ? (int) $x : (int) ($x - 1);
    }

getNoise2D()

getNoise2D (   $x,   $z  )

abstract

Parameters

$x
$z

Returns

mixed

getNoise3D()

getNoise3D (   $x,   $y,   $z  )

abstract

Parameters

$x
$y
$z

Returns

mixed

grad()

static grad (   $hash,   $x,   $y,   $z  )

static

Parameters

$hash
$x
$y
$z

Returns

mixed

                                                  {
        $hash &= 15;
        $u = $hash < 8 ? $x : $y;
        $v = $hash < 4 ? $y : (($hash === 12 or $hash === 14) ? $x : $z);

        return (($hash & 1) === 0 ? $u : -$u) + (($hash & 2) === 0 ? $v : -$v);
    }

lerp()

static lerp (   $x,   $y,   $z  )

static

Parameters

$x
$y
$z

Returns

mixed

                                           {
        return $y + $x * ($z - $y);
    }

linearLerp()

static linearLerp (   $x,   $x1,   $x2,   $q0,   $q1  )

static

Parameters

$x
$x1
$x2
$q0
$q1

Returns

float|int

                                                             {
        return (($x2 - $x) / ($x2 - $x1)) * $q0 + (($x - $x1) / ($x2 - $x1)) * $q1;
    }

noise2D()

noise2D	(		$x,
			$z,
			$normalized = false
	)

Parameters

	$x
	$z
bool	$normalized

Returns

int

                                                        {
        $result = 0;
        $amp = 1;
        $freq = 1;
        $max = 0;

        $x *= $this->expansion;
        $z *= $this->expansion;

        for($i = 0; $i < $this->octaves; ++$i){
            $result += $this->getNoise2D($x * $freq, $z * $freq) * $amp;
            $max += $amp;
            $freq *= 2;
            $amp *= $this->persistence;
        }

        if($normalized === true){
            $result /= $max;
        }

        return $result;
    }

noise3D()

noise3D	(		$x,
			$y,
			$z,
			$normalized = false
	)

Parameters

	$x
	$y
	$z
bool	$normalized

Returns

int

                                                            {
        $result = 0;
        $amp = 1;
        $freq = 1;
        $max = 0;

        $x *= $this->expansion;
        $y *= $this->expansion;
        $z *= $this->expansion;

        for($i = 0; $i < $this->octaves; ++$i){
            $result += $this->getNoise3D($x * $freq, $y * $freq, $z * $freq) * $amp;
            $max += $amp;
            $freq *= 2;
            $amp *= $this->persistence;
        }

        if($normalized === true){
            $result /= $max;
        }

        return $result;
    }

setOffset()

setOffset	(		$x,
			$y,
			$z
	)

Parameters

$x
$y
$z

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

trilinearLerp()

static trilinearLerp (   $x,   $y,   $z,   $q000,   $q001,   $q010,   $q011,   $q100,   $q101,   $q110,   $q111,   $x1,   $x2,   $y1,   $y2,   $z1,   $z2  )

static

Parameters

$x
$y
$z
$q000
$q001
$q010
$q011
$q100
$q101
$q110
$q111
$x1
$x2
$y1
$y2
$z1
$z2

Returns

float|int

                                                                                                                                          {
        $dx1 = (($x2 - $x) / ($x2 - $x1));
        $dx2 = (($x - $x1) / ($x2 - $x1));
        $dy1 = (($y2 - $y) / ($y2 - $y1));
        $dy2 = (($y - $y1) / ($y2 - $y1));

        return (($z2 - $z) / ($z2 - $z1)) * (
                $dy1 * (
                    $dx1 * $q000 + $dx2 * $q100
                ) + $dy2 * (
                    $dx1 * $q001 + $dx2 * $q101
                )
            ) + (($z - $z1) / ($z2 - $z1)) * (
                $dy1 * (
                    $dx1 * $q010 + $dx2 * $q110
                ) + $dy2 * (
                    $dx1 * $q011 + $dx2 * $q111
                )
            );
    }

Field Documentation

$expansion

$expansion

protected

$octaves

$octaves = 8

protected

$offsetX

$offsetX = 0

protected

$offsetY

$offsetY = 0

protected

$offsetZ

$offsetZ = 0

protected

$perm

$perm = []

protected

$persistence

$persistence

protected

---

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

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