Clean-up and add simplexQuintic, simplexHermite
This commit is contained in:
Edwin Jakobs
@@ -1,28 +1,32 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
private const val CUBIC_2D_BOUNDING = 1 / (1.5 * 1.5).toFloat()
|
||||
fun cubic(seed: Int, x: Double, y: Double): Double {
|
||||
val x1 = x.fastFloor()
|
||||
val y1 = y.fastFloor()
|
||||
|
||||
val x0 = x1 - 1
|
||||
val y0 = y1 - 1
|
||||
val x2 = x1 + 1
|
||||
val y2 = y1 + 1
|
||||
val x3 = x1 + 2
|
||||
val y3 = y1 + 2
|
||||
|
||||
val xs = x - x1.toDouble()
|
||||
val ys = y - y1.toDouble()
|
||||
|
||||
return cubic(
|
||||
cubic(valCoord2D(seed, x0, y0), valCoord2D(seed, x1, y0), valCoord2D(seed, x2, y0), valCoord2D(seed, x3, y0),
|
||||
xs),
|
||||
cubic(valCoord2D(seed, x0, y1), valCoord2D(seed, x1, y1), valCoord2D(seed, x2, y1), valCoord2D(seed, x3, y1),
|
||||
xs),
|
||||
cubic(valCoord2D(seed, x0, y2), valCoord2D(seed, x1, y2), valCoord2D(seed, x2, y2), valCoord2D(seed, x3, y2),
|
||||
xs),
|
||||
cubic(valCoord2D(seed, x0, y3), valCoord2D(seed, x1, y3), valCoord2D(seed, x2, y3), valCoord2D(seed, x3, y3),
|
||||
xs),
|
||||
ys) * CUBIC_2D_BOUNDING
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun cubicLinear(seed: Int, x: Double, y: Double) = cubic(seed, x, y, ::linear)
|
||||
fun cubicQuintic(seed: Int, x: Double, y: Double) = cubic(seed, x, y, ::quintic)
|
||||
fun cubicHermite(seed: Int, x: Double, y: Double) = cubic(seed, x, y, ::hermite)
|
||||
|
||||
private const val CUBIC_2D_BOUNDING = 1 / (1.5 * 1.5).toFloat()
|
||||
fun cubic(seed: Int, x: Double, y: Double, interpolator: (Double) -> Double = ::linear): Double {
|
||||
val x1 = x.fastFloor()
|
||||
val y1 = y.fastFloor()
|
||||
|
||||
val x0 = x1 - 1
|
||||
val y0 = y1 - 1
|
||||
val x2 = x1 + 1
|
||||
val y2 = y1 + 1
|
||||
val x3 = x1 + 2
|
||||
val y3 = y1 + 2
|
||||
|
||||
val xs = interpolator(x - x1.toDouble())
|
||||
val ys = interpolator(y - y1.toDouble())
|
||||
|
||||
return cubic(
|
||||
cubic(valCoord2D(seed, x0, y0), valCoord2D(seed, x1, y0), valCoord2D(seed, x2, y0), valCoord2D(seed, x3, y0),
|
||||
xs),
|
||||
cubic(valCoord2D(seed, x0, y1), valCoord2D(seed, x1, y1), valCoord2D(seed, x2, y1), valCoord2D(seed, x3, y1),
|
||||
xs),
|
||||
cubic(valCoord2D(seed, x0, y2), valCoord2D(seed, x1, y2), valCoord2D(seed, x2, y2), valCoord2D(seed, x3, y2),
|
||||
xs),
|
||||
cubic(valCoord2D(seed, x0, y3), valCoord2D(seed, x1, y3), valCoord2D(seed, x2, y3), valCoord2D(seed, x3, y3),
|
||||
xs),
|
||||
ys) * CUBIC_2D_BOUNDING
|
||||
}
|
||||
@@ -1,51 +1,55 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
|
||||
private const val CUBIC_3D_BOUNDING = 1 / (1.5 * 1.5 * 1.5).toFloat()
|
||||
|
||||
fun cubic(seed: Int, x: Double, y: Double, z: Double): Double {
|
||||
val x1 = x.fastFloor()
|
||||
val y1 = y.fastFloor()
|
||||
val z1 = z.fastFloor()
|
||||
|
||||
val x0 = x1 - 1
|
||||
val y0 = y1 - 1
|
||||
val z0 = z1 - 1
|
||||
val x2 = x1 + 1
|
||||
val y2 = y1 + 1
|
||||
val z2 = z1 + 1
|
||||
val x3 = x1 + 2
|
||||
val y3 = y1 + 2
|
||||
val z3 = z1 + 2
|
||||
|
||||
val xs = x - x1.toFloat()
|
||||
val ys = y - y1.toFloat()
|
||||
val zs = z - z1.toFloat()
|
||||
|
||||
return cubic(
|
||||
cubic(
|
||||
cubic(valCoord3D(seed, x0, y0, z0), valCoord3D(seed, x1, y0, z0), valCoord3D(seed, x2, y0, z0), valCoord3D(seed, x3, y0, z0), xs),
|
||||
cubic(valCoord3D(seed, x0, y1, z0), valCoord3D(seed, x1, y1, z0), valCoord3D(seed, x2, y1, z0), valCoord3D(seed, x3, y1, z0), xs),
|
||||
cubic(valCoord3D(seed, x0, y2, z0), valCoord3D(seed, x1, y2, z0), valCoord3D(seed, x2, y2, z0), valCoord3D(seed, x3, y2, z0), xs),
|
||||
cubic(valCoord3D(seed, x0, y3, z0), valCoord3D(seed, x1, y3, z0), valCoord3D(seed, x2, y3, z0), valCoord3D(seed, x3, y3, z0), xs),
|
||||
ys),
|
||||
cubic(
|
||||
cubic(valCoord3D(seed, x0, y0, z1), valCoord3D(seed, x1, y0, z1), valCoord3D(seed, x2, y0, z1), valCoord3D(seed, x3, y0, z1), xs),
|
||||
cubic(valCoord3D(seed, x0, y1, z1), valCoord3D(seed, x1, y1, z1), valCoord3D(seed, x2, y1, z1), valCoord3D(seed, x3, y1, z1), xs),
|
||||
cubic(valCoord3D(seed, x0, y2, z1), valCoord3D(seed, x1, y2, z1), valCoord3D(seed, x2, y2, z1), valCoord3D(seed, x3, y2, z1), xs),
|
||||
cubic(valCoord3D(seed, x0, y3, z1), valCoord3D(seed, x1, y3, z1), valCoord3D(seed, x2, y3, z1), valCoord3D(seed, x3, y3, z1), xs),
|
||||
ys),
|
||||
cubic(
|
||||
cubic(valCoord3D(seed, x0, y0, z2), valCoord3D(seed, x1, y0, z2), valCoord3D(seed, x2, y0, z2), valCoord3D(seed, x3, y0, z2), xs),
|
||||
cubic(valCoord3D(seed, x0, y1, z2), valCoord3D(seed, x1, y1, z2), valCoord3D(seed, x2, y1, z2), valCoord3D(seed, x3, y1, z2), xs),
|
||||
cubic(valCoord3D(seed, x0, y2, z2), valCoord3D(seed, x1, y2, z2), valCoord3D(seed, x2, y2, z2), valCoord3D(seed, x3, y2, z2), xs),
|
||||
cubic(valCoord3D(seed, x0, y3, z2), valCoord3D(seed, x1, y3, z2), valCoord3D(seed, x2, y3, z2), valCoord3D(seed, x3, y3, z2), xs),
|
||||
ys),
|
||||
cubic(
|
||||
cubic(valCoord3D(seed, x0, y0, z3), valCoord3D(seed, x1, y0, z3), valCoord3D(seed, x2, y0, z3), valCoord3D(seed, x3, y0, z3), xs),
|
||||
cubic(valCoord3D(seed, x0, y1, z3), valCoord3D(seed, x1, y1, z3), valCoord3D(seed, x2, y1, z3), valCoord3D(seed, x3, y1, z3), xs),
|
||||
cubic(valCoord3D(seed, x0, y2, z3), valCoord3D(seed, x1, y2, z3), valCoord3D(seed, x2, y2, z3), valCoord3D(seed, x3, y2, z3), xs),
|
||||
cubic(valCoord3D(seed, x0, y3, z3), valCoord3D(seed, x1, y3, z3), valCoord3D(seed, x2, y3, z3), valCoord3D(seed, x3, y3, z3), xs),
|
||||
ys),
|
||||
zs) * CUBIC_3D_BOUNDING
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
private const val CUBIC_3D_BOUNDING = 1 / (1.5 * 1.5 * 1.5).toFloat()
|
||||
|
||||
fun cubic(seed: Int, x: Double, y: Double, z: Double) = cubic(seed, x, y, z, ::linear)
|
||||
fun cubicLinear(seed: Int, x: Double, y: Double, z: Double) = cubic(seed, x, y, z, ::linear)
|
||||
fun cubicQuintic(seed: Int, x: Double, y: Double, z: Double) = cubic(seed, x, y, z, ::quintic)
|
||||
fun cubicHermite(seed: Int, x: Double, y: Double, z: Double) = perlin(seed, x, y, z, ::hermite)
|
||||
|
||||
fun cubic(seed: Int, x: Double, y: Double, z: Double, interpolator: (Double) -> Double): Double {
|
||||
val x1 = x.fastFloor()
|
||||
val y1 = y.fastFloor()
|
||||
val z1 = z.fastFloor()
|
||||
|
||||
val x0 = x1 - 1
|
||||
val y0 = y1 - 1
|
||||
val z0 = z1 - 1
|
||||
val x2 = x1 + 1
|
||||
val y2 = y1 + 1
|
||||
val z2 = z1 + 1
|
||||
val x3 = x1 + 2
|
||||
val y3 = y1 + 2
|
||||
val z3 = z1 + 2
|
||||
|
||||
val xs = interpolator(x - x1.toFloat())
|
||||
val ys = interpolator(y - y1.toFloat())
|
||||
val zs = interpolator(z - z1.toFloat())
|
||||
|
||||
return cubic(
|
||||
cubic(
|
||||
cubic(valCoord3D(seed, x0, y0, z0), valCoord3D(seed, x1, y0, z0), valCoord3D(seed, x2, y0, z0), valCoord3D(seed, x3, y0, z0), xs),
|
||||
cubic(valCoord3D(seed, x0, y1, z0), valCoord3D(seed, x1, y1, z0), valCoord3D(seed, x2, y1, z0), valCoord3D(seed, x3, y1, z0), xs),
|
||||
cubic(valCoord3D(seed, x0, y2, z0), valCoord3D(seed, x1, y2, z0), valCoord3D(seed, x2, y2, z0), valCoord3D(seed, x3, y2, z0), xs),
|
||||
cubic(valCoord3D(seed, x0, y3, z0), valCoord3D(seed, x1, y3, z0), valCoord3D(seed, x2, y3, z0), valCoord3D(seed, x3, y3, z0), xs),
|
||||
ys),
|
||||
cubic(
|
||||
cubic(valCoord3D(seed, x0, y0, z1), valCoord3D(seed, x1, y0, z1), valCoord3D(seed, x2, y0, z1), valCoord3D(seed, x3, y0, z1), xs),
|
||||
cubic(valCoord3D(seed, x0, y1, z1), valCoord3D(seed, x1, y1, z1), valCoord3D(seed, x2, y1, z1), valCoord3D(seed, x3, y1, z1), xs),
|
||||
cubic(valCoord3D(seed, x0, y2, z1), valCoord3D(seed, x1, y2, z1), valCoord3D(seed, x2, y2, z1), valCoord3D(seed, x3, y2, z1), xs),
|
||||
cubic(valCoord3D(seed, x0, y3, z1), valCoord3D(seed, x1, y3, z1), valCoord3D(seed, x2, y3, z1), valCoord3D(seed, x3, y3, z1), xs),
|
||||
ys),
|
||||
cubic(
|
||||
cubic(valCoord3D(seed, x0, y0, z2), valCoord3D(seed, x1, y0, z2), valCoord3D(seed, x2, y0, z2), valCoord3D(seed, x3, y0, z2), xs),
|
||||
cubic(valCoord3D(seed, x0, y1, z2), valCoord3D(seed, x1, y1, z2), valCoord3D(seed, x2, y1, z2), valCoord3D(seed, x3, y1, z2), xs),
|
||||
cubic(valCoord3D(seed, x0, y2, z2), valCoord3D(seed, x1, y2, z2), valCoord3D(seed, x2, y2, z2), valCoord3D(seed, x3, y2, z2), xs),
|
||||
cubic(valCoord3D(seed, x0, y3, z2), valCoord3D(seed, x1, y3, z2), valCoord3D(seed, x2, y3, z2), valCoord3D(seed, x3, y3, z2), xs),
|
||||
ys),
|
||||
cubic(
|
||||
cubic(valCoord3D(seed, x0, y0, z3), valCoord3D(seed, x1, y0, z3), valCoord3D(seed, x2, y0, z3), valCoord3D(seed, x3, y0, z3), xs),
|
||||
cubic(valCoord3D(seed, x0, y1, z3), valCoord3D(seed, x1, y1, z3), valCoord3D(seed, x2, y1, z3), valCoord3D(seed, x3, y1, z3), xs),
|
||||
cubic(valCoord3D(seed, x0, y2, z3), valCoord3D(seed, x1, y2, z3), valCoord3D(seed, x2, y2, z3), valCoord3D(seed, x3, y2, z3), xs),
|
||||
cubic(valCoord3D(seed, x0, y3, z3), valCoord3D(seed, x1, y3, z3), valCoord3D(seed, x2, y3, z3), valCoord3D(seed, x3, y3, z3), xs),
|
||||
ys),
|
||||
zs) * CUBIC_3D_BOUNDING
|
||||
}
|
||||
@@ -1,105 +1,105 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
inline fun fbm(seed: Int, x: Double, y: Double, z: Double, crossinline noise: (Int, Double, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = noise(seed, x, y, z)
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
var z = z
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
z *= lacunarity
|
||||
amp *= gain
|
||||
sum += noise(seed + i, x, y, z) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
|
||||
inline fun fbm(seed: Int, x: Double, y: Double, crossinline noise: (Int, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = noise(seed, x, y)
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
amp *= gain
|
||||
sum += noise(seed + i, x, y) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
inline fun billow(seed: Int, x: Double, y: Double, z: Double, crossinline noise: (Int, Double, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5) : Double {
|
||||
var sum = Math.abs(noise(seed, x, y, z) * 2.0 - 1.0)
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
var z = z
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
z *= lacunarity
|
||||
amp *= gain
|
||||
sum += Math.abs(noise(seed + i, x, y, z) * 2.0 - 1.0) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
inline fun billow(seed: Int, x: Double, y: Double, crossinline noise: (Int, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5) : Double {
|
||||
var sum = Math.abs(noise(seed, x, y) * 2.0 - 1.0)
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
amp *= gain
|
||||
sum += Math.abs(noise(seed + i, x, y) * 2.0 - 1.0) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
inline fun rigid(seed: Int, x: Double, y: Double, crossinline noise: (Int, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = 1.0 - Math.abs(noise(seed, x, y))
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
amp *= gain
|
||||
sum -= (1.0 - Math.abs(noise(seed + i, x, y))) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
inline fun rigid(seed: Int, x: Double, y: Double, z: Double, crossinline noise: (Int, Double, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = 1.0 - Math.abs(noise(seed, x, y, z))
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
var z = z
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
z *= lacunarity
|
||||
amp *= gain
|
||||
sum -= (1.0 - Math.abs(noise(seed + i, x, y, z))) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
inline fun fbm(seed: Int, x: Double, y: Double, z: Double, crossinline noise: (Int, Double, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = noise(seed, x, y, z)
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
var z = z
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
z *= lacunarity
|
||||
amp *= gain
|
||||
sum += noise(seed + i, x, y, z) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
|
||||
inline fun fbm(seed: Int, x: Double, y: Double, crossinline noise: (Int, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = noise(seed, x, y)
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
amp *= gain
|
||||
sum += noise(seed + i, x, y) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
inline fun billow(seed: Int, x: Double, y: Double, z: Double, crossinline noise: (Int, Double, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = Math.abs(noise(seed, x, y, z) * 2.0 - 1.0)
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
var z = z
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
z *= lacunarity
|
||||
amp *= gain
|
||||
sum += Math.abs(noise(seed + i, x, y, z) * 2.0 - 1.0) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
inline fun billow(seed: Int, x: Double, y: Double, crossinline noise: (Int, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = Math.abs(noise(seed, x, y) * 2.0 - 1.0)
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
amp *= gain
|
||||
sum += Math.abs(noise(seed + i, x, y) * 2.0 - 1.0) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
inline fun rigid(seed: Int, x: Double, y: Double, crossinline noise: (Int, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = 1.0 - Math.abs(noise(seed, x, y))
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
amp *= gain
|
||||
sum -= (1.0 - Math.abs(noise(seed + i, x, y))) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
inline fun rigid(seed: Int, x: Double, y: Double, z: Double, crossinline noise: (Int, Double, Double, Double) -> Double,
|
||||
octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
|
||||
var sum = 1.0 - Math.abs(noise(seed, x, y, z))
|
||||
var amp = 1.0
|
||||
|
||||
var x = x
|
||||
var y = y
|
||||
var z = z
|
||||
for (i in 1 until octaves) {
|
||||
x *= lacunarity
|
||||
y *= lacunarity
|
||||
z *= lacunarity
|
||||
amp *= gain
|
||||
sum -= (1.0 - Math.abs(noise(seed + i, x, y, z))) * amp
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because one or more lines are too long
@@ -1,24 +1,22 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
|
||||
|
||||
fun hermite(t: Double): Double {
|
||||
return t * t * (3 - 2 * t)
|
||||
}
|
||||
|
||||
fun quintic(t: Double): Double {
|
||||
return t * t * t * (t * (t * 6 - 15) + 10)
|
||||
}
|
||||
|
||||
fun cubic(a: Double, b: Double, c: Double, d: Double, t: Double) : Double {
|
||||
val p = d - c - (a - b)
|
||||
return t * t * t * p + t * t * (a - b - p) + t * (c - a) + b
|
||||
}
|
||||
|
||||
fun linear(x: Double) : Double {
|
||||
return x
|
||||
}
|
||||
|
||||
fun lerp(left: Double, right: Double, x: Double): Double {
|
||||
return left * (1.0 - x) + right * x
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun hermite(t: Double): Double {
|
||||
return t * t * (3 - 2 * t)
|
||||
}
|
||||
|
||||
fun quintic(t: Double): Double {
|
||||
return t * t * t * (t * (t * 6 - 15) + 10)
|
||||
}
|
||||
|
||||
fun cubic(a: Double, b: Double, c: Double, d: Double, t: Double): Double {
|
||||
val p = d - c - (a - b)
|
||||
return t * t * t * p + t * t * (a - b - p) + t * (c - a) + b
|
||||
}
|
||||
|
||||
fun linear(x: Double): Double {
|
||||
return x
|
||||
}
|
||||
|
||||
fun lerp(left: Double, right: Double, x: Double): Double {
|
||||
return left * (1.0 - x) + right * x
|
||||
}
|
||||
@@ -1,26 +1,26 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun perlinLinear(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::linear)
|
||||
fun perlinQuintic(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::quintic)
|
||||
fun perlinHermite(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::hermite)
|
||||
|
||||
private fun perlin(seed: Int, x: Double, y: Double, interpolator: (Double) -> Double): Double {
|
||||
val x0 = x.fastFloor()
|
||||
val y0 = y.fastFloor()
|
||||
val x1 = x0 + 1
|
||||
val y1 = y0 + 1
|
||||
|
||||
val xs = interpolator(x - x0)
|
||||
val ys = interpolator(y - y0)
|
||||
|
||||
|
||||
val xd0 = x - x0
|
||||
val yd0 = y - y0
|
||||
val xd1 = xd0 - 1
|
||||
val yd1 = yd0 - 1
|
||||
|
||||
val xf0 = lerp(gradCoord2D(seed, x0, y0, xd0, yd0), gradCoord2D(seed, x1, y0, xd1, yd0), xs)
|
||||
val xf1 = lerp(gradCoord2D(seed, x0, y1, xd0, yd1), gradCoord2D(seed, x1, y1, xd1, yd1), xs)
|
||||
|
||||
return lerp(xf0, xf1, ys)
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun perlin(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::linear)
|
||||
fun perlinLinear(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::linear)
|
||||
fun perlinQuintic(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::quintic)
|
||||
fun perlinHermite(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::hermite)
|
||||
|
||||
inline fun perlin(seed: Int, x: Double, y: Double, crossinline interpolator: (Double) -> Double): Double {
|
||||
val x0 = x.fastFloor()
|
||||
val y0 = y.fastFloor()
|
||||
val x1 = x0 + 1
|
||||
val y1 = y0 + 1
|
||||
|
||||
val xs = interpolator(x - x0)
|
||||
val ys = interpolator(y - y0)
|
||||
|
||||
val xd0 = x - x0
|
||||
val yd0 = y - y0
|
||||
val xd1 = xd0 - 1
|
||||
val yd1 = yd0 - 1
|
||||
|
||||
val xf0 = lerp(gradCoord2D(seed, x0, y0, xd0, yd0), gradCoord2D(seed, x1, y0, xd1, yd0), xs)
|
||||
val xf1 = lerp(gradCoord2D(seed, x0, y1, xd0, yd1), gradCoord2D(seed, x1, y1, xd1, yd1), xs)
|
||||
|
||||
return lerp(xf0, xf1, ys)
|
||||
}
|
||||
@@ -87,7 +87,7 @@ object Random {
|
||||
var list = coll.toMutableList()
|
||||
val picked = mutableListOf<T>()
|
||||
|
||||
while(picked.size < count) {
|
||||
while (picked.size < count) {
|
||||
if (list.isEmpty()) {
|
||||
list = coll.toMutableList()
|
||||
}
|
||||
@@ -95,7 +95,7 @@ object Random {
|
||||
var index = int0(list.size)
|
||||
var newElem = list.elementAt(index)
|
||||
|
||||
while(compareAgainst.contains(newElem)) {
|
||||
while (compareAgainst.contains(newElem)) {
|
||||
index = int0(list.size)
|
||||
newElem = list.elementAt(index)
|
||||
}
|
||||
@@ -202,7 +202,7 @@ object Random {
|
||||
fun simplex(x: Double, y: Double, z: Double): Double {
|
||||
return simplex(stringToInt(seed), x, y, z)
|
||||
}
|
||||
|
||||
|
||||
fun simplex(x: Double, y: Double, z: Double, w: Double): Double {
|
||||
return simplex(stringToInt(seed), x, y, z, w)
|
||||
}
|
||||
@@ -238,14 +238,14 @@ object Random {
|
||||
}
|
||||
|
||||
fun ring2d(innerRadius: Double = 0.0, outerRadius: Double = 1.0, count: Int = 1): Any {
|
||||
return when(count) {
|
||||
return when (count) {
|
||||
1 -> Vector2.uniformRing(innerRadius, outerRadius, rnd)
|
||||
else -> Vector2.uniformsRing(count, innerRadius, outerRadius, rnd)
|
||||
}
|
||||
}
|
||||
|
||||
fun ring3d(innerRadius: Double = 0.0, outerRadius: Double = 1.0, count: Int = 1): Any {
|
||||
return when(count) {
|
||||
return when (count) {
|
||||
1 -> Vector3.uniformRing(innerRadius, outerRadius, rnd)
|
||||
else -> Vector3.uniformsRing(count, innerRadius, outerRadius, rnd)
|
||||
}
|
||||
|
||||
@@ -1,63 +1,66 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
|
||||
private val G2 = 1.0 / 4.0
|
||||
private val F2 = 1.0 / 2.0
|
||||
|
||||
fun simplex(seed: Int, x: Double, y: Double): Double {
|
||||
var t = (x + y) * F2
|
||||
val i = (x + t).fastFloor()
|
||||
val j = (y + t).fastFloor()
|
||||
|
||||
t = ((i + j) * G2)
|
||||
val X0 = i - t
|
||||
val Y0 = j - t
|
||||
|
||||
val x0 = x - X0
|
||||
val y0 = y - Y0
|
||||
|
||||
val i1: Int
|
||||
val j1: Int
|
||||
if (x0 > y0) {
|
||||
i1 = 1
|
||||
j1 = 0
|
||||
} else {
|
||||
i1 = 0
|
||||
j1 = 1
|
||||
}
|
||||
|
||||
val x1 = x0 - i1 + G2
|
||||
val y1 = y0 - j1 + G2
|
||||
val x2 = x0 - 1 + F2
|
||||
val y2 = y0 - 1 + F2
|
||||
|
||||
val n0: Double
|
||||
val n1: Double
|
||||
val n2: Double
|
||||
|
||||
t = 0.5 - x0 * x0 - y0 * y0
|
||||
if (t < 0)
|
||||
n0 = 0.0
|
||||
else {
|
||||
t *= t
|
||||
n0 = t * t * gradCoord2D(seed, i, j, x0, y0)
|
||||
}
|
||||
|
||||
t = 0.5 - x1 * x1 - y1 * y1
|
||||
if (t < 0)
|
||||
n1 = 0.0
|
||||
else {
|
||||
t *= t
|
||||
n1 = t * t * gradCoord2D(seed, i + i1, j + j1, x1, y1)
|
||||
}
|
||||
|
||||
t = 0.5 - x2 * x2 - y2 * y2
|
||||
if (t < 0)
|
||||
n2 = 0.0
|
||||
else {
|
||||
t *= t
|
||||
n2 = t * t * gradCoord2D(seed, i + 1, j + 1, x2, y2)
|
||||
}
|
||||
|
||||
return 50.0 * (n0 + n1 + n2)
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
private const val G2 = 1.0 / 4.0
|
||||
private const val F2 = 1.0 / 2.0
|
||||
|
||||
fun simplexLinear(seed: Int, x: Double, y: Double) = simplex(seed, x, y, ::linear)
|
||||
fun simplexQuintic(seed: Int, x: Double, y: Double) = simplex(seed, x, y, ::quintic)
|
||||
fun simplexHermite(seed: Int, x: Double, y: Double) = simplex(seed, x, y, ::hermite)
|
||||
|
||||
fun simplex(seed: Int, x: Double, y: Double, interpolator: (Double) -> Double = ::linear): Double {
|
||||
var t = (x + y) * F2
|
||||
val i = (x + t).fastFloor()
|
||||
val j = (y + t).fastFloor()
|
||||
|
||||
t = ((i + j) * G2)
|
||||
val X0 = i - t
|
||||
val Y0 = j - t
|
||||
|
||||
val x0 = interpolator(x - X0)
|
||||
val y0 = interpolator(y - Y0)
|
||||
|
||||
val i1: Int
|
||||
val j1: Int
|
||||
if (x0 > y0) {
|
||||
i1 = 1
|
||||
j1 = 0
|
||||
} else {
|
||||
i1 = 0
|
||||
j1 = 1
|
||||
}
|
||||
|
||||
val x1 = x0 - i1 + G2
|
||||
val y1 = y0 - j1 + G2
|
||||
val x2 = x0 - 1 + F2
|
||||
val y2 = y0 - 1 + F2
|
||||
|
||||
val n0: Double
|
||||
val n1: Double
|
||||
val n2: Double
|
||||
|
||||
t = 0.5 - x0 * x0 - y0 * y0
|
||||
if (t < 0)
|
||||
n0 = 0.0
|
||||
else {
|
||||
t *= t
|
||||
n0 = t * t * gradCoord2D(seed, i, j, x0, y0)
|
||||
}
|
||||
|
||||
t = 0.5 - x1 * x1 - y1 * y1
|
||||
if (t < 0)
|
||||
n1 = 0.0
|
||||
else {
|
||||
t *= t
|
||||
n1 = t * t * gradCoord2D(seed, i + i1, j + j1, x1, y1)
|
||||
}
|
||||
|
||||
t = 0.5 - x2 * x2 - y2 * y2
|
||||
if (t < 0)
|
||||
n2 = 0.0
|
||||
else {
|
||||
t *= t
|
||||
n2 = t * t * gradCoord2D(seed, i + 1, j + 1, x2, y2)
|
||||
}
|
||||
|
||||
return 50.0 * (n0 + n1 + n2)
|
||||
}
|
||||
@@ -1,94 +1,98 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun simplex(seed: Int, x: Double, y: Double, z: Double): Double {
|
||||
|
||||
var t = (x + y + z) / 3.0
|
||||
val i = (x + t).fastFloor()
|
||||
val j = (y + t).fastFloor()
|
||||
val k = (z + t).fastFloor()
|
||||
|
||||
val t2 = (i + j + k) / 6.0
|
||||
val x0 = x - (i - t2)
|
||||
val y0 = y - (j - t2)
|
||||
val z0 = z - (k - t2)
|
||||
|
||||
val i1: Int
|
||||
val j1: Int
|
||||
val k1: Int
|
||||
|
||||
val i2: Int
|
||||
val j2: Int
|
||||
val k2: Int
|
||||
|
||||
if (x0 >= y0) {
|
||||
when {
|
||||
y0 >= z0 -> {
|
||||
i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0; }
|
||||
x0 >= z0 -> {
|
||||
i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1; }
|
||||
else -> {
|
||||
i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1; }
|
||||
}
|
||||
} else {
|
||||
when {
|
||||
y0 < z0 -> {
|
||||
i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1; }
|
||||
x0 < z0 -> {
|
||||
i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1; }
|
||||
else -> {
|
||||
i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0; }
|
||||
}
|
||||
}
|
||||
val x1 = x0 - i1 + 1.0 / 6.0
|
||||
val y1 = y0 - j1 + 1.0 / 6.0
|
||||
val z1 = z0 - k1 + 1.0 / 6.0
|
||||
val x2 = x0 - i2 + 1.0 / 3.0
|
||||
val y2 = y0 - j2 + 1.0 / 3.0
|
||||
val z2 = z0 - k2 + 1.0 / 3.0
|
||||
val x3 = x0 + ((1.0 / 6.0) * 3.0 - 1.0)
|
||||
val y3 = y0 + ((1.0 / 6.0) * 3.0 - 1.0)
|
||||
val z3 = z0 + ((1.0 / 6.0) * 3.0 - 1.0)
|
||||
|
||||
val n0: Double
|
||||
run {
|
||||
var t = 0.6 * x0 * x0 - y0 * y0 - z0 * z0
|
||||
if (t < 0) {
|
||||
n0 = 0.0
|
||||
} else {
|
||||
t *= t
|
||||
n0 = t * t * gradCoord3D(seed, i, j, k, x0, y0, z0)
|
||||
}
|
||||
}
|
||||
val n1: Double
|
||||
run {
|
||||
var t = 0.6 * x1 * x1 - y1 * y1 - z1 * z1
|
||||
if (t < 0) {
|
||||
n1 = 0.0
|
||||
} else {
|
||||
t *= t
|
||||
n1 = t * t * gradCoord3D(seed, i + i1, j + j1, k + k1, x1, y1, z1)
|
||||
}
|
||||
}
|
||||
val n2: Double
|
||||
run {
|
||||
var t = 0.6 * x2 * x2 - y2 * y2 - z2 * z2
|
||||
if (t < 0) {
|
||||
n2 = 0.0
|
||||
} else {
|
||||
t *= t
|
||||
n2 = t * t * gradCoord3D(seed, i + i2, j + j2, k + k2, x2, y2, z2)
|
||||
}
|
||||
}
|
||||
|
||||
val n3: Double
|
||||
run {
|
||||
var t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3
|
||||
if (t < 0)
|
||||
n3 = 0.0
|
||||
else {
|
||||
t *= t
|
||||
n3 = t * t * gradCoord3D(seed, i + 1, j + 1, k + 1, x3, y3, z3)
|
||||
}
|
||||
}
|
||||
return 32 * (n0 + n1 + n2 + n3)
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun simplexLinear(seed: Int, x: Double, y: Double, z: Double) = simplex(seed, x, y, z, ::linear)
|
||||
fun simplexQuintic(seed: Int, x: Double, y: Double, z: Double) = simplex(seed, x, y, z, ::quintic)
|
||||
fun simplexHermite(seed: Int, x: Double, y: Double, z: Double) = simplex(seed, x, y, z, ::hermite)
|
||||
|
||||
fun simplex(seed: Int, x: Double, y: Double, z: Double, interpolator: (Double) -> Double = ::linear): Double {
|
||||
|
||||
val t = (x + y + z) / 3.0
|
||||
val i = (x + t).fastFloor()
|
||||
val j = (y + t).fastFloor()
|
||||
val k = (z + t).fastFloor()
|
||||
|
||||
val t2 = (i + j + k) / 6.0
|
||||
val x0 = interpolator(x - (i - t2))
|
||||
val y0 = interpolator(y - (j - t2))
|
||||
val z0 = interpolator(z - (k - t2))
|
||||
|
||||
val i1: Int
|
||||
val j1: Int
|
||||
val k1: Int
|
||||
|
||||
val i2: Int
|
||||
val j2: Int
|
||||
val k2: Int
|
||||
|
||||
if (x0 >= y0) {
|
||||
when {
|
||||
y0 >= z0 -> {
|
||||
i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0; }
|
||||
x0 >= z0 -> {
|
||||
i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1; }
|
||||
else -> {
|
||||
i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1; }
|
||||
}
|
||||
} else {
|
||||
when {
|
||||
y0 < z0 -> {
|
||||
i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1; }
|
||||
x0 < z0 -> {
|
||||
i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1; }
|
||||
else -> {
|
||||
i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0; }
|
||||
}
|
||||
}
|
||||
val x1 = x0 - i1 + 1.0 / 6.0
|
||||
val y1 = y0 - j1 + 1.0 / 6.0
|
||||
val z1 = z0 - k1 + 1.0 / 6.0
|
||||
val x2 = x0 - i2 + 1.0 / 3.0
|
||||
val y2 = y0 - j2 + 1.0 / 3.0
|
||||
val z2 = z0 - k2 + 1.0 / 3.0
|
||||
val x3 = x0 + ((1.0 / 6.0) * 3.0 - 1.0)
|
||||
val y3 = y0 + ((1.0 / 6.0) * 3.0 - 1.0)
|
||||
val z3 = z0 + ((1.0 / 6.0) * 3.0 - 1.0)
|
||||
|
||||
val n0: Double
|
||||
run {
|
||||
var t = 0.6 * x0 * x0 - y0 * y0 - z0 * z0
|
||||
if (t < 0) {
|
||||
n0 = 0.0
|
||||
} else {
|
||||
t *= t
|
||||
n0 = t * t * gradCoord3D(seed, i, j, k, x0, y0, z0)
|
||||
}
|
||||
}
|
||||
val n1: Double
|
||||
run {
|
||||
var t = 0.6 * x1 * x1 - y1 * y1 - z1 * z1
|
||||
if (t < 0) {
|
||||
n1 = 0.0
|
||||
} else {
|
||||
t *= t
|
||||
n1 = t * t * gradCoord3D(seed, i + i1, j + j1, k + k1, x1, y1, z1)
|
||||
}
|
||||
}
|
||||
val n2: Double
|
||||
run {
|
||||
var t = 0.6 * x2 * x2 - y2 * y2 - z2 * z2
|
||||
if (t < 0) {
|
||||
n2 = 0.0
|
||||
} else {
|
||||
t *= t
|
||||
n2 = t * t * gradCoord3D(seed, i + i2, j + j2, k + k2, x2, y2, z2)
|
||||
}
|
||||
}
|
||||
|
||||
val n3: Double
|
||||
run {
|
||||
var t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3
|
||||
if (t < 0)
|
||||
n3 = 0.0
|
||||
else {
|
||||
t *= t
|
||||
n3 = t * t * gradCoord3D(seed, i + 1, j + 1, k + 1, x3, y3, z3)
|
||||
}
|
||||
}
|
||||
return 32 * (n0 + n1 + n2 + n3)
|
||||
}
|
||||
@@ -1,103 +1,107 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
private val SIMPLEX_4D = byteArrayOf(
|
||||
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
|
||||
)
|
||||
|
||||
private val F4 = ((2.23606797 - 1.0) / 4.0)
|
||||
private val G4 = ((5.0 - 2.23606797) / 20.0)
|
||||
|
||||
fun simplex(seed: Int, x: Double, y: Double, z: Double, w: Double): Double {
|
||||
|
||||
var t = (x + y + z + w) * F4
|
||||
val i = (x + t).fastFloor()
|
||||
val j = (y + t).fastFloor()
|
||||
val k = (z + t).fastFloor()
|
||||
val l = (w + t).fastFloor()
|
||||
|
||||
val t2 = (i + j + k + l) * G4
|
||||
val x0 = x - (i - t2)
|
||||
val y0 = y - (j - t2)
|
||||
val z0 = z - (k - t2)
|
||||
val w0 = w - (l - t2)
|
||||
|
||||
var c = if (x0 > y0) 32 else 0
|
||||
c += if (x0 > z0) 16 else 0
|
||||
c += if (y0 > z0) 8 else 0
|
||||
c += if (x0 > w0) 4 else 0
|
||||
c += if (y0 > w0) 2 else 0
|
||||
c += if (z0 > w0) 1 else 0
|
||||
c = c shl 2
|
||||
|
||||
val i1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
|
||||
val i2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
|
||||
val i3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0
|
||||
val j1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
|
||||
val j2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
|
||||
val j3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0
|
||||
val k1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
|
||||
val k2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
|
||||
val k3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0
|
||||
val l1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
|
||||
val l2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
|
||||
val l3 = if (SIMPLEX_4D[c] >= 1) 1 else 0
|
||||
|
||||
|
||||
val x1 = x0 - i1 + G4
|
||||
val y1 = y0 - j1 + G4
|
||||
val z1 = z0 - k1 + G4
|
||||
val w1 = w0 - l1 + G4
|
||||
val x2 = x0 - i2 + 2 * G4
|
||||
val y2 = y0 - j2 + 2 * G4
|
||||
val z2 = z0 - k2 + 2 * G4
|
||||
val w2 = w0 - l2 + 2 * G4
|
||||
val x3 = x0 - i3 + 3 * G4
|
||||
val y3 = y0 - j3 + 3 * G4
|
||||
val z3 = z0 - k3 + 3 * G4
|
||||
val w3 = w0 - l3 + 3 * G4
|
||||
val x4 = x0 - 1 + 4 * G4
|
||||
val y4 = y0 - 1 + 4 * G4
|
||||
val z4 = z0 - 1 + 4 * G4
|
||||
val w4 = w0 - 1 + 4 * G4
|
||||
|
||||
val n0: Double
|
||||
val n1: Double
|
||||
val n2: Double
|
||||
val n3: Double
|
||||
val n4: Double
|
||||
|
||||
t = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0
|
||||
if (t < 0) n0 = 0.0 else {
|
||||
t *= t
|
||||
n0 = t * t * gradCoord4D(seed, i, j, k, l, x0, y0, z0, w0)
|
||||
}
|
||||
t = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1
|
||||
if (t < 0) n1 = 0.0 else {
|
||||
t *= t
|
||||
n1 = t * t * gradCoord4D(seed, i + i1, j + j1, k + k1, l + l1, x1, y1, z1, w1)
|
||||
}
|
||||
t = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2
|
||||
if (t < 0) n2 = 0.0 else {
|
||||
t *= t
|
||||
n2 = t * t * gradCoord4D(seed, i + i2, j + j2, k + k2, l + l2, x2, y2, z2, w2)
|
||||
}
|
||||
t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3
|
||||
if (t < 0) n3 = 0.0 else {
|
||||
t *= t
|
||||
n3 = t * t * gradCoord4D(seed, i + i3, j + j3, k + k3, l + l3, x3, y3, z3, w3)
|
||||
}
|
||||
t = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4
|
||||
if (t < 0) n4 = 0.0 else {
|
||||
t *= t
|
||||
n4 = t * t * gradCoord4D(seed, i + 1, j + 1, k + 1, l + 1, x4, y4, z4, w4)
|
||||
}
|
||||
|
||||
return 27 * (n0 + n1 + n2 + n3 + n4)
|
||||
}
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
private val SIMPLEX_4D = byteArrayOf(
|
||||
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
|
||||
)
|
||||
|
||||
private const val F4 = ((2.23606797 - 1.0) / 4.0)
|
||||
private const val G4 = ((5.0 - 2.23606797) / 20.0)
|
||||
|
||||
fun simplexLinear(seed: Int, x: Double, y: Double, z: Double, w: Double) = simplex(seed, x, y, z, w, ::linear)
|
||||
fun simplexQuintic(seed: Int, x: Double, y: Double, z: Double, w: Double) = simplex(seed, x, y, z, w, ::quintic)
|
||||
fun simplexHermite(seed: Int, x: Double, y: Double, z: Double, w: Double) = simplex(seed, x, y, z, w, ::hermite)
|
||||
|
||||
fun simplex(seed: Int, x: Double, y: Double, z: Double, w: Double, interpolator: (Double) -> Double = ::linear): Double {
|
||||
|
||||
var t = (x + y + z + w) * F4
|
||||
val i = (x + t).fastFloor()
|
||||
val j = (y + t).fastFloor()
|
||||
val k = (z + t).fastFloor()
|
||||
val l = (w + t).fastFloor()
|
||||
|
||||
val t2 = (i + j + k + l) * G4
|
||||
val x0 = interpolator(x - (i - t2))
|
||||
val y0 = interpolator(y - (j - t2))
|
||||
val z0 = interpolator(z - (k - t2))
|
||||
val w0 = interpolator(w - (l - t2))
|
||||
|
||||
var c = if (x0 > y0) 32 else 0
|
||||
c += if (x0 > z0) 16 else 0
|
||||
c += if (y0 > z0) 8 else 0
|
||||
c += if (x0 > w0) 4 else 0
|
||||
c += if (y0 > w0) 2 else 0
|
||||
c += if (z0 > w0) 1 else 0
|
||||
c = c shl 2
|
||||
|
||||
val i1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
|
||||
val i2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
|
||||
val i3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0
|
||||
val j1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
|
||||
val j2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
|
||||
val j3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0
|
||||
val k1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
|
||||
val k2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
|
||||
val k3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0
|
||||
val l1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
|
||||
val l2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
|
||||
val l3 = if (SIMPLEX_4D[c] >= 1) 1 else 0
|
||||
|
||||
|
||||
val x1 = x0 - i1 + G4
|
||||
val y1 = y0 - j1 + G4
|
||||
val z1 = z0 - k1 + G4
|
||||
val w1 = w0 - l1 + G4
|
||||
val x2 = x0 - i2 + 2 * G4
|
||||
val y2 = y0 - j2 + 2 * G4
|
||||
val z2 = z0 - k2 + 2 * G4
|
||||
val w2 = w0 - l2 + 2 * G4
|
||||
val x3 = x0 - i3 + 3 * G4
|
||||
val y3 = y0 - j3 + 3 * G4
|
||||
val z3 = z0 - k3 + 3 * G4
|
||||
val w3 = w0 - l3 + 3 * G4
|
||||
val x4 = x0 - 1 + 4 * G4
|
||||
val y4 = y0 - 1 + 4 * G4
|
||||
val z4 = z0 - 1 + 4 * G4
|
||||
val w4 = w0 - 1 + 4 * G4
|
||||
|
||||
val n0: Double
|
||||
val n1: Double
|
||||
val n2: Double
|
||||
val n3: Double
|
||||
val n4: Double
|
||||
|
||||
t = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0
|
||||
if (t < 0) n0 = 0.0 else {
|
||||
t *= t
|
||||
n0 = t * t * gradCoord4D(seed, i, j, k, l, x0, y0, z0, w0)
|
||||
}
|
||||
t = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1
|
||||
if (t < 0) n1 = 0.0 else {
|
||||
t *= t
|
||||
n1 = t * t * gradCoord4D(seed, i + i1, j + j1, k + k1, l + l1, x1, y1, z1, w1)
|
||||
}
|
||||
t = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2
|
||||
if (t < 0) n2 = 0.0 else {
|
||||
t *= t
|
||||
n2 = t * t * gradCoord4D(seed, i + i2, j + j2, k + k2, l + l2, x2, y2, z2, w2)
|
||||
}
|
||||
t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3
|
||||
if (t < 0) n3 = 0.0 else {
|
||||
t *= t
|
||||
n3 = t * t * gradCoord4D(seed, i + i3, j + j3, k + k3, l + l3, x3, y3, z3, w3)
|
||||
}
|
||||
t = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4
|
||||
if (t < 0) n4 = 0.0 else {
|
||||
t *= t
|
||||
n4 = t * t * gradCoord4D(seed, i + 1, j + 1, k + 1, l + 1, x4, y4, z4, w4)
|
||||
}
|
||||
|
||||
return 27 * (n0 + n1 + n2 + n3 + n4)
|
||||
}
|
||||
|
||||
@@ -1,118 +1,122 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
import org.openrndr.math.Vector2
|
||||
import org.openrndr.math.Vector3
|
||||
import org.openrndr.math.Vector4
|
||||
import kotlin.random.Random
|
||||
|
||||
fun Double.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Double {
|
||||
return (random.nextDouble() * (max - min)) + min
|
||||
}
|
||||
|
||||
fun Vector2.Companion.uniform(min: Vector2 = -ONE, max: Vector2 = ONE, random: Random = Random.Default): Vector2 {
|
||||
return Vector2(Double.uniform(min.x, max.x, random), Double.uniform(min.y, max.y, random))
|
||||
}
|
||||
|
||||
fun Vector2.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default) =
|
||||
Vector2.uniform(Vector2(min, min), Vector2(max, max), random)
|
||||
|
||||
fun Vector2.Companion.uniformRing(innerRadius: Double = 0.0,
|
||||
outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): Vector2 {
|
||||
while (true) {
|
||||
uniform(-outerRadius, outerRadius, random).let {
|
||||
val squaredLength = it.squaredLength
|
||||
if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) {
|
||||
return it
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun Vector2.Companion.uniforms(count: Int,
|
||||
min: Vector2 = -ONE,
|
||||
max: Vector2 = ONE,
|
||||
random: Random = Random.Default): List<Vector2> =
|
||||
List(count) {
|
||||
Vector2.uniform(min, max, random)
|
||||
}
|
||||
|
||||
fun Vector2.Companion.uniformsRing(count: Int,
|
||||
innerRadius: Double = 0.0, outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): List<Vector2> =
|
||||
List(count) {
|
||||
Vector2.uniformRing(innerRadius, outerRadius, random)
|
||||
}
|
||||
|
||||
fun Vector3.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Vector3 =
|
||||
Vector3.uniform(Vector3(min, min, min), Vector3(max, max, max), random)
|
||||
|
||||
fun Vector3.Companion.uniform(min: Vector3 = -ONE,
|
||||
max: Vector3 = ONE,
|
||||
random: Random = Random.Default): Vector3 {
|
||||
return Vector3(Double.uniform(min.x, max.x, random),
|
||||
Double.uniform(min.y, max.y, random),
|
||||
Double.uniform(min.z, max.z, random))
|
||||
}
|
||||
|
||||
fun Vector3.Companion.uniformRing(innerRadius: Double = 0.0,
|
||||
outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): Vector3 {
|
||||
while (true) {
|
||||
uniform(-outerRadius, outerRadius, random).let {
|
||||
val squaredLength = it.squaredLength
|
||||
if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) {
|
||||
return it
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun Vector3.Companion.uniforms(count: Int,
|
||||
min: Double = -1.0,
|
||||
max: Double = 1.0,
|
||||
random: Random = Random.Default): List<Vector3> =
|
||||
List(count) {
|
||||
Vector3.uniform(min, max, random)
|
||||
}
|
||||
|
||||
|
||||
fun Vector3.Companion.uniforms(count: Int,
|
||||
min: Vector3 = -ONE,
|
||||
max: Vector3 = ONE,
|
||||
random: Random = Random.Default): List<Vector3> =
|
||||
List(count) {
|
||||
Vector3.uniform(min, max, random)
|
||||
}
|
||||
|
||||
fun Vector3.Companion.uniformsRing(count: Int,
|
||||
innerRadius: Double = 0.0, outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): List<Vector3> =
|
||||
List(count) {
|
||||
Vector3.uniformRing(innerRadius, outerRadius, random)
|
||||
}
|
||||
|
||||
|
||||
fun Vector4.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Vector4 =
|
||||
Vector4.uniform(Vector4(min, min, min, min), Vector4(max, max, max, max), random)
|
||||
|
||||
fun Vector4.Companion.uniform(min: Vector4 = -ONE, max: Vector4 = ONE, random: Random = Random.Default): Vector4 {
|
||||
return Vector4(Double.uniform(min.x, max.x, random),
|
||||
Double.uniform(min.y, max.y, random),
|
||||
Double.uniform(min.z, max.z, random),
|
||||
Double.uniform(min.w, max.w, random))
|
||||
}
|
||||
|
||||
fun Vector4.Companion.uniformRing(innerRadius: Double = 0.0,
|
||||
outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): Vector4 {
|
||||
while (true) {
|
||||
uniform(-outerRadius, outerRadius, random).let {
|
||||
val squaredLength = it.squaredLength
|
||||
if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) {
|
||||
return it
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
import org.openrndr.math.Vector2
|
||||
import org.openrndr.math.Vector3
|
||||
import org.openrndr.math.Vector4
|
||||
import kotlin.random.Random
|
||||
|
||||
fun random(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Double {
|
||||
return (random.nextDouble() * (max - min)) + min
|
||||
}
|
||||
|
||||
fun Double.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Double {
|
||||
return (random.nextDouble() * (max - min)) + min
|
||||
}
|
||||
|
||||
fun Vector2.Companion.uniform(min: Vector2 = -ONE, max: Vector2 = ONE, random: Random = Random.Default): Vector2 {
|
||||
return Vector2(Double.uniform(min.x, max.x, random), Double.uniform(min.y, max.y, random))
|
||||
}
|
||||
|
||||
fun Vector2.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default) =
|
||||
Vector2.uniform(Vector2(min, min), Vector2(max, max), random)
|
||||
|
||||
fun Vector2.Companion.uniformRing(innerRadius: Double = 0.0,
|
||||
outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): Vector2 {
|
||||
while (true) {
|
||||
uniform(-outerRadius, outerRadius, random).let {
|
||||
val squaredLength = it.squaredLength
|
||||
if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) {
|
||||
return it
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun Vector2.Companion.uniforms(count: Int,
|
||||
min: Vector2 = -ONE,
|
||||
max: Vector2 = ONE,
|
||||
random: Random = Random.Default): List<Vector2> =
|
||||
List(count) {
|
||||
Vector2.uniform(min, max, random)
|
||||
}
|
||||
|
||||
fun Vector2.Companion.uniformsRing(count: Int,
|
||||
innerRadius: Double = 0.0, outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): List<Vector2> =
|
||||
List(count) {
|
||||
Vector2.uniformRing(innerRadius, outerRadius, random)
|
||||
}
|
||||
|
||||
fun Vector3.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Vector3 =
|
||||
Vector3.uniform(Vector3(min, min, min), Vector3(max, max, max), random)
|
||||
|
||||
fun Vector3.Companion.uniform(min: Vector3 = -ONE,
|
||||
max: Vector3 = ONE,
|
||||
random: Random = Random.Default): Vector3 {
|
||||
return Vector3(Double.uniform(min.x, max.x, random),
|
||||
Double.uniform(min.y, max.y, random),
|
||||
Double.uniform(min.z, max.z, random))
|
||||
}
|
||||
|
||||
fun Vector3.Companion.uniformRing(innerRadius: Double = 0.0,
|
||||
outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): Vector3 {
|
||||
while (true) {
|
||||
uniform(-outerRadius, outerRadius, random).let {
|
||||
val squaredLength = it.squaredLength
|
||||
if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) {
|
||||
return it
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun Vector3.Companion.uniforms(count: Int,
|
||||
min: Double = -1.0,
|
||||
max: Double = 1.0,
|
||||
random: Random = Random.Default): List<Vector3> =
|
||||
List(count) {
|
||||
Vector3.uniform(min, max, random)
|
||||
}
|
||||
|
||||
|
||||
fun Vector3.Companion.uniforms(count: Int,
|
||||
min: Vector3 = -ONE,
|
||||
max: Vector3 = ONE,
|
||||
random: Random = Random.Default): List<Vector3> =
|
||||
List(count) {
|
||||
Vector3.uniform(min, max, random)
|
||||
}
|
||||
|
||||
fun Vector3.Companion.uniformsRing(count: Int,
|
||||
innerRadius: Double = 0.0, outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): List<Vector3> =
|
||||
List(count) {
|
||||
Vector3.uniformRing(innerRadius, outerRadius, random)
|
||||
}
|
||||
|
||||
|
||||
fun Vector4.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Vector4 =
|
||||
Vector4.uniform(Vector4(min, min, min, min), Vector4(max, max, max, max), random)
|
||||
|
||||
fun Vector4.Companion.uniform(min: Vector4 = -ONE, max: Vector4 = ONE, random: Random = Random.Default): Vector4 {
|
||||
return Vector4(Double.uniform(min.x, max.x, random),
|
||||
Double.uniform(min.y, max.y, random),
|
||||
Double.uniform(min.z, max.z, random),
|
||||
Double.uniform(min.w, max.w, random))
|
||||
}
|
||||
|
||||
fun Vector4.Companion.uniformRing(innerRadius: Double = 0.0,
|
||||
outerRadius: Double = 1.0,
|
||||
random: Random = Random.Default): Vector4 {
|
||||
while (true) {
|
||||
uniform(-outerRadius, outerRadius, random).let {
|
||||
val squaredLength = it.squaredLength
|
||||
if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) {
|
||||
return it
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -1,21 +1,20 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun valueLinear(seed: Int, x:Double, y:Double) = value(seed, x, y, ::linear)
|
||||
fun valueQuintic(seed: Int, x:Double, y:Double) = value(seed, x, y, ::quintic)
|
||||
fun valueHermite(seed: Int, x:Double, y:Double) = value(seed, x, y, ::hermite)
|
||||
|
||||
|
||||
inline fun value(seed: Int, x: Double, y: Double, crossinline interpolation: (Double) -> Double = ::linear): Double {
|
||||
val x0 = x.fastFloor()
|
||||
val y0 = y.fastFloor()
|
||||
val x1 = x0 + 1
|
||||
val y1 = y0 + 1
|
||||
|
||||
val xs = interpolation(x - x0)
|
||||
val ys = interpolation(y - y0)
|
||||
|
||||
val xf0 = lerp(valCoord2D(seed, x0, y0), valCoord2D(seed, x1, y0), xs)
|
||||
val xf1 = lerp(valCoord2D(seed, x0, y1), valCoord2D(seed, x1, y1), xs)
|
||||
|
||||
return lerp(xf0, xf1, ys)
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun valueLinear(seed: Int, x: Double, y: Double) = value(seed, x, y, ::linear)
|
||||
fun valueQuintic(seed: Int, x: Double, y: Double) = value(seed, x, y, ::quintic)
|
||||
fun valueHermite(seed: Int, x: Double, y: Double) = value(seed, x, y, ::hermite)
|
||||
|
||||
inline fun value(seed: Int, x: Double, y: Double, crossinline interpolation: (Double) -> Double = ::linear): Double {
|
||||
val x0 = x.fastFloor()
|
||||
val y0 = y.fastFloor()
|
||||
val x1 = x0 + 1
|
||||
val y1 = y0 + 1
|
||||
|
||||
val xs = interpolation(x - x0)
|
||||
val ys = interpolation(y - y0)
|
||||
|
||||
val xf0 = lerp(valCoord2D(seed, x0, y0), valCoord2D(seed, x1, y0), xs)
|
||||
val xf1 = lerp(valCoord2D(seed, x0, y1), valCoord2D(seed, x1, y1), xs)
|
||||
|
||||
return lerp(xf0, xf1, ys)
|
||||
}
|
||||
@@ -1,29 +1,29 @@
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun valueLinear(seed: Int, x:Double, y:Double, z:Double) = value(seed, x, y, z, ::linear)
|
||||
fun valueQuintic(seed: Int, x:Double, y:Double, z:Double) = value(seed, x, y, z, ::quintic)
|
||||
fun valueHermite(seed: Int, x:Double, y:Double, z:Double) = value(seed, x, y, z, ::hermite)
|
||||
|
||||
inline fun value(seed:Int, x: Double, y: Double, z: Double, crossinline interpolation:(Double)->Double = ::linear) : Double {
|
||||
val x0 = x.fastFloor()
|
||||
val y0 = y.fastFloor()
|
||||
val z0 = z.fastFloor()
|
||||
val x1 = x0 + 1
|
||||
val y1 = y0 + 1
|
||||
val z1 = z0 + 1
|
||||
|
||||
val xs = interpolation(x - x0)
|
||||
val ys = interpolation(y - y0)
|
||||
val zs = interpolation(z - z0)
|
||||
|
||||
|
||||
val xf00 = lerp(valCoord3D(seed, x0, y0, z0), valCoord3D(seed, x1, y0, z0), xs)
|
||||
val xf10 = lerp(valCoord3D(seed, x0, y1, z0), valCoord3D(seed, x1, y1, z0), xs)
|
||||
val xf01 = lerp(valCoord3D(seed, x0, y0, z1), valCoord3D(seed, x1, y0, z1), xs)
|
||||
val xf11 = lerp(valCoord3D(seed, x0, y1, z1), valCoord3D(seed, x1, y1, z1), xs)
|
||||
|
||||
val yf0 = lerp(xf00, xf10, ys)
|
||||
val yf1 = lerp(xf01, xf11, ys)
|
||||
|
||||
return lerp(yf0, yf1, zs)
|
||||
package org.openrndr.extra.noise
|
||||
|
||||
fun valueLinear(seed: Int, x: Double, y: Double, z: Double) = value(seed, x, y, z, ::linear)
|
||||
fun valueQuintic(seed: Int, x: Double, y: Double, z: Double) = value(seed, x, y, z, ::quintic)
|
||||
fun valueHermite(seed: Int, x: Double, y: Double, z: Double) = value(seed, x, y, z, ::hermite)
|
||||
|
||||
inline fun value(seed: Int, x: Double, y: Double, z: Double, crossinline interpolation: (Double) -> Double = ::linear): Double {
|
||||
val x0 = x.fastFloor()
|
||||
val y0 = y.fastFloor()
|
||||
val z0 = z.fastFloor()
|
||||
val x1 = x0 + 1
|
||||
val y1 = y0 + 1
|
||||
val z1 = z0 + 1
|
||||
|
||||
val xs = interpolation(x - x0)
|
||||
val ys = interpolation(y - y0)
|
||||
val zs = interpolation(z - z0)
|
||||
|
||||
|
||||
val xf00 = lerp(valCoord3D(seed, x0, y0, z0), valCoord3D(seed, x1, y0, z0), xs)
|
||||
val xf10 = lerp(valCoord3D(seed, x0, y1, z0), valCoord3D(seed, x1, y1, z0), xs)
|
||||
val xf01 = lerp(valCoord3D(seed, x0, y0, z1), valCoord3D(seed, x1, y0, z1), xs)
|
||||
val xf11 = lerp(valCoord3D(seed, x0, y1, z1), valCoord3D(seed, x1, y1, z1), xs)
|
||||
|
||||
val yf0 = lerp(xf00, xf10, ys)
|
||||
val yf1 = lerp(xf01, xf11, ys)
|
||||
|
||||
return lerp(yf0, yf1, zs)
|
||||
}
|
||||
Reference in New Issue
Block a user