kaze/orx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean-up and add simplexQuintic, simplexHermite

Browse Source
This commit is contained in:
Edwin Jakobs
2020-03-11 17:29:15 +01:00
parent d795ef91f3
commit 5b0775289c
13 changed files with 836 additions and 815 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
orx-noise/src/main/kotlin/CubicNoise2D.kt
View File

@@ -1,28 +1,32 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
private const val CUBIC_2D_BOUNDING = 1 / (1.5 * 1.5).toFloat() fun cubicLinear(seed: Int, x: Double, y: Double) = cubic(seed, x, y, ::linear)
fun cubic(seed: Int, x: Double, y: Double): Double { fun cubicQuintic(seed: Int, x: Double, y: Double) = cubic(seed, x, y, ::quintic)
val x1 = x.fastFloor() fun cubicHermite(seed: Int, x: Double, y: Double) = cubic(seed, x, y, ::hermite)
val y1 = y.fastFloor()
private const val CUBIC_2D_BOUNDING = 1 / (1.5 * 1.5).toFloat()
val x0 = x1 - 1 fun cubic(seed: Int, x: Double, y: Double, interpolator: (Double) -> Double = ::linear): Double {
val y0 = y1 - 1 val x1 = x.fastFloor()
val x2 = x1 + 1 val y1 = y.fastFloor()
val y2 = y1 + 1
val x3 = x1 + 2 val x0 = x1 - 1
val y3 = y1 + 2 val y0 = y1 - 1
val x2 = x1 + 1
val xs = x - x1.toDouble() val y2 = y1 + 1
val ys = y - y1.toDouble() val x3 = x1 + 2
val y3 = y1 + 2
return cubic(
cubic(valCoord2D(seed, x0, y0), valCoord2D(seed, x1, y0), valCoord2D(seed, x2, y0), valCoord2D(seed, x3, y0), val xs = interpolator(x - x1.toDouble())
xs), val ys = interpolator(y - y1.toDouble())
cubic(valCoord2D(seed, x0, y1), valCoord2D(seed, x1, y1), valCoord2D(seed, x2, y1), valCoord2D(seed, x3, y1),
xs), return cubic(
cubic(valCoord2D(seed, x0, y2), valCoord2D(seed, x1, y2), valCoord2D(seed, x2, y2), valCoord2D(seed, x3, y2), cubic(valCoord2D(seed, x0, y0), valCoord2D(seed, x1, y0), valCoord2D(seed, x2, y0), valCoord2D(seed, x3, y0),
xs), xs),
cubic(valCoord2D(seed, x0, y3), valCoord2D(seed, x1, y3), valCoord2D(seed, x2, y3), valCoord2D(seed, x3, y3), cubic(valCoord2D(seed, x0, y1), valCoord2D(seed, x1, y1), valCoord2D(seed, x2, y1), valCoord2D(seed, x3, y1),
xs), xs),
ys) * CUBIC_2D_BOUNDING 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
} }

104
orx-noise/src/main/kotlin/CubicNoise3D.kt
View File

@@ -1,51 +1,55 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
private const val CUBIC_3D_BOUNDING = 1 / (1.5 * 1.5 * 1.5).toFloat()
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 cubic(seed: Int, x: Double, y: Double, z: Double): Double { fun cubicLinear(seed: Int, x: Double, y: Double, z: Double) = cubic(seed, x, y, z, ::linear)
val x1 = x.fastFloor() fun cubicQuintic(seed: Int, x: Double, y: Double, z: Double) = cubic(seed, x, y, z, ::quintic)
val y1 = y.fastFloor() fun cubicHermite(seed: Int, x: Double, y: Double, z: Double) = perlin(seed, x, y, z, ::hermite)
val z1 = z.fastFloor()
fun cubic(seed: Int, x: Double, y: Double, z: Double, interpolator: (Double) -> Double): Double {
val x0 = x1 - 1 val x1 = x.fastFloor()
val y0 = y1 - 1 val y1 = y.fastFloor()
val z0 = z1 - 1 val z1 = z.fastFloor()
val x2 = x1 + 1
val y2 = y1 + 1 val x0 = x1 - 1
val z2 = z1 + 1 val y0 = y1 - 1
val x3 = x1 + 2 val z0 = z1 - 1
val y3 = y1 + 2 val x2 = x1 + 1
val z3 = z1 + 2 val y2 = y1 + 1
val z2 = z1 + 1
val xs = x - x1.toFloat() val x3 = x1 + 2
val ys = y - y1.toFloat() val y3 = y1 + 2
val zs = z - z1.toFloat() val z3 = z1 + 2
return cubic( val xs = interpolator(x - x1.toFloat())
cubic( val ys = interpolator(y - y1.toFloat())
cubic(valCoord3D(seed, x0, y0, z0), valCoord3D(seed, x1, y0, z0), valCoord3D(seed, x2, y0, z0), valCoord3D(seed, x3, y0, z0), xs), val zs = interpolator(z - z1.toFloat())
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), return cubic(
cubic(valCoord3D(seed, x0, y3, z0), valCoord3D(seed, x1, y3, z0), valCoord3D(seed, x2, y3, z0), valCoord3D(seed, x3, y3, z0), xs), cubic(
ys), cubic(valCoord3D(seed, x0, y0, z0), valCoord3D(seed, x1, y0, z0), valCoord3D(seed, x2, y0, z0), valCoord3D(seed, x3, y0, z0), xs),
cubic( 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, y0, z1), valCoord3D(seed, x1, y0, z1), valCoord3D(seed, x2, y0, z1), valCoord3D(seed, x3, y0, z1), 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, y1, z1), valCoord3D(seed, x1, y1, z1), valCoord3D(seed, x2, y1, z1), valCoord3D(seed, x3, y1, z1), xs), cubic(valCoord3D(seed, x0, y3, z0), valCoord3D(seed, x1, y3, z0), valCoord3D(seed, x2, y3, z0), valCoord3D(seed, x3, y3, z0), xs),
cubic(valCoord3D(seed, x0, y2, z1), valCoord3D(seed, x1, y2, z1), valCoord3D(seed, x2, y2, z1), valCoord3D(seed, x3, y2, z1), xs), ys),
cubic(valCoord3D(seed, x0, y3, z1), valCoord3D(seed, x1, y3, z1), valCoord3D(seed, x2, y3, z1), valCoord3D(seed, x3, y3, z1), xs), cubic(
ys), cubic(valCoord3D(seed, x0, y0, z1), valCoord3D(seed, x1, y0, z1), valCoord3D(seed, x2, y0, z1), valCoord3D(seed, x3, y0, z1), xs),
cubic( 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, y0, z2), valCoord3D(seed, x1, y0, z2), valCoord3D(seed, x2, y0, z2), valCoord3D(seed, x3, y0, z2), 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, y1, z2), valCoord3D(seed, x1, y1, z2), valCoord3D(seed, x2, y1, z2), valCoord3D(seed, x3, y1, z2), xs), cubic(valCoord3D(seed, x0, y3, z1), valCoord3D(seed, x1, y3, z1), valCoord3D(seed, x2, y3, z1), valCoord3D(seed, x3, y3, z1), xs),
cubic(valCoord3D(seed, x0, y2, z2), valCoord3D(seed, x1, y2, z2), valCoord3D(seed, x2, y2, z2), valCoord3D(seed, x3, y2, z2), xs), ys),
cubic(valCoord3D(seed, x0, y3, z2), valCoord3D(seed, x1, y3, z2), valCoord3D(seed, x2, y3, z2), valCoord3D(seed, x3, y3, z2), xs), cubic(
ys), cubic(valCoord3D(seed, x0, y0, z2), valCoord3D(seed, x1, y0, z2), valCoord3D(seed, x2, y0, z2), valCoord3D(seed, x3, y0, z2), xs),
cubic( 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, y0, z3), valCoord3D(seed, x1, y0, z3), valCoord3D(seed, x2, y0, z3), valCoord3D(seed, x3, y0, z3), 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, y1, z3), valCoord3D(seed, x1, y1, z3), valCoord3D(seed, x2, y1, z3), valCoord3D(seed, x3, y1, z3), xs), cubic(valCoord3D(seed, x0, y3, z2), valCoord3D(seed, x1, y3, z2), valCoord3D(seed, x2, y3, z2), valCoord3D(seed, x3, y3, z2), xs),
cubic(valCoord3D(seed, x0, y2, z3), valCoord3D(seed, x1, y2, z3), valCoord3D(seed, x2, y2, z3), valCoord3D(seed, x3, y2, z3), xs), ys),
cubic(valCoord3D(seed, x0, y3, z3), valCoord3D(seed, x1, y3, z3), valCoord3D(seed, x2, y3, z3), valCoord3D(seed, x3, y3, z3), xs), cubic(
ys), cubic(valCoord3D(seed, x0, y0, z3), valCoord3D(seed, x1, y0, z3), valCoord3D(seed, x2, y0, z3), valCoord3D(seed, x3, y0, z3), xs),
zs) * CUBIC_3D_BOUNDING 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
} }

