230 lines
9.4 KiB
Kotlin
230 lines
9.4 KiB
Kotlin
package org.openrndr.extra.fcurve
|
|
|
|
import org.openrndr.color.ColorRGBa
|
|
import org.openrndr.math.*
|
|
|
|
abstract class CompoundFCurve<T>(val compounds: List<FCurve?>, val compoundNames: List<String>) {
|
|
val duration: Double
|
|
get() {
|
|
return compounds.maxOf { it?.duration ?: 0.0 }
|
|
}
|
|
|
|
abstract fun value(t: Double, overrides: Map<String, Double>? = null): T
|
|
abstract fun sampler(normalized: Boolean = false): (Double) -> T
|
|
}
|
|
|
|
class BooleanFCurve(value: Pair<String, FCurve?>, val default: Boolean = true) :
|
|
CompoundFCurve<Boolean>(listOf(value.second), listOf(value.first)) {
|
|
override fun value(t: Double, overrides: Map<String, Double>?): Boolean {
|
|
val d = overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t)
|
|
return if (d != null) {
|
|
d >= 1.0
|
|
} else {
|
|
default
|
|
}
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> Boolean {
|
|
val sampler = compounds[0]?.sampler(normalized) ?: { if (default) 1.0 else 0.0 }
|
|
return { t -> sampler(t) >= 1.0 }
|
|
}
|
|
}
|
|
|
|
class DoubleFCurve(value: Pair<String, FCurve?>, val default: Double = 0.0) :
|
|
CompoundFCurve<Double>(listOf(value.second), listOf(value.first)) {
|
|
|
|
override fun value(t: Double, overrides: Map<String, Double>?): Double {
|
|
return overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t) ?: default
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> Double {
|
|
val sampler = compounds[0]?.sampler(normalized) ?: { default }
|
|
return { t -> sampler(t) }
|
|
}
|
|
}
|
|
|
|
class IntFCurve(value: Pair<String, FCurve?>, val default: Int = 0) :
|
|
CompoundFCurve<Int>(listOf(value.second), listOf(value.first)) {
|
|
|
|
override fun value(t: Double, overrides: Map<String, Double>?): Int {
|
|
val d = overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t)
|
|
return if (d != null) {
|
|
d.toInt()
|
|
} else {
|
|
default
|
|
}
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> Int {
|
|
val sampler = compounds[0]?.sampler(normalized) ?: { default.toDouble() }
|
|
return { t -> sampler(t).toInt() }
|
|
}
|
|
}
|
|
|
|
class Vector2FCurve(
|
|
x: Pair<String, FCurve?>, y: Pair<String, FCurve?>,
|
|
val default: Vector2 = Vector2.ZERO
|
|
) :
|
|
CompoundFCurve<Vector2>(listOf(x.second, y.second), listOf(x.first, y.first)) {
|
|
override fun value(t: Double, overrides: Map<String, Double>?): Vector2 {
|
|
val x = overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t) ?: default.x
|
|
val y = overrides?.get(compoundNames[1]) ?: compounds[1]?.value(t) ?: default.y
|
|
return Vector2(x, y)
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> Vector2 {
|
|
val xSampler = compounds[0]?.sampler(normalized) ?: { default.x }
|
|
val ySampler = compounds[1]?.sampler(normalized) ?: { default.y }
|
|
return { t -> Vector2(xSampler(t), ySampler(t)) }
|
|
}
|
|
}
|
|
|
|
class Vector3FCurve(
|
|
x: Pair<String, FCurve?>,
|
|
y: Pair<String, FCurve?>,
|
|
z: Pair<String, FCurve?>,
|
|
val default: Vector3 = Vector3.ZERO
|
|
) :
|
|
CompoundFCurve<Vector3>(listOf(x.second, y.second, z.second), listOf(x.first, y.first, z.first)) {
|
|
override fun value(t: Double, overrides: Map<String, Double>?): Vector3 {
|
|
val x = overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t) ?: default.x
|
|
val y = overrides?.get(compoundNames[1]) ?: compounds[1]?.value(t) ?: default.y
|
|
val z = overrides?.get(compoundNames[2]) ?: compounds[2]?.value(t) ?: default.z
|
|
return Vector3(x, y, z)
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> Vector3 {
|
|
val xSampler = compounds[0]?.sampler(normalized) ?: { default.x }
|
|
val ySampler = compounds[1]?.sampler(normalized) ?: { default.y }
|
|
val zSampler = compounds[2]?.sampler(normalized) ?: { default.z }
|
|
return { t -> Vector3(xSampler(t), ySampler(t), zSampler(t)) }
|
|
}
|
|
}
|
|
|
|
class Vector4FCurve(
|
|
x: Pair<String, FCurve?>,
|
|
y: Pair<String, FCurve?>,
|
|
z: Pair<String, FCurve?>,
|
|
w: Pair<String, FCurve?>,
|
|
val default: Vector4 = Vector4.ZERO
|
|
) :
|
|
CompoundFCurve<Vector4>(
|
|
listOf(x.second, y.second, z.second, w.second),
|
|
listOf(x.first, y.first, z.first, w.first)
|
|
) {
|
|
|
|
override fun value(t: Double, overrides: Map<String, Double>?): Vector4 {
|
|
val x = overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t) ?: default.x
|
|
val y = overrides?.get(compoundNames[1]) ?: compounds[1]?.value(t) ?: default.y
|
|
val z = overrides?.get(compoundNames[2]) ?: compounds[2]?.value(t) ?: default.z
|
|
val w = overrides?.get(compoundNames[3]) ?: compounds[3]?.value(t) ?: default.w
|
|
return Vector4(x, y, z, w)
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> Vector4 {
|
|
val xSampler = compounds[0]?.sampler(normalized) ?: { default.x }
|
|
val ySampler = compounds[1]?.sampler(normalized) ?: { default.y }
|
|
val zSampler = compounds[2]?.sampler(normalized) ?: { default.z }
|
|
val wSampler = compounds[3]?.sampler(normalized) ?: { default.w }
|
|
return { t -> Vector4(xSampler(t), ySampler(t), zSampler(t), wSampler(t)) }
|
|
}
|
|
}
|
|
|
|
class RgbFCurve(
|
|
r: Pair<String, FCurve?>,
|
|
g: Pair<String, FCurve?>,
|
|
b: Pair<String, FCurve?>,
|
|
val default: ColorRGBa = ColorRGBa.WHITE
|
|
) :
|
|
CompoundFCurve<ColorRGBa>(listOf(r.second, g.second, b.second), listOf(r.first, g.first, b.first)) {
|
|
|
|
override fun value(t: Double, overrides: Map<String, Double>?): ColorRGBa {
|
|
val r = overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t) ?: default.r
|
|
val g = overrides?.get(compoundNames[1]) ?: compounds[1]?.value(t) ?: default.g
|
|
val b = overrides?.get(compoundNames[2]) ?: compounds[2]?.value(t) ?: default.g
|
|
return ColorRGBa(r, g, b)
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> ColorRGBa {
|
|
val rSampler = compounds[0]?.sampler(normalized) ?: { default.r }
|
|
val gSampler = compounds[1]?.sampler(normalized) ?: { default.g }
|
|
val bSampler = compounds[2]?.sampler(normalized) ?: { default.b }
|
|
return { t -> ColorRGBa(rSampler(t), gSampler(t), bSampler(t)) }
|
|
}
|
|
}
|
|
|
|
class RgbaFCurve(
|
|
r: Pair<String, FCurve?>,
|
|
g: Pair<String, FCurve?>,
|
|
b: Pair<String, FCurve?>,
|
|
a: Pair<String, FCurve?>,
|
|
val default: ColorRGBa = ColorRGBa.WHITE
|
|
) :
|
|
CompoundFCurve<ColorRGBa>(
|
|
listOf(r.second, g.second, b.second, a.second),
|
|
listOf(r.first, g.first, b.first, a.first)
|
|
) {
|
|
|
|
override fun value(t: Double, overrides: Map<String, Double>?): ColorRGBa {
|
|
val r = overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t) ?: default.r
|
|
val g = overrides?.get(compoundNames[1]) ?: compounds[1]?.value(t) ?: default.g
|
|
val b = overrides?.get(compoundNames[2]) ?: compounds[2]?.value(t) ?: default.g
|
|
val a = overrides?.get(compoundNames[3]) ?: compounds[3]?.value(t) ?: default.alpha
|
|
return ColorRGBa(r, g, b, a)
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> ColorRGBa {
|
|
val rSampler = compounds[0]?.sampler(normalized) ?: { default.r }
|
|
val gSampler = compounds[1]?.sampler(normalized) ?: { default.g }
|
|
val bSampler = compounds[2]?.sampler(normalized) ?: { default.b }
|
|
val aSampler = compounds[3]?.sampler(normalized) ?: { default.alpha }
|
|
return { t -> ColorRGBa(rSampler(t), gSampler(t), bSampler(t), aSampler(t)) }
|
|
}
|
|
}
|
|
|
|
class PolarFCurve(
|
|
angleInDegrees: Pair<String, FCurve?>,
|
|
radius: Pair<String, FCurve?>,
|
|
val default: Polar = Polar(0.0, 1.0)
|
|
) :
|
|
CompoundFCurve<Polar>(listOf(angleInDegrees.second, radius.second), listOf(angleInDegrees.first, radius.first)) {
|
|
|
|
override fun value(t: Double, overrides: Map<String, Double>?): Polar {
|
|
val theta = overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t) ?: default.theta
|
|
val radius = overrides?.get(compoundNames[1]) ?: compounds[1]?.value(t) ?: default.radius
|
|
return Polar(theta, radius)
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> Polar {
|
|
val angleSampler = compounds[0]?.sampler(normalized) ?: { default.theta }
|
|
val radiusSampler = compounds[1]?.sampler(normalized) ?: { default.radius }
|
|
return { t -> Polar(angleSampler(t), radiusSampler(t)) }
|
|
}
|
|
}
|
|
|
|
class SphericalFCurve(
|
|
thetaInDegrees: Pair<String, FCurve?>,
|
|
phiInDegrees: Pair<String, FCurve?>,
|
|
radius: Pair<String, FCurve?>,
|
|
val default: Spherical = Spherical(0.0, 1.0, 1.0)
|
|
) :
|
|
CompoundFCurve<Spherical>(
|
|
listOf(thetaInDegrees.second, phiInDegrees.second, radius.second),
|
|
listOf(thetaInDegrees.first, phiInDegrees.first, radius.first)
|
|
) {
|
|
override fun value(t: Double, overrides: Map<String, Double>?): Spherical {
|
|
val theta = overrides?.get(compoundNames[0]) ?: compounds[0]?.value(t) ?: default.theta
|
|
val phi = overrides?.get(compoundNames[1]) ?: compounds[1]?.value(t) ?: default.phi
|
|
val radius = overrides?.get(compoundNames[2]) ?: compounds[2]?.value(t) ?: default.radius
|
|
return Spherical(theta, phi, radius)
|
|
}
|
|
|
|
override fun sampler(normalized: Boolean): (Double) -> Spherical {
|
|
val thetaSampler = compounds[0]?.sampler(normalized) ?: { default.theta }
|
|
val phiSampler = compounds[0]?.sampler(normalized) ?: { default.theta }
|
|
val radiusSampler = compounds[2]?.sampler(normalized) ?: { default.radius }
|
|
return { t -> Spherical(thetaSampler(t), phiSampler(t), radiusSampler(t)) }
|
|
}
|
|
}
|
|
|