Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

noise: add simplex noise #207

Merged
merged 11 commits into from
Aug 5, 2024
Merged

noise: add simplex noise #207

Changes from 1 commit
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
dc7e687
noise: add simplex 2d implementation
PottierLoic Jul 3, 2024
cb9f649
noise: add simplex 1d/3d implementation
PottierLoic Jul 4, 2024
88a9e48
noise: add simplex 4d implementation
PottierLoic Jul 5, 2024
b0d2484
noise: fmt and clean
PottierLoic Jul 7, 2024
3f64daa
noise: rename `Perlin` struct to `Generator` and add tests for simple…
PottierLoic Jul 8, 2024
d6d226f
noise: add comments
PottierLoic Jul 13, 2024
c8f94bf
noise: examples
PottierLoic Jul 23, 2024
53c91c0
noise: add fractal noise example
PottierLoic Jul 23, 2024
4861581
noise: fmt
PottierLoic Jul 23, 2024
f918cdf
Update README.md
ulises-jeremias Aug 5, 2024
80d461c
Update README.md
ulises-jeremias Aug 5, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
125 changes: 125 additions & 0 deletions noise/simplex.v
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -8,6 +8,21 @@ const g2 = (3.0 - math.sqrt(3)) / 6.0
// skewing factors for 3d case
const f3 = f64(1.0 / 3.0)
const g3 = f64(1.0 / 6.0)
// skewing factors for 4d case
const f4 = f64((math.sqrt(5.0) - 1.0) / 4)
const g4 = f64((5.0 - math.sqrt(5.0)) / 20.0)


const simplex := [
PottierLoic marked this conversation as resolved.
Show resolved Hide resolved
[0, 1, 2, 3], [0, 1, 3, 2], [0, 0, 0, 0], [0, 2, 3, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 2, 3, 0],
[0, 2, 1, 3], [0, 0, 0, 0], [0, 3, 1, 2], [0, 3, 2, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 3, 2, 0],
[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
[1, 2, 0, 3], [0, 0, 0, 0], [1, 3, 0, 2], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [2, 3, 0, 1], [2, 3, 1, 0],
[1, 0, 2, 3], [1, 0, 3, 2], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [2, 0, 3, 1], [0, 0, 0, 0], [2, 1, 3, 0],
[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0],
[2, 0, 1, 3], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [3, 0, 1, 2], [3, 0, 2, 1], [0, 0, 0, 0], [3, 1, 2, 0],
[2, 1, 0, 3], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [3, 1, 0, 2], [0, 0, 0, 0], [3, 2, 0, 1], [3, 2, 1, 0]
]

fn grad_1d(hash int, x f64) f64 {
h := hash & 15
Expand Down Expand Up @@ -279,3 +294,113 @@ pub fn simplex_3d(x f64, y f64, z f64) f64 {
// scale the return value to [-1, 1]
return 32.0 * (n0 + n1 + n2 + n3)
}

pub fn simplex_4d(x f64, y f64, z f64, w f64) f64 {
s := (x + y + z + w) * f4
xs := x + s
ys := y + s
zs := z + s
ws := w + s
i := int(xs)
j := int(ys)
k := int(zs)
l := int(ws)

t := f64(i + j + k + l) * g4
x0 := x - (i - t)
y0 := y - (j - t)
z0 := z - (k - t)
w0 := w - (l - t)

c1 := if x0 > y0 { 32 } else { 0 }
c2 := if x0 > z0 { 16 } else { 0 }
c3 := if y0 > z0 { 8 } else { 0 }
c4 := if x0 > w0 { 4 } else { 0 }
c5 := if y0 > w0 { 2 } else { 0 }
c6 := if z0 > w0 { 1 } else { 0 }
c := c1 + c2 + c3 + c4 + c5 + c6

i1 := if simplex[c][0] >= 3 { 1 } else { 0 }
j1 := if simplex[c][1] >= 3 { 1 } else { 0 }
k1 := if simplex[c][2] >= 3 { 1 } else { 0 }
l1 := if simplex[c][3] >= 3 { 1 } else { 0 }

i2 := if simplex[c][0] >= 2 { 1 } else { 0 }
j2 := if simplex[c][1] >= 2 { 1 } else { 0 }
k2 := if simplex[c][2] >= 2 { 1 } else { 0 }
l2 := if simplex[c][3] >= 2 { 1 } else { 0 }

i3 := if simplex[c][0] >= 1 { 1 } else { 0 }
j3 := if simplex[c][1] >= 1 { 1 } else { 0 }
k3 := if simplex[c][2] >= 1 { 1 } else { 0 }
l3 := if simplex[c][3] >= 1 { 1 } else { 0 }

x1 := x0 - i1 + g4
y1 := y0 - j1 + g4
z1 := z0 - k1 + g4
w1 := w0 - l1 + g4
x2 := x0 - i2 + 2.0 * g4
y2 := y0 - j2 + 2.0 * g4
z2 := z0 - k2 + 2.0 * g4
w2 := w0 - l2 + 2.0 * g4
x3 := x0 - i3 + 3.0 * g4
y3 := y0 - j3 + 3.0 * g4
z3 := z0 - k3 + 3.0 * g4
w3 := w0 - l3 + 3.0 * g4
x4 := x0 - 1.0 + 4.0 * g4
y4 := y0 - 1.0 + 4.0 * g4
z4 := z0 - 1.0 + 4.0 * g4
w4 := w0 - 1.0 + 4.0 * g4

ii := i & 0xff
jj := j & 0xff
kk := k & 0xff
ll := l & 0xff

mut t0 := 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0
mut n0 := 0.0
if t0 < 0.0 {
n0 = 0.0
} else {
t0 *= t0
n0 = t0 * t0 * grad_4d(permutations[ii + permutations[jj + permutations[kk + permutations[ll]]]], x0, y0, z0, w0)
}

mut t1 := 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1
mut n1 := 0.0
if t1 < 0.0 {
n1 = 0.0
} else {
t1 *= t1
n1 = t1 * t1 * grad_4d(permutations[ii + i1 + permutations[jj + j1 + permutations[kk + k1 + permutations[ll + l1]]]], x1, y1, z1, w1)
}

mut t2 := 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2
mut n2 := 0.0
if t2 < 0.0 {
n2 = 0.0
} else {
t2 *= t2
n2 = t2 * t2 * grad_4d(permutations[ii + i2 + permutations[jj + j2 + permutations[kk + k2 + permutations[ll + l2]]]], x2, y2, z2, w2)
}

mut t3 := 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3
mut n3 := 0.0
if t3 < 0.0 {
n3 = 0.0
} else {
t3 *= t3
n3 = t3 * t3 * grad_4d(permutations[ii + i3 + permutations[jj + j3 + permutations[kk + k3 + permutations[ll + l3]]]], x3, y3, z3, w3)
}

mut t4 := 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4
mut n4 := 0.0
if t4 < 0.0 {
n4 = 0.0
} else {
t4 *= t4
n4 = t4 * t4 * grad_4d(permutations[ii + 1 + permutations[jj + 1 + permutations[kk + 1 + permutations[ll + 1]]]], x4, y4, z4, w4)
}

return 27.0 * (n0 + n1 + n2 + n3 + n4)
}
Loading