210
orx-noise/src/main/kotlin/Fractal.kt
View File

@@ -1,105 +1,105 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
inline fun fbm(seed: Int, x: Double, y: Double, z: Double, crossinline noise: (Int, Double, Double, Double) -> Double, 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 { octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
var sum = noise(seed, x, y, z) var sum = noise(seed, x, y, z)
var amp = 1.0 var amp = 1.0
var x = x var x = x
var y = y var y = y
var z = z var z = z
for (i in 1 until octaves) { for (i in 1 until octaves) {
x *= lacunarity x *= lacunarity
y *= lacunarity y *= lacunarity
z *= lacunarity z *= lacunarity
amp *= gain amp *= gain
sum += noise(seed + i, x, y, z) * amp sum += noise(seed + i, x, y, z) * amp
} }
return sum return sum
} }
inline fun fbm(seed: Int, x: Double, y: Double, crossinline noise: (Int, Double, Double) -> Double, 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 { octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
var sum = noise(seed, x, y) var sum = noise(seed, x, y)
var amp = 1.0 var amp = 1.0
var x = x var x = x
var y = y var y = y
for (i in 1 until octaves) { for (i in 1 until octaves) {
x *= lacunarity x *= lacunarity
y *= lacunarity y *= lacunarity
amp *= gain amp *= gain
sum += noise(seed + i, x, y) * amp sum += noise(seed + i, x, y) * amp
} }
return sum return sum
} }
inline fun billow(seed: Int, x: Double, y: Double, z: Double, crossinline noise: (Int, Double, Double, Double) -> Double, 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 { 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 sum = Math.abs(noise(seed, x, y, z) * 2.0 - 1.0)
var amp = 1.0 var amp = 1.0
var x = x var x = x
var y = y var y = y
var z = z var z = z
for (i in 1 until octaves) { for (i in 1 until octaves) {
x *= lacunarity x *= lacunarity
y *= lacunarity y *= lacunarity
z *= lacunarity z *= lacunarity
amp *= gain amp *= gain
sum += Math.abs(noise(seed + i, x, y, z) * 2.0 - 1.0) * amp sum += Math.abs(noise(seed + i, x, y, z) * 2.0 - 1.0) * amp
} }
return sum return sum
} }
inline fun billow(seed: Int, x: Double, y: Double, crossinline noise: (Int, Double, Double) -> Double, 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 { 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 sum = Math.abs(noise(seed, x, y) * 2.0 - 1.0)
var amp = 1.0 var amp = 1.0
var x = x var x = x
var y = y var y = y
for (i in 1 until octaves) { for (i in 1 until octaves) {
x *= lacunarity x *= lacunarity
y *= lacunarity y *= lacunarity
amp *= gain amp *= gain
sum += Math.abs(noise(seed + i, x, y) * 2.0 - 1.0) * amp sum += Math.abs(noise(seed + i, x, y) * 2.0 - 1.0) * amp
} }
return sum return sum
} }
inline fun rigid(seed: Int, x: Double, y: Double, crossinline noise: (Int, Double, Double) -> Double, 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 { octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
var sum = 1.0 - Math.abs(noise(seed, x, y)) var sum = 1.0 - Math.abs(noise(seed, x, y))
var amp = 1.0 var amp = 1.0
var x = x var x = x
var y = y var y = y
for (i in 1 until octaves) { for (i in 1 until octaves) {
x *= lacunarity x *= lacunarity
y *= lacunarity y *= lacunarity
amp *= gain amp *= gain
sum -= (1.0 - Math.abs(noise(seed + i, x, y))) * amp sum -= (1.0 - Math.abs(noise(seed + i, x, y))) * amp
} }
return sum return sum
} }
inline fun rigid(seed: Int, x: Double, y: Double, z: Double, crossinline noise: (Int, Double, Double, Double) -> Double, 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 { octaves: Int = 8, lacunarity: Double = 0.5, gain: Double = 0.5): Double {
var sum = 1.0 - Math.abs(noise(seed, x, y, z)) var sum = 1.0 - Math.abs(noise(seed, x, y, z))
var amp = 1.0 var amp = 1.0
var x = x var x = x
var y = y var y = y
var z = z var z = z
for (i in 1 until octaves) { for (i in 1 until octaves) {
x *= lacunarity x *= lacunarity
y *= lacunarity y *= lacunarity
z *= lacunarity z *= lacunarity
amp *= gain amp *= gain
sum -= (1.0 - Math.abs(noise(seed + i, x, y, z))) * amp sum -= (1.0 - Math.abs(noise(seed + i, x, y, z))) * amp
} }
return sum return sum
} }

