[orx-noise] Refactor LinearRangeExtensions, add SimplexRangeExtensions

orx-noise/build.gradle.kts

@@ -22,6 +22,7 @@ kotlin {
                 implementation(project(":orx-hash-grid"))
                 implementation(project(":orx-parameters"))
                 implementation(project(":orx-shader-phrases"))
+                api(project(":orx-math"))
             }
         }
 

orx-noise/src/commonMain/kotlin/linearrange/LinearRangeExtensions.kt

@@ -1,7 +1,8 @@
 package org.openrndr.extra.noise.linearrange
 
 import org.openrndr.extra.noise.fhash1D
-import org.openrndr.math.*
+import org.openrndr.extra.math.linearrange.*
+import org.openrndr.math.LinearType
 import kotlin.random.Random
 
 /**

orx-noise/src/commonMain/kotlin/simplexrange/SimplexRangeExtensions.kt

@@ -0,0 +1,37 @@
+package org.openrndr.extra.noise.simplexrange
+
+import org.openrndr.math.LinearType
+import org.openrndr.extra.math.simplexrange.SimplexRange4D
+import org.openrndr.extra.math.simplexrange.SimplexRange3D
+import org.openrndr.extra.math.simplexrange.SimplexRange2D
+import kotlin.random.Random
+
+/**
+ * Generates a uniformly distributed value within the SimplexRange2D.
+ *
+ * @param random the random number generator used to produce random values.
+ * @return a value of type T sampled uniformly within the 2D simplex range.
+ */
+fun <T:LinearType<T>> SimplexRange2D<T>.uniform(random: Random): T {
+    return value(random.nextDouble(), random.nextDouble())
+}
+
+/**
+ * Generates a uniformly distributed value within the 3D simplex range.
+ *
+ * @param random the random number generator to produce the distribution.
+ * @return a value of type [T] sampled uniformly within the range.
+ */
+fun <T:LinearType<T>> SimplexRange3D<T>.uniform(random: Random): T {
+    return value(random.nextDouble(), random.nextDouble(), random.nextDouble())
+}
+
+/**
+ * Generates a uniformly distributed value within the 4D simplex range using a random generator.
+ *
+ * @param random an instance of the random number generator used to produce random values
+ * @return a value of type `T` that represents a point within the simplex range
+ */
+fun <T:LinearType<T>> SimplexRange4D<T>.uniform(random: Random): T {
+    return value(random.nextDouble(), random.nextDouble(), random.nextDouble(), random.nextDouble())
+}

orx-noise/src/jvmDemo/kotlin/linearrange/DemoLinearRange01.kt

@@ -3,7 +3,7 @@ package linearrange
 import org.openrndr.application
 import org.openrndr.color.ColorRGBa
 import org.openrndr.extra.noise.linearrange.uniform
-import org.openrndr.math.rangeTo
+import org.openrndr.extra.math.linearrange.rangeTo
 import kotlin.random.Random
 
 fun main() {

orx-noise/src/jvmDemo/kotlin/simplexrange/DemoSimplexRange2D01.kt

@@ -0,0 +1,61 @@
+package simplexrange
+
+import org.openrndr.application
+import org.openrndr.color.ColorRGBa
+import org.openrndr.extra.math.linearrange.rangeTo
+import org.openrndr.extra.math.simplexrange.SimplexRange3D
+import kotlin.random.Random
+import org.openrndr.extra.noise.simplexrange.uniform
+import org.openrndr.extra.noise.linearrange.*
+
+/**
+ * This demo creates a dynamic graphical output utilizing simplex and
+ * linear interpolation-based color ranges.
+ *
+ * Functionalities:
+ * - Defines a list of base colors converted to LAB color space for smooth interpolation.
+ * - Constructs a 3D simplex range and a 2D linear range for color sampling.
+ * - Randomly populates two sections of the screen with rectangles filled with colors
+ *   sampled from simplex and linear ranges respectively.
+ * - Draws a vertical divider line in the middle of the application window.
+ */
+fun main() {
+    application {
+        configure {
+            width = 720
+            height = 720
+        }
+        program {
+            extend {
+                val colors = listOf(ColorRGBa.BLACK, ColorRGBa.RED, ColorRGBa.GREEN, ColorRGBa.BLUE).map { it.toLABa() }
+                drawer.stroke = null
+                val sr = SimplexRange3D(colors[0], colors[1], colors[2], colors[3])
+                val lr = (colors[0]..colors[1])..(colors[2]..colors[3])
+
+                val r = Random((seconds * 2).toInt())
+
+                // Draw the simplex sampling on the left
+                drawer.rectangles {
+                    for (y in 0 until 40) {
+                        for (x in 0 until 20) {
+                            fill = sr.uniform(r).toRGBa()
+                            rectangle(x * width / 40.0, y * height / 40.0, width / 40.0, height / 40.0)
+                        }
+                    }
+                }
+
+                // Draw the bilinear sampling on the right
+                drawer.rectangles {
+                    for (y in 0 until 40) {
+                        for (x in 20 until 40) {
+                            fill = lr.uniform(r).toRGBa()
+                            rectangle(x * width / 40.0, y * height / 40.0, width / 40.0, height / 40.0)
+                        }
+                    }
+                }
+                drawer.stroke = ColorRGBa.BLACK
+                drawer.lineSegment(drawer.bounds.vertical(0.5))
+            }
+        }
+    }
+}