WIP

Author: JD557

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

@@ -99,21 +99,22 @@ object Kernel {
     private val minY = -height / 2
 
     /** Convolution function to use.
-      *  All color channels are handled the same way, with the alpha channel being forced to 255.
+      * 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: Int = constant
+      var accG: Int = constant
+      var accB: Int = constant
 
       var dMY = 0
       while (dMY < height) {
-        val dy  = minY + dMY
-        var dMX = 0
+        val dy   = minY + dMY
+        var dMX  = 0
+        val line = matrix(dMY)
         while (dMX < width) {
-          val weight = matrix(dMY)(dMX)
+          val weight = line(dMX)
           if (weight != 0) {
             val dx    = minX + dMX
             val color = getPixel(dx, dy)
@@ -128,12 +129,11 @@ object Kernel {
 
       if (normalization != 1)
         Color(
-          constant + (accR / normalization),
-          constant + (accG / normalization),
-          constant + (accB / normalization)
+          accR / normalization,
+          accG / normalization,
+          accB / normalization
         )
-      else
-        Color(constant + accR, constant + accG, constant + accB)
+      else Color(accR, accG, accB)
     }
 
     /** Creates a kernel equivalent to this one, but resized (keeping the center unchanged).
@@ -208,20 +208,24 @@ object Kernel {
     private val minY = -height / 2
 
     def apply(getPixel: (Int, Int) => Color): Color = {
-      var accR: Int = 0
-      var accG: Int = 0
-      var accB: Int = 0
-      var accA: Int = 0
+      var accR: Int = kernelR.constant
+      var accG: Int = kernelG.constant
+      var accB: Int = kernelB.constant
+      var accA: Int = kernelA.constant
 
       var dMY = 0
       while (dMY < height) {
-        val dy  = minY + dMY
-        var dMX = 0
+        val dy    = minY + dMY
+        var dMX   = 0
+        val lineR = matrixR(dMY)
+        val lineG = matrixG(dMY)
+        val lineB = matrixB(dMY)
+        val lineA = matrixA(dMY)
         while (dMX < width) {
-          val weightR = matrixR(dMY)(dMX)
-          val weightG = matrixG(dMY)(dMX)
-          val weightB = matrixB(dMY)(dMX)
-          val weightA = matrixA(dMY)(dMX)
+          val weightR = lineR(dMX)
+          val weightG = lineG(dMX)
+          val weightB = lineB(dMX)
+          val weightA = lineA(dMX)
           if (weightR != 0 || weightG != 0 || weightB != 0 || weightA != 0) {
             val dx    = minX + dMX
             val color = getPixel(dx, dy)
@@ -236,10 +240,10 @@ object Kernel {
       }
 
       Color(
-        kernelR.constant + (accR / kernelR.normalization),
-        kernelG.constant + (accG / kernelG.normalization),
-        kernelB.constant + (accB / kernelB.normalization),
-        kernelA.constant + (accA / kernelA.normalization)
+        accR / kernelR.normalization,
+        accG / kernelG.normalization,
+        accB / kernelB.normalization,
+        accA / kernelA.normalization
       )
     }
   }

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,33 +77,42 @@ 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
+    .toSurfaceView(canvasSettings.width, canvasSettings.height)
+    .precompute
     .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)
+
+  canvas.blit(image)(0, 0)
 }
 ```
 
 ### 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()
 ```