Bumped to version 0.0.7

version of JumpFlood with reusable color buffers

build.gradle

@@ -4,7 +4,7 @@ plugins {
 
 allprojects {
     group 'org.openrndr.extra'
-    version '0.0.6'
+    version '0.0.7'
 }
 
 repositories {

orx-jumpflood/src/main/kotlin/JumpFlood.kt

@@ -13,7 +13,12 @@ class JumpFlood : Filter(filterShaderFromUrl(resourceUrl("/shaders/gl3/jumpflood
 
 class PixelDistance : Filter(filterShaderFromUrl(resourceUrl("/shaders/gl3/pixel-distance.frag")))
 class ContourPoints : Filter(filterShaderFromUrl(resourceUrl("/shaders/gl3/contour-points.frag")))
-class Threshold : Filter(filterShaderFromUrl(resourceUrl("/shaders/gl3/threshold.frag")))
+class Threshold : Filter(filterShaderFromUrl(resourceUrl("/shaders/gl3/threshold.frag"))) {
+    var threshold by parameters
+    init {
+        threshold = 0.5
+    }
+}
 
 val encodePoints by lazy { EncodePoints() }
 val jumpFlood by lazy { JumpFlood() }
@@ -21,69 +26,75 @@ val pixelDistance by lazy { PixelDistance() }
 val contourPoints by lazy { ContourPoints() }
 val threshold by lazy { Threshold() }
 
-/** [points] is square and power of 2 */
+
-fun jumpFlood(points: ColorBuffer, coordinates: List<ColorBuffer>) {
+class JumpFlooder(val width: Int, val height: Int) {
-    encodePoints.apply(points, coordinates[0])
+    private val dimension = Math.max(width, height)
-    val exp = Math.ceil(Math.log(points.width.toDouble()) / Math.log(2.0)).toInt()
+    private val exp = Math.ceil(Math.log(dimension.toDouble()) / Math.log(2.0)).toInt()
+    private val squareDim = Math.pow(2.0, exp.toDouble()).toInt()
+
+    private val coordinates =
+            listOf(colorBuffer(squareDim, squareDim, format = ColorFormat.RG, type = ColorType.FLOAT32),
+                    colorBuffer(squareDim, squareDim, format = ColorFormat.RG, type = ColorType.FLOAT32))
+
+    private val final = renderTarget(width, height) {
+        colorBuffer(type = ColorType.FLOAT32)
+    }
+
+    val result: ColorBuffer get() = final.colorBuffer(0)
+
+    private val square = renderTarget(squareDim, squareDim) {
+        colorBuffer()
+    }
+
+    fun jumpFlood(drawer: Drawer, input: ColorBuffer) {
+        if (input.width != width || input.height != height) {
+            throw IllegalArgumentException("dimensions mismatch")
+        }
+
+        drawer.isolatedWithTarget(square) {
+            drawer.ortho(square)
+            drawer.view = Matrix44.IDENTITY
+            drawer.model = Matrix44.IDENTITY
+            drawer.image(input)
+        }
+        encodePoints.apply(square.colorBuffer(0), coordinates[0])
+        val exp = Math.ceil(Math.log(input.width.toDouble()) / Math.log(2.0)).toInt()
         for (i in 0 until exp) {
             jumpFlood.step = i
             jumpFlood.apply(coordinates[i % 2], coordinates[(i + 1) % 2])
         }
-}
-
-fun jumpFlood(drawer: Drawer, points: ColorBuffer): ColorBuffer {
-    val dimension = Math.max(points.width, points.height)
-    val exp = Math.ceil(Math.log(dimension.toDouble()) / Math.log(2.0)).toInt()
-    val squareDim = Math.pow(2.0, exp.toDouble()).toInt()
-
-    val rt = renderTarget(squareDim, squareDim) {
-        colorBuffer()
-    }
-
-    val coordinates =
-            listOf(colorBuffer(squareDim, squareDim, type = ColorType.FLOAT32),
-                    colorBuffer(squareDim, squareDim, type = ColorType.FLOAT32))
-
-    drawer.isolatedWithTarget(rt) {
-        drawer.ortho(rt)
-        drawer.view = Matrix44.IDENTITY
-        drawer.model = Matrix44.IDENTITY
-        drawer.image(points)
-    }
-
-
-    jumpFlood(rt.colorBuffer(0), coordinates)
-
-//    encodePoints.apply(rt.colorBuffer(0), coordinates[0])
-//
-//
-//    for (i in 0 until exp) {
-//        jumpFlood.step = i
-//        jumpFlood.apply(coordinates[i % 2], coordinates[(i + 1) % 2])
-//
-//    }
-
-    val final = renderTarget(points.width, points.height) {
-        colorBuffer(type = ColorType.FLOAT32)
-    }
 
         pixelDistance.apply(coordinates[exp % 2], coordinates[exp % 2])
-
         drawer.isolatedWithTarget(final) {
             drawer.ortho(final)
             drawer.view = Matrix44.IDENTITY
             drawer.model = Matrix44.IDENTITY
             drawer.image(coordinates[exp % 2])
         }
+    }
 
+    fun destroy(destroyFinal: Boolean = true) {
         coordinates.forEach { it.destroy() }
 
-    rt.colorBuffer(0).destroy()
+        square.colorBuffer(0).destroy()
-    rt.detachColorBuffers()
+        square.detachColorBuffers()
-    rt.destroy()
+        square.destroy()
 
-    val fcb = final.colorBuffer(0)
+        if (destroyFinal) {
-    final.detachColorBuffers()
+            final.colorBuffer(0).destroy()
-    final.destroy()
+        }
-    return fcb
+        final.detachColorBuffers()
+
+        final.destroy()
+
+    }
+
+}
+
+fun jumpFlood(drawer: Drawer, points: ColorBuffer): ColorBuffer {
+    val jumpFlooder = JumpFlooder(points.width, points.height)
+    jumpFlooder.jumpFlood(drawer, points)
+    val result = jumpFlooder.result
+    jumpFlooder.destroy(false)
+    return result
 }

orx-jumpflood/src/main/resources/shaders/gl3/contour-points.frag

@@ -6,15 +6,15 @@ in vec2 v_texCoord0;
 out vec4 o_color;
 
 void main() {
-    vec2 step = 1.0 / textureSize(tex0, 0);
+    vec2 stepSize = 1.0 / textureSize(tex0, 0);
     float ref = step(0.5 , texture(tex0, v_texCoord0).r);
     vec4 outc = vec4(-1.0, -1.0, 0.0, 1.0);
 
     float contour = 0.0;
     for (int y = -1; y <= 1; ++y) {
         for (int x = -1; x <= 1; ++x) {
-            float smp = step(0.5, texture(tex0, v_texCoord0 + vec2(x,y) * step).r);
+            float smp = step(0.5, texture(tex0, v_texCoord0 + vec2(x,y) * stepSize).r);
-            if (smp != ref) {
+            if (smp != ref && ref == 1.0) {
                 contour = 1.0;
             }
         }

orx-jumpflood/src/main/resources/shaders/gl3/pixel-distance.frag

@@ -7,9 +7,9 @@ out vec4 o_color;
 
 void main() {
     vec2 size = textureSize(tex0, 0);
-    vec2 pixelPosition = v_texCoord0 * size;
+    vec2 pixelPosition = v_texCoord0;
-    vec2 centroidPixelPosition = texture(tex0, v_texCoord0).xy * size;
+    vec2 centroidPixelPosition = texture(tex0, v_texCoord0).xy;
-    vec2 pixelDistance = centroidPixelPosition - pixelPosition;
+    vec2 pixelDistance = (centroidPixelPosition - pixelPosition) * size;
 
     o_color = vec4(pixelDistance, 0.0, 1.0);
 }

orx-jumpflood/src/main/resources/shaders/gl3/threshold.frag

@@ -7,7 +7,5 @@ out vec4 o_color;
 
 void main() {
     float ref = step(threshold , dot( vec3(1.0/3.0), texture(tex0, v_texCoord0).rgb ));
-
-
     o_color = vec4(ref, ref, ref, 1.0);
 }