118 lines
2.3 KiB
Go
118 lines
2.3 KiB
Go
package common
|
|
|
|
import (
|
|
"math"
|
|
"math/rand"
|
|
)
|
|
|
|
const (
|
|
perlinYwrapb = 4
|
|
perlinYwrap = 1 << perlinYwrapb
|
|
perlinZwrapb = 8
|
|
perlinZwrap = 1 << perlinZwrapb
|
|
perlinSize = 4095
|
|
perlinOctaves = 4
|
|
perlinAmpFalloff = 0.5
|
|
)
|
|
|
|
// PerlinNoise is a perlin noise struct to generate perlin noise.
|
|
type PerlinNoise struct {
|
|
perlin []float64
|
|
}
|
|
|
|
// NewPerlinNoise returns a PerlinNoise object.
|
|
func NewPerlinNoise() *PerlinNoise {
|
|
perlin := &PerlinNoise{perlin: nil}
|
|
perlin.perlin = make([]float64, perlinSize+1)
|
|
|
|
for i, _ := range perlin.perlin {
|
|
perlin.perlin[i] = rand.Float64()
|
|
}
|
|
return perlin
|
|
}
|
|
|
|
// Noise1D returns a float noise number on one dimension.
|
|
func (p *PerlinNoise) Noise1D(x float64) float64 {
|
|
return p.noise(x, 0, 0)
|
|
}
|
|
|
|
// Noise2D returns a float noise number on two dimensions.
|
|
func (p *PerlinNoise) Noise2D(x, y float64) float64 {
|
|
return p.noise(x, y, 0)
|
|
}
|
|
|
|
// Noise3D returns a float noise number on three dimensions.
|
|
func (p *PerlinNoise) Noise3D(x, y, z float64) float64 {
|
|
return p.noise(x, y, z)
|
|
}
|
|
|
|
func (p *PerlinNoise) noise(x, y, z float64) float64 {
|
|
if x < 0 {
|
|
x = -x
|
|
}
|
|
|
|
if y < 0 {
|
|
y = -y
|
|
}
|
|
|
|
if z < 0 {
|
|
z = -z
|
|
}
|
|
|
|
xi, yi, zi := int(math.Floor(x)), int(math.Floor(y)), int(math.Floor(z))
|
|
xf, yf, zf := x-float64(xi), y-float64(yi), z-float64(zi)
|
|
|
|
var rxf, ryf, n1, n2, n3 float64
|
|
var r float64
|
|
var ampl float64 = 0.5
|
|
|
|
for o := 0; o < perlinOctaves; o++ {
|
|
of := xi + (yi << perlinYwrapb) + (zi << perlinZwrapb)
|
|
|
|
rxf = scaledCosin(xf)
|
|
ryf = scaledCosin(yf)
|
|
|
|
n1 = p.perlin[of&perlinSize]
|
|
n1 += rxf * (p.perlin[(of+1)&perlinSize] - n1)
|
|
n2 = p.perlin[(of+perlinYwrap)&perlinSize]
|
|
n2 += rxf * (p.perlin[(of+perlinYwrap+1)&perlinSize] - n2)
|
|
n1 += ryf * (n2 - n1)
|
|
|
|
of += perlinZwrap
|
|
n2 = p.perlin[of&perlinSize]
|
|
n2 += rxf * (p.perlin[(of+1)&perlinSize] - n2)
|
|
n3 = p.perlin[(of+perlinYwrap)&perlinSize]
|
|
n3 += rxf * (p.perlin[(of+perlinYwrap+1)&perlinSize] - n3)
|
|
n2 += ryf * (n3 - n2)
|
|
|
|
n1 += scaledCosin(zf) * (n2 - n1)
|
|
|
|
r += n1 * ampl
|
|
ampl *= perlinAmpFalloff
|
|
xi <<= 1
|
|
xf *= 2
|
|
yi <<= 1
|
|
yf *= 2
|
|
zi <<= 1
|
|
zf *= 2
|
|
|
|
if xf >= 1.0 {
|
|
xi += 1
|
|
xf -= 1
|
|
}
|
|
if yf >= 1.0 {
|
|
yi += 1
|
|
yf -= 1
|
|
}
|
|
if zf >= 1.0 {
|
|
zi += 1
|
|
zf -= 1
|
|
}
|
|
}
|
|
return r
|
|
}
|
|
|
|
func scaledCosin(x float64) float64 {
|
|
return 0.5 * (1.0 - math.Cos(x*math.Pi))
|
|
}
|