noise

Documentation

Overview

Package noise provides several noise algorithms.

The Perlin and Simplex noise functions are adapted from "Simplex Noise Demystified": http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf by Stefan Gustavson (code in the public domain).

Index

• Variables
• func Gradient(a0 float32, n uint) []coord.XY
• func GradientFrom(a []float32) []coord.XY
• func Perlin3D(p coord.XYZ) float32
• func Simplex2D(p coord.XY, grad []coord.XY) float32
• func SimplexAxial(q, r float32, grad []coord.XY) float32

Examples

• Perlin3D

Variables

var Gradient12 = []coord.XY{
	coord.XY{0.0, 1.0}, coord.XY{sin60, cos60}, coord.XY{-sin60, cos60},
	coord.XY{1.0, 0.0}, coord.XY{sin30, cos30}, coord.XY{-sin30, cos30},
	coord.XY{0.0, -1.0}, coord.XY{-sin60, -cos60}, coord.XY{sin60, -cos60},
	coord.XY{-1.0, 0.0}, coord.XY{-sin30, -cos30}, coord.XY{sin30, -cos30},
}

var Gradient24 = []coord.XY{
	coord.XY{0.0, 1.0}, coord.XY{sin60, cos60}, coord.XY{-sin60, cos60},
	coord.XY{1.0, 0.0}, coord.XY{sin30, cos30}, coord.XY{-sin30, cos30},
	coord.XY{0.0, -1.0}, coord.XY{-sin60, -cos60}, coord.XY{sin60, -cos60},
	coord.XY{-1.0, 0.0}, coord.XY{-sin30, -cos30}, coord.XY{sin30, -cos30},
	coord.XY{sin15, cos15}, coord.XY{sin45, cos45}, coord.XY{sin75, cos75},
	coord.XY{-sin15, cos15}, coord.XY{-sin45, cos45}, coord.XY{-sin75, cos75},
	coord.XY{sin15, -cos15}, coord.XY{sin45, -cos45}, coord.XY{sin75, -cos75},
	coord.XY{-sin15, -cos15}, coord.XY{-sin45, -cos45}, coord.XY{-sin75, -cos75},
}

var Gradient3D = []coord.XYZ{
	coord.XYZ{X: +1, Y: +1, Z: 0}, coord.XYZ{X: -1, Y: +1, Z: 0}, coord.XYZ{X: +1, Y: -1, Z: 0}, coord.XYZ{X: -1, Y: -1, Z: 0},
	coord.XYZ{X: +1, Y: 0, Z: +1}, coord.XYZ{X: -1, Y: 0, Z: +1}, coord.XYZ{X: +1, Y: 0, Z: -1}, coord.XYZ{X: -1, Y: 0, Z: -1},
	coord.XYZ{X: 0, Y: +1, Z: +1}, coord.XYZ{X: 0, Y: -1, Z: +1}, coord.XYZ{X: 0, Y: +1, Z: -1}, coord.XYZ{X: 0, Y: -1, Z: -1},
}

var Gradient4 = []coord.XY{
	coord.XY{1.0, 0.0}, coord.XY{0.0, 1.0}, coord.XY{-1.0, 0.0}, coord.XY{0.0, -1.0},
}

var Gradient6 = []coord.XY{
	coord.XY{0.0, 1.0}, coord.XY{sin60, cos60}, coord.XY{-sin60, cos60},
	coord.XY{0.0, -1.0}, coord.XY{-sin60, -cos60}, coord.XY{sin60, -cos60},
}

var Gradient8 = []coord.XY{
	coord.XY{1.0, 0.0}, coord.XY{0.0, 1.0}, coord.XY{-1.0, 0.0}, coord.XY{0.0, -1.0},
	coord.XY{cos45, cos45}, coord.XY{-cos45, cos45}, coord.XY{-cos45, -cos45}, coord.XY{cos45, -cos45},
}

Functions

func Gradient

func Gradient(a0 float32, n uint) []coord.XY

func GradientFrom

func GradientFrom(a []float32) []coord.XY

func Perlin3D

func Perlin3D(p coord.XYZ) float32

Perlin3D returns the value of a 3D Perlin noise function at position `p`.

Example

for z := 0; z < 4; z++ {
	for y := 0; y < 10; y++ {
		for x := 0; x < 10; x++ {
			v := Perlin3D(coord.XYZ{X: float32(x), Y: float32(y), Z: float32(z * 10)}.Slash(10.0))
			iv := uint8(v*50.0 + 50.0)
			fmt.Printf("%2d", iv)
			if x < 9 {
				fmt.Printf(" ")
			}
		}
		fmt.Printf("\n")
	}
	fmt.Printf("\n")
}

Output:

50 50 50 50 50 50 50 50 50 50
45 45 45 46 48 49 51 53 54 54
40 41 42 44 46 49 52 54 56 56
37 38 40 42 45 49 52 54 56 56
36 38 40 43 46 49 51 53 53 54
37 40 42 45 48 50 50 50 50 50
40 43 47 49 51 51 50 48 47 46
44 48 52 54 55 54 51 48 45 43
47 52 56 58 59 57 53 49 45 43
49 54 58 61 61 59 56 51 47 45

50 54 59 62 63 62 59 55 52 50
55 60 64 67 68 67 64 60 57 55
61 66 71 74 75 73 70 66 62 60
68 73 77 80 81 79 76 71 66 63
73 78 82 85 86 84 80 74 69 65
75 80 84 88 89 87 82 76 70 65
73 78 83 87 88 87 82 76 69 63
68 73 78 83 85 84 80 73 66 60
61 66 72 78 81 81 77 71 64 57
55 60 66 72 76 77 75 69 62 55

50 49 47 44 40 37 36 37 40 45
44 44 42 40 38 37 38 40 45 49
38 38 37 36 36 37 40 44 49 54
31 31 31 32 35 38 43 49 54 58
26 27 28 30 35 40 46 53 58 61
25 25 27 31 36 43 50 56 60 62
26 27 29 34 40 47 54 58 61 61
31 32 34 39 45 52 57 60 60 58
38 38 41 45 51 56 59 61 59 56
44 45 47 51 55 59 61 61 59 55

50 45 40 37 36 37 40 44 47 49
54 50 45 42 41 42 45 49 52 54
59 55 50 47 46 47 50 53 56 58
62 59 55 53 51 52 53 56 59 61
63 61 59 57 55 55 55 57 59 61
62 62 61 59 57 56 55 56 57 60
59 61 61 60 58 55 53 53 53 56
55 58 60 59 56 53 50 49 49 51
52 56 58 58 55 51 47 45 45 47
50 54 57 57 54 50 46 43 43 45

func Simplex2D

func Simplex2D(p coord.XY, grad []coord.XY) float32

Simplex2D returns the 2D simplex noise at position p.

func SimplexAxial

func SimplexAxial(q, r float32, grad []coord.XY) float32

SimplexAxial returns the 2D simplex noise at position (q, r), expressed in axial coordinates.