313
orx-noise/src/main/kotlin/GradCoord.kt
View File

File diff suppressed because one or more lines are too long

44
orx-noise/src/main/kotlin/Interpolation.kt
View File

@@ -1,24 +1,22 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
fun hermite(t: Double): Double {
return t * t * (3 - 2 * t)
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 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)
fun cubic(a: Double, b: Double, c: Double, d: Double, t: Double) : Double { return t * t * t * p + t * t * (a - b - p) + t * (c - a) + b
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 linear(x: Double) : Double { }
return x
} fun lerp(left: Double, right: Double, x: Double): Double {
return left * (1.0 - x) + right * x
fun lerp(left: Double, right: Double, x: Double): Double {
return left * (1.0 - x) + right * x
} }

50
orx-noise/src/main/kotlin/PerlinNoise2D.kt
View File

@@ -1,26 +1,26 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
fun perlinLinear(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::linear) fun perlin(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 perlinLinear(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::linear)
fun perlinHermite(seed: Int, x: Double, y: Double) = perlin(seed, x, y, ::hermite) 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() inline fun perlin(seed: Int, x: Double, y: Double, crossinline interpolator: (Double) -> Double): Double {
val y0 = y.fastFloor() val x0 = x.fastFloor()
val x1 = x0 + 1 val y0 = y.fastFloor()
val y1 = y0 + 1 val x1 = x0 + 1
val y1 = y0 + 1
val xs = interpolator(x - x0)
val ys = interpolator(y - y0) val xs = interpolator(x - x0)
val ys = interpolator(y - y0)
val xd0 = x - x0 val xd0 = x - x0
val yd0 = y - y0 val yd0 = y - y0
val xd1 = xd0 - 1 val xd1 = xd0 - 1
val yd1 = yd0 - 1 val yd1 = yd0 - 1
val xf0 = lerp(gradCoord2D(seed, x0, y0, xd0, yd0), gradCoord2D(seed, x1, y0, xd1, yd0), xs) 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) val xf1 = lerp(gradCoord2D(seed, x0, y1, xd0, yd1), gradCoord2D(seed, x1, y1, xd1, yd1), xs)
return lerp(xf0, xf1, ys) return lerp(xf0, xf1, ys)
} }

10
orx-noise/src/main/kotlin/Random.kt
View File

