WIP

Author: JD557

core/shared/src/main/scala/eu/joaocosta/minart/graphics/Kernel.scala

@@ -98,15 +98,19 @@ object Kernel {
     private val minX = -width / 2
     private val minY = -height / 2
 
+    // "Division by Invariant Integers using Multiplication" https://gmplib.org/~tege/divcnst-pldi94.pdf
+    private val reciprocal: Long = (0xffffffffL / normalization) + 1
+    private val bias: Long       = normalization / 2
+
     /** Convolution function to use.
       *  All color channels are handled the same way, with the alpha channel being forced to 255.
       *
       * Use as `plane.coflatMap(kernel)`
       */
     def apply(getPixel: (Int, Int) => Color): Color = {
-      var accR: Int = 0
-      var accG: Int = 0
-      var accB: Int = 0
+      var accR: Long = 0
+      var accG: Long = 0
+      var accB: Long = 0
 
       var dMY = 0
       while (dMY < height) {
@@ -126,14 +130,19 @@ object Kernel {
         dMY += 1
       }
 
-      if (normalization != 1)
+      if (normalization != 1) {
+        /*Color(
+          constant + (((accR + bias) * reciprocal) >> 32).toInt,
+          constant + (((accG + bias) * reciprocal) >> 32).toInt,
+          constant + (((accB + bias) * reciprocal) >> 32).toInt
+        )*/
         Color(
-          constant + (accR / normalization),
-          constant + (accG / normalization),
-          constant + (accB / normalization)
+          constant + (accR.toInt / normalization),
+          constant + (accG.toInt / normalization),
+          constant + (accB.toInt / normalization)
         )
-      else
-        Color(constant + accR, constant + accG, constant + accB)
+      } else
+        Color(constant + accR.toInt, constant + accG.toInt, constant + accB.toInt)
     }
 
     /** Creates a kernel equivalent to this one, but resized (keeping the center unchanged).

examples/snapshot/09-surface-views.md

@@ -64,7 +64,7 @@ We could use a simple function, but Minart already provides some optimized kerne
 out of the box.
 
 ```scala
-val blurKernel = Kernel.averageBlur(3, 3)
+val blurKernel = Kernel.averageBlur(9, 9)
 
 ```
 
@@ -77,15 +77,7 @@ def application(t: Double, canvas: Canvas): Unit = {
   val zoom     = 1.0 / (frameSin + 2.0)
 
   val image = updatedBitmap.view.repeating // Create an infinite Plane from our surface
-    .scale(zoom, zoom)  // Scale
     .coflatMap(blurKernel) // Average blur
-    .rotate(t) // Rotate
-    .contramap((x, y) => (x + (5 * Math.sin(t + y / 10.0)).toInt, y)) // Wobbly effect
-    .flatMap(color =>
-      (x, y) => // Checkerboard effect
-        if (x % 32 < 16 != y % 32 < 16) color.invert
-        else color
-    )
 
   canvas.blitPlane(image)(0, 0)
 }
@@ -94,16 +86,31 @@ def application(t: Double, canvas: Canvas): Unit = {
 ### Putting it all together
 
 ```scala
-val canvasSettings = Canvas.Settings(width = 128, height = 128, scale = Some(4), clearColor = Color(0, 0, 0))
+val frameCounter = {
+  var frameNumber: Int = 0
+  var timer            = System.currentTimeMillis
+  () => {
+    frameNumber += 1
+    if (frameNumber % 10 == 0) {
+      val currTime = System.currentTimeMillis()
+      val fps      = 10.0 / ((currTime - timer) / 1000.0)
+      println("FPS:" + fps)
+      timer = System.currentTimeMillis()
+    }
+  }
+}
+
+val canvasSettings = Canvas.Settings(width = 512, height = 512, scale = Some(1), clearColor = Color(0, 0, 0))
 
 AppLoop
   .statefulRenderLoop((t: Double) => (canvas: Canvas) => {
+      frameCounter()
       canvas.clear()
       application(t, canvas)
       canvas.redraw()
       t + 0.01
     }
   )
-  .configure(canvasSettings, LoopFrequency.hz60, 0)
+  .configure(canvasSettings, LoopFrequency.Uncapped, 0)
   .run()
 ```