@@ -87,7 +87,7 @@ object Random {
var list = coll.toMutableList() var list = coll.toMutableList()
val picked = mutableListOf<T>() val picked = mutableListOf<T>()
while(picked.size < count) { while (picked.size < count) {
if (list.isEmpty()) { if (list.isEmpty()) {
list = coll.toMutableList() list = coll.toMutableList()
} }
@@ -95,7 +95,7 @@ object Random {
var index = int0(list.size) var index = int0(list.size)
var newElem = list.elementAt(index) var newElem = list.elementAt(index)
while(compareAgainst.contains(newElem)) { while (compareAgainst.contains(newElem)) {
index = int0(list.size) index = int0(list.size)
newElem = list.elementAt(index) newElem = list.elementAt(index)
} }
@@ -202,7 +202,7 @@ object Random {
fun simplex(x: Double, y: Double, z: Double): Double { fun simplex(x: Double, y: Double, z: Double): Double {
return simplex(stringToInt(seed), x, y, z) return simplex(stringToInt(seed), x, y, z)
} }
fun simplex(x: Double, y: Double, z: Double, w: Double): Double { fun simplex(x: Double, y: Double, z: Double, w: Double): Double {
return simplex(stringToInt(seed), x, y, z, w) 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 { 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) 1 -> Vector2.uniformRing(innerRadius, outerRadius, rnd)
else -> Vector2.uniformsRing(count, innerRadius, outerRadius, rnd) else -> Vector2.uniformsRing(count, innerRadius, outerRadius, rnd)
} }
} }
fun ring3d(innerRadius: Double = 0.0, outerRadius: Double = 1.0, count: Int = 1): Any { 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) 1 -> Vector3.uniformRing(innerRadius, outerRadius, rnd)
else -> Vector3.uniformsRing(count, innerRadius, outerRadius, rnd) else -> Vector3.uniformsRing(count, innerRadius, outerRadius, rnd)
} }

127
orx-noise/src/main/kotlin/SimplexNoise2D.kt
View File

@@ -1,63 +1,66 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
private const val G2 = 1.0 / 4.0
private val G2 = 1.0 / 4.0 private const val F2 = 1.0 / 2.0
private val F2 = 1.0 / 2.0
fun simplexLinear(seed: Int, x: Double, y: Double) = simplex(seed, x, y, ::linear)
fun simplex(seed: Int, x: Double, y: Double): Double { fun simplexQuintic(seed: Int, x: Double, y: Double) = simplex(seed, x, y, ::quintic)
var t = (x + y) * F2 fun simplexHermite(seed: Int, x: Double, y: Double) = simplex(seed, x, y, ::hermite)
val i = (x + t).fastFloor()
val j = (y + t).fastFloor() fun simplex(seed: Int, x: Double, y: Double, interpolator: (Double) -> Double = ::linear): Double {
var t = (x + y) * F2
t = ((i + j) * G2) val i = (x + t).fastFloor()
val X0 = i - t val j = (y + t).fastFloor()
val Y0 = j - t
t = ((i + j) * G2)
val x0 = x - X0 val X0 = i - t
val y0 = y - Y0 val Y0 = j - t
val i1: Int val x0 = interpolator(x - X0)
val j1: Int val y0 = interpolator(y - Y0)
if (x0 > y0) {
i1 = 1 val i1: Int
j1 = 0 val j1: Int
} else { if (x0 > y0) {
i1 = 0 i1 = 1
j1 = 1 j1 = 0
} } else {
i1 = 0
val x1 = x0 - i1 + G2 j1 = 1
val y1 = y0 - j1 + G2 }
val x2 = x0 - 1 + F2
val y2 = y0 - 1 + F2 val x1 = x0 - i1 + G2
val y1 = y0 - j1 + G2
val n0: Double val x2 = x0 - 1 + F2
val n1: Double val y2 = y0 - 1 + F2
val n2: Double
val n0: Double
t = 0.5 - x0 * x0 - y0 * y0 val n1: Double
if (t < 0) val n2: Double
n0 = 0.0
else { t = 0.5 - x0 * x0 - y0 * y0
t *= t if (t < 0)
n0 = t * t * gradCoord2D(seed, i, j, x0, y0) n0 = 0.0
} else {
t *= t
t = 0.5 - x1 * x1 - y1 * y1 n0 = t * t * gradCoord2D(seed, i, j, x0, y0)
if (t < 0) }
n1 = 0.0
else { t = 0.5 - x1 * x1 - y1 * y1
t *= t if (t < 0)
n1 = t * t * gradCoord2D(seed, i + i1, j + j1, x1, y1) n1 = 0.0
} else {
t *= t
t = 0.5 - x2 * x2 - y2 * y2 n1 = t * t * gradCoord2D(seed, i + i1, j + j1, x1, y1)
if (t < 0) }
n2 = 0.0
else { t = 0.5 - x2 * x2 - y2 * y2
t *= t if (t < 0)
n2 = t * t * gradCoord2D(seed, i + 1, j + 1, x2, y2) n2 = 0.0
} else {
t *= t
return 50.0 * (n0 + n1 + n2) n2 = t * t * gradCoord2D(seed, i + 1, j + 1, x2, y2)
}
return 50.0 * (n0 + n1 + n2)
} }

190
orx-noise/src/main/kotlin/SimplexNoise3D.kt
View File

@@ -1,94 +1,98 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
fun simplex(seed: Int, x: Double, y: Double, z: Double): Double { 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)
var t = (x + y + z) / 3.0 fun simplexHermite(seed: Int, x: Double, y: Double, z: Double) = simplex(seed, x, y, z, ::hermite)
val i = (x + t).fastFloor()
val j = (y + t).fastFloor() fun simplex(seed: Int, x: Double, y: Double, z: Double, interpolator: (Double) -> Double = ::linear): Double {
val k = (z + t).fastFloor()
val t = (x + y + z) / 3.0
val t2 = (i + j + k) / 6.0 val i = (x + t).fastFloor()
val x0 = x - (i - t2) val j = (y + t).fastFloor()
val y0 = y - (j - t2) val k = (z + t).fastFloor()
val z0 = z - (k - t2)
val t2 = (i + j + k) / 6.0
val i1: Int val x0 = interpolator(x - (i - t2))
val j1: Int val y0 = interpolator(y - (j - t2))
val k1: Int val z0 = interpolator(z - (k - t2))
val i2: Int val i1: Int
val j2: Int val j1: Int
val k2: Int val k1: Int
if (x0 >= y0) { val i2: Int
when { val j2: Int
y0 >= z0 -> { val k2: Int
i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0; }
x0 >= z0 -> { if (x0 >= y0) {
i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1; } when {
else -> { y0 >= z0 -> {
i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1; } i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 1; k2 = 0; }
} x0 >= z0 -> {
} else { i1 = 1; j1 = 0; k1 = 0; i2 = 1; j2 = 0; k2 = 1; }
when { else -> {
y0 < z0 -> { i1 = 0; j1 = 0; k1 = 1; i2 = 1; j2 = 0; k2 = 1; }
i1 = 0; j1 = 0; k1 = 1; i2 = 0; j2 = 1; k2 = 1; } }
x0 < z0 -> { } else {
i1 = 0; j1 = 1; k1 = 0; i2 = 0; j2 = 1; k2 = 1; } when {
else -> { y0 < z0 -> {
i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 0; } 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; }
val x1 = x0 - i1 + 1.0 / 6.0 else -> {
val y1 = y0 - j1 + 1.0 / 6.0 i1 = 0; j1 = 1; k1 = 0; i2 = 1; j2 = 1; k2 = 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 x1 = x0 - i1 + 1.0 / 6.0
val z2 = z0 - k2 + 1.0 / 3.0 val y1 = y0 - j1 + 1.0 / 6.0
val x3 = x0 + ((1.0 / 6.0) * 3.0 - 1.0) val z1 = z0 - k1 + 1.0 / 6.0
val y3 = y0 + ((1.0 / 6.0) * 3.0 - 1.0) val x2 = x0 - i2 + 1.0 / 3.0
val z3 = z0 + ((1.0 / 6.0) * 3.0 - 1.0) val y2 = y0 - j2 + 1.0 / 3.0
val z2 = z0 - k2 + 1.0 / 3.0
val n0: Double val x3 = x0 + ((1.0 / 6.0) * 3.0 - 1.0)
run { val y3 = y0 + ((1.0 / 6.0) * 3.0 - 1.0)
var t = 0.6 * x0 * x0 - y0 * y0 - z0 * z0 val z3 = z0 + ((1.0 / 6.0) * 3.0 - 1.0)
if (t < 0) {
n0 = 0.0 val n0: Double
} else { run {
t *= t var t = 0.6 * x0 * x0 - y0 * y0 - z0 * z0
n0 = t * t * gradCoord3D(seed, i, j, k, x0, y0, z0) if (t < 0) {
} n0 = 0.0
} } else {
val n1: Double t *= t
run { n0 = t * t * gradCoord3D(seed, i, j, k, x0, y0, z0)
var t = 0.6 * x1 * x1 - y1 * y1 - z1 * z1 }
if (t < 0) { }
n1 = 0.0 val n1: Double
} else { run {
t *= t var t = 0.6 * x1 * x1 - y1 * y1 - z1 * z1
n1 = t * t * gradCoord3D(seed, i + i1, j + j1, k + k1, x1, y1, z1) if (t < 0) {
} n1 = 0.0
} } else {
val n2: Double t *= t
run { n1 = t * t * gradCoord3D(seed, i + i1, j + j1, k + k1, x1, y1, z1)
var t = 0.6 * x2 * x2 - y2 * y2 - z2 * z2 }
if (t < 0) { }
n2 = 0.0 val n2: Double
} else { run {
t *= t var t = 0.6 * x2 * x2 - y2 * y2 - z2 * z2
n2 = t * t * gradCoord3D(seed, i + i2, j + j2, k + k2, x2, y2, z2) if (t < 0) {
} n2 = 0.0
} } else {
t *= t
val n3: Double n2 = t * t * gradCoord3D(seed, i + i2, j + j2, k + k2, x2, y2, z2)
run { }
var t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 }
if (t < 0)
n3 = 0.0 val n3: Double
else { run {
t *= t var t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3
n3 = t * t * gradCoord3D(seed, i + 1, j + 1, k + 1, x3, y3, z3) if (t < 0)
} n3 = 0.0
} else {
return 32 * (n0 + n1 + n2 + n3) t *= t
n3 = t * t * gradCoord3D(seed, i + 1, j + 1, k + 1, x3, y3, z3)
}
}
return 32 * (n0 + n1 + n2 + n3)
} }

210
orx-noise/src/main/kotlin/SimplexNoise4D.kt
View File

@@ -1,103 +1,107 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
private val SIMPLEX_4D = byteArrayOf( 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, 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, 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, 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, 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, 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, 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, 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 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 const val F4 = ((2.23606797 - 1.0) / 4.0)
private val G4 = ((5.0 - 2.23606797) / 20.0) private const val G4 = ((5.0 - 2.23606797) / 20.0)
fun simplex(seed: Int, x: Double, y: Double, z: Double, w: Double): Double { 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)
var t = (x + y + z + w) * F4 fun simplexHermite(seed: Int, x: Double, y: Double, z: Double, w: Double) = simplex(seed, x, y, z, w, ::hermite)
val i = (x + t).fastFloor()
val j = (y + t).fastFloor() fun simplex(seed: Int, x: Double, y: Double, z: Double, w: Double, interpolator: (Double) -> Double = ::linear): Double {
val k = (z + t).fastFloor()
val l = (w + t).fastFloor() var t = (x + y + z + w) * F4
val i = (x + t).fastFloor()
val t2 = (i + j + k + l) * G4 val j = (y + t).fastFloor()
val x0 = x - (i - t2) val k = (z + t).fastFloor()
val y0 = y - (j - t2) val l = (w + t).fastFloor()
val z0 = z - (k - t2)
val w0 = w - (l - t2) val t2 = (i + j + k + l) * G4
val x0 = interpolator(x - (i - t2))
var c = if (x0 > y0) 32 else 0 val y0 = interpolator(y - (j - t2))
c += if (x0 > z0) 16 else 0 val z0 = interpolator(z - (k - t2))
c += if (y0 > z0) 8 else 0 val w0 = interpolator(w - (l - t2))
c += if (x0 > w0) 4 else 0
c += if (y0 > w0) 2 else 0 var c = if (x0 > y0) 32 else 0
c += if (z0 > w0) 1 else 0 c += if (x0 > z0) 16 else 0
c = c shl 2 c += if (y0 > z0) 8 else 0
c += if (x0 > w0) 4 else 0
val i1 = if (SIMPLEX_4D[c] >= 3) 1 else 0 c += if (y0 > w0) 2 else 0
val i2 = if (SIMPLEX_4D[c] >= 2) 1 else 0 c += if (z0 > w0) 1 else 0
val i3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0 c = c shl 2
val j1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
val j2 = if (SIMPLEX_4D[c] >= 2) 1 else 0 val i1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
val j3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0 val i2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
val k1 = if (SIMPLEX_4D[c] >= 3) 1 else 0 val i3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0
val k2 = if (SIMPLEX_4D[c] >= 2) 1 else 0 val j1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
val k3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0 val j2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
val l1 = if (SIMPLEX_4D[c] >= 3) 1 else 0 val j3 = if (SIMPLEX_4D[c++] >= 1) 1 else 0
val l2 = if (SIMPLEX_4D[c] >= 2) 1 else 0 val k1 = if (SIMPLEX_4D[c] >= 3) 1 else 0
val l3 = if (SIMPLEX_4D[c] >= 1) 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 x1 = x0 - i1 + G4 val l2 = if (SIMPLEX_4D[c] >= 2) 1 else 0
val y1 = y0 - j1 + G4 val l3 = if (SIMPLEX_4D[c] >= 1) 1 else 0
val z1 = z0 - k1 + G4
val w1 = w0 - l1 + G4
val x2 = x0 - i2 + 2 * G4 val x1 = x0 - i1 + G4
val y2 = y0 - j2 + 2 * G4 val y1 = y0 - j1 + G4
val z2 = z0 - k2 + 2 * G4 val z1 = z0 - k1 + G4
val w2 = w0 - l2 + 2 * G4 val w1 = w0 - l1 + G4
val x3 = x0 - i3 + 3 * G4 val x2 = x0 - i2 + 2 * G4
val y3 = y0 - j3 + 3 * G4 val y2 = y0 - j2 + 2 * G4
val z3 = z0 - k3 + 3 * G4 val z2 = z0 - k2 + 2 * G4
val w3 = w0 - l3 + 3 * G4 val w2 = w0 - l2 + 2 * G4
val x4 = x0 - 1 + 4 * G4 val x3 = x0 - i3 + 3 * G4
val y4 = y0 - 1 + 4 * G4 val y3 = y0 - j3 + 3 * G4
val z4 = z0 - 1 + 4 * G4 val z3 = z0 - k3 + 3 * G4
val w4 = w0 - 1 + 4 * G4 val w3 = w0 - l3 + 3 * G4
val x4 = x0 - 1 + 4 * G4
val n0: Double val y4 = y0 - 1 + 4 * G4
val n1: Double val z4 = z0 - 1 + 4 * G4
val n2: Double val w4 = w0 - 1 + 4 * G4
val n3: Double
val n4: Double val n0: Double
val n1: Double
t = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0 val n2: Double
if (t < 0) n0 = 0.0 else { val n3: Double
t *= t val n4: Double
n0 = t * t * gradCoord4D(seed, i, j, k, l, x0, y0, z0, w0)
} t = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0
t = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1 if (t < 0) n0 = 0.0 else {
if (t < 0) n1 = 0.0 else { t *= t
t *= t n0 = t * t * gradCoord4D(seed, i, j, k, l, x0, y0, z0, w0)
n1 = t * t * gradCoord4D(seed, i + i1, j + j1, k + k1, l + l1, x1, y1, z1, w1) }
} t = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1
t = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2 if (t < 0) n1 = 0.0 else {
if (t < 0) n2 = 0.0 else { t *= t
t *= t n1 = t * t * gradCoord4D(seed, i + i1, j + j1, k + k1, l + l1, x1, y1, z1, w1)
n2 = t * t * gradCoord4D(seed, i + i2, j + j2, k + k2, l + l2, x2, y2, z2, w2) }
} t = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2
t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3 if (t < 0) n2 = 0.0 else {
if (t < 0) n3 = 0.0 else { t *= t
t *= t n2 = t * t * gradCoord4D(seed, i + i2, j + j2, k + k2, l + l2, x2, y2, z2, w2)
n3 = t * t * gradCoord4D(seed, i + i3, j + j3, k + k3, l + l3, x3, y3, z3, w3) }
} t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3
t = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4 if (t < 0) n3 = 0.0 else {
if (t < 0) n4 = 0.0 else { t *= t
t *= t n3 = t * t * gradCoord4D(seed, i + i3, j + j3, k + k3, l + l3, x3, y3, z3, w3)
n4 = t * t * gradCoord4D(seed, i + 1, j + 1, k + 1, l + 1, x4, y4, z4, w4) }
} t = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4
if (t < 0) n4 = 0.0 else {
return 27 * (n0 + n1 + n2 + n3 + n4) 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)
}

240
orx-noise/src/main/kotlin/UniformRandom.kt
View File

@@ -1,118 +1,122 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
import org.openrndr.math.Vector2 import org.openrndr.math.Vector2
import org.openrndr.math.Vector3 import org.openrndr.math.Vector3
import org.openrndr.math.Vector4 import org.openrndr.math.Vector4
import kotlin.random.Random import kotlin.random.Random
fun Double.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Double { fun random(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Double {
return (random.nextDouble() * (max - min)) + min return (random.nextDouble() * (max - min)) + min
} }
fun Vector2.Companion.uniform(min: Vector2 = -ONE, max: Vector2 = ONE, random: Random = Random.Default): Vector2 { fun Double.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Double {
return Vector2(Double.uniform(min.x, max.x, random), Double.uniform(min.y, max.y, random)) return (random.nextDouble() * (max - min)) + min
} }
fun Vector2.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default) = fun Vector2.Companion.uniform(min: Vector2 = -ONE, max: Vector2 = ONE, random: Random = Random.Default): Vector2 {
Vector2.uniform(Vector2(min, min), Vector2(max, max), random) return Vector2(Double.uniform(min.x, max.x, random), Double.uniform(min.y, max.y, random))
}
fun Vector2.Companion.uniformRing(innerRadius: Double = 0.0,
outerRadius: Double = 1.0, fun Vector2.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default) =
random: Random = Random.Default): Vector2 { Vector2.uniform(Vector2(min, min), Vector2(max, max), random)
while (true) {
uniform(-outerRadius, outerRadius, random).let { fun Vector2.Companion.uniformRing(innerRadius: Double = 0.0,
val squaredLength = it.squaredLength outerRadius: Double = 1.0,
if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) { random: Random = Random.Default): Vector2 {
return it 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) { fun Vector2.Companion.uniforms(count: Int,
Vector2.uniform(min, max, random) min: Vector2 = -ONE,
} max: Vector2 = ONE,
random: Random = Random.Default): List<Vector2> =
fun Vector2.Companion.uniformsRing(count: Int, List(count) {
innerRadius: Double = 0.0, outerRadius: Double = 1.0, Vector2.uniform(min, max, random)
random: Random = Random.Default): List<Vector2> = }
List(count) {
Vector2.uniformRing(innerRadius, outerRadius, random) fun Vector2.Companion.uniformsRing(count: Int,
} innerRadius: Double = 0.0, outerRadius: Double = 1.0,
random: Random = Random.Default): List<Vector2> =
fun Vector3.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Vector3 = List(count) {
Vector3.uniform(Vector3(min, min, min), Vector3(max, max, max), random) Vector2.uniformRing(innerRadius, outerRadius, random)
}
fun Vector3.Companion.uniform(min: Vector3 = -ONE,
max: Vector3 = ONE, fun Vector3.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Vector3 =
random: Random = Random.Default): Vector3 { Vector3.uniform(Vector3(min, min, min), Vector3(max, max, max), random)
return Vector3(Double.uniform(min.x, max.x, random),
Double.uniform(min.y, max.y, random), fun Vector3.Companion.uniform(min: Vector3 = -ONE,
Double.uniform(min.z, max.z, random)) max: Vector3 = ONE,
} random: Random = Random.Default): Vector3 {
return Vector3(Double.uniform(min.x, max.x, random),
fun Vector3.Companion.uniformRing(innerRadius: Double = 0.0, Double.uniform(min.y, max.y, random),
outerRadius: Double = 1.0, Double.uniform(min.z, max.z, random))
random: Random = Random.Default): Vector3 { }
while (true) {
uniform(-outerRadius, outerRadius, random).let { fun Vector3.Companion.uniformRing(innerRadius: Double = 0.0,
val squaredLength = it.squaredLength outerRadius: Double = 1.0,
if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) { random: Random = Random.Default): Vector3 {
return it 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) { fun Vector3.Companion.uniforms(count: Int,
Vector3.uniform(min, max, random) min: Double = -1.0,
} max: Double = 1.0,
random: Random = Random.Default): List<Vector3> =
List(count) {
fun Vector3.Companion.uniforms(count: Int, Vector3.uniform(min, max, random)
min: Vector3 = -ONE, }
max: Vector3 = ONE,
random: Random = Random.Default): List<Vector3> =
List(count) { fun Vector3.Companion.uniforms(count: Int,
Vector3.uniform(min, max, random) min: Vector3 = -ONE,
} max: Vector3 = ONE,
random: Random = Random.Default): List<Vector3> =
fun Vector3.Companion.uniformsRing(count: Int, List(count) {
innerRadius: Double = 0.0, outerRadius: Double = 1.0, Vector3.uniform(min, max, random)
random: Random = Random.Default): List<Vector3> = }
List(count) {
Vector3.uniformRing(innerRadius, outerRadius, random) fun Vector3.Companion.uniformsRing(count: Int,
} innerRadius: Double = 0.0, outerRadius: Double = 1.0,
random: Random = Random.Default): List<Vector3> =
List(count) {
fun Vector4.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Vector4 = Vector3.uniformRing(innerRadius, outerRadius, random)
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), fun Vector4.Companion.uniform(min: Double = -1.0, max: Double = 1.0, random: Random = Random.Default): Vector4 =
Double.uniform(min.y, max.y, random), Vector4.uniform(Vector4(min, min, min, min), Vector4(max, max, max, max), random)
Double.uniform(min.z, max.z, random),
Double.uniform(min.w, max.w, 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),
fun Vector4.Companion.uniformRing(innerRadius: Double = 0.0, Double.uniform(min.z, max.z, random),
outerRadius: Double = 1.0, Double.uniform(min.w, max.w, random))
random: Random = Random.Default): Vector4 { }
while (true) {
uniform(-outerRadius, outerRadius, random).let { fun Vector4.Companion.uniformRing(innerRadius: Double = 0.0,
val squaredLength = it.squaredLength outerRadius: Double = 1.0,
if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) { random: Random = Random.Default): Vector4 {
return it while (true) {
} uniform(-outerRadius, outerRadius, random).let {
} val squaredLength = it.squaredLength
} if (squaredLength >= innerRadius * innerRadius && squaredLength < outerRadius * outerRadius) {
} return it
}
}
}
}

39
orx-noise/src/main/kotlin/ValueNoise2D.kt
View File

@@ -1,21 +1,20 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
fun valueLinear(seed: Int, x:Double, y:Double) = value(seed, x, y, ::linear) 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 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) 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 {
inline fun value(seed: Int, x: Double, y: Double, crossinline interpolation: (Double) -> Double = ::linear): Double { val x0 = x.fastFloor()
val x0 = x.fastFloor() val y0 = y.fastFloor()
val y0 = y.fastFloor() val x1 = x0 + 1
val x1 = x0 + 1 val y1 = y0 + 1
val y1 = y0 + 1
val xs = interpolation(x - x0)
val xs = interpolation(x - x0) val ys = interpolation(y - y0)
val ys = interpolation(y - y0)
val xf0 = lerp(valCoord2D(seed, x0, y0), valCoord2D(seed, x1, y0), xs)
val xf0 = lerp(valCoord2D(seed, x0, y0), valCoord2D(seed, x1, y0), xs) val xf1 = lerp(valCoord2D(seed, x0, y1), valCoord2D(seed, x1, y1), xs)
val xf1 = lerp(valCoord2D(seed, x0, y1), valCoord2D(seed, x1, y1), xs)
return lerp(xf0, xf1, ys)
return lerp(xf0, xf1, ys)
} }

56
orx-noise/src/main/kotlin/ValueNoise3D.kt
View File

@@ -1,29 +1,29 @@
package org.openrndr.extra.noise package org.openrndr.extra.noise
fun valueLinear(seed: Int, x:Double, y:Double, z:Double) = value(seed, x, y, z, ::linear) 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 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) 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 { inline fun value(seed: Int, x: Double, y: Double, z: Double, crossinline interpolation: (Double) -> Double = ::linear): Double {
val x0 = x.fastFloor() val x0 = x.fastFloor()
val y0 = y.fastFloor() val y0 = y.fastFloor()
val z0 = z.fastFloor() val z0 = z.fastFloor()
val x1 = x0 + 1 val x1 = x0 + 1
val y1 = y0 + 1 val y1 = y0 + 1
val z1 = z0 + 1 val z1 = z0 + 1
val xs = interpolation(x - x0) val xs = interpolation(x - x0)
val ys = interpolation(y - y0) val ys = interpolation(y - y0)
val zs = interpolation(z - z0) val zs = interpolation(z - z0)
val xf00 = lerp(valCoord3D(seed, x0, y0, z0), valCoord3D(seed, x1, y0, z0), xs) 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 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 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 xf11 = lerp(valCoord3D(seed, x0, y1, z1), valCoord3D(seed, x1, y1, z1), xs)
val yf0 = lerp(xf00, xf10, ys) val yf0 = lerp(xf00, xf10, ys)
val yf1 = lerp(xf01, xf11, ys) val yf1 = lerp(xf01, xf11, ys)
return lerp(yf0, yf1, zs) return lerp(yf0, yf1, zs)
} }