Merge pull request #19 from guzba/master

inplace blur, faster fill, simpler SetSat

src/pixie/blends.nim

@@ -1,6 +1,9 @@
 ## Blending modes.
 import chroma, math, algorithm
 
+# See https://www.w3.org/TR/compositing-1/
+# See https://www.khronos.org/registry/OpenGL/extensions/KHR/KHR_blend_equation_advanced.txt
+
 type BlendMode* = enum
   bmNormal
   bmDarken
@@ -312,41 +315,9 @@ proc Sat(C: Color): float32 {.inline.} =
   max([C.r, C.g, C.b]) - min([C.r, C.g, C.b])
 
 proc SetSat(C: Color, s: float32): Color {.inline.} =
-  var arr = [(C.r, 0), (C.g, 1), (C.b, 2)]
+  let satC = Sat(C)
-  # TODO: Don't rely on sort.
+  if satC > 0:
-  arr.sort()
+    result = (C - min([C.r, C.g, C.b])) * s / satC
-  var
-    Cmin = arr[0][0]
-    Cmid = arr[1][0]
-    Cmax = arr[2][0]
-  if Cmax > Cmin:
-    Cmid = (((Cmid - Cmin) * s) / (Cmax - Cmin))
-    Cmax = s
-  else:
-    Cmid = 0
-    Cmax = 0
-  Cmin = 0
-
-  if arr[0][1] == 0:
-    result.r = Cmin
-  if arr[1][1] == 0:
-    result.r = Cmid
-  if arr[2][1] == 0:
-    result.r = Cmax
-
-  if arr[0][1] == 1:
-    result.g = Cmin
-  if arr[1][1] == 1:
-    result.g = Cmid
-  if arr[2][1] == 1:
-    result.g = Cmax
-
-  if arr[0][1] == 2:
-    result.b = Cmin
-  if arr[1][1] == 2:
-    result.b = Cmid
-  if arr[2][1] == 2:
-    result.b = Cmax
 
 proc alphaFix(Cb, Cs, mixed: Color): Color {.inline.} =
   let ab = Cb.a

src/pixie/images.nim

@@ -1,4 +1,4 @@
-import chroma, blends, vmath, common
+import chroma, blends, vmath, common, system/memory
 
 type
   Image* = ref object
@@ -70,8 +70,11 @@ proc `[]=`*(image: Image, x, y: int, rgba: ColorRGBA) {.inline.} =
 
 proc fill*(image: Image, rgba: ColorRgba) =
   ## Fills the image with a solid color.
-  for c in image.data.mitems:
+  if rgba.r == rgba.g and rgba.r == rgba.b and rgba.r == rgba.a:
-    c = rgba
+    nimSetMem(image.data[0].addr, rgba.r.cint, image.data.len * 4)
+  else:
+    for c in image.data.mitems:
+      c = rgba
 
 proc invert*(image: Image) =
   ## Inverts all of the colors and alpha.
@@ -206,7 +209,7 @@ proc resize*(srcImage: Image, width, height: int): Image =
 
 proc blur*(image: Image, radius: float32): Image =
   ## Applies Gaussian blur to the image given a radius.
-  let radius = radius.int
+  let radius = round(radius).int
   if radius == 0:
     return image.copy()
 
@@ -264,11 +267,11 @@ proc blur*(image: Image, radius: float32): Image =
 
   return blurY
 
-proc blurAlpha*(image: Image, radius: float32): Image =
+proc blurAlpha*(image: Image, radius: float32) =
   ## Applies Gaussian blur to the image given a radius.
-  let radius = radius.int
+  let radius = round(radius).int
   if radius == 0:
-    return image.copy()
+    return
 
   # Compute lookup table for 1d Gaussian kernel.
   var
@@ -294,8 +297,7 @@ proc blurAlpha*(image: Image, radius: float32): Image =
         alpha += c2.a.float32 * a
       blurX.setRgbaUnsafe(x, y, rgba(0, 0, 0, alpha.uint8))
 
-  # Blur in the Y direction.
+  # Blur in the Y direction and modify image.
-  var blurY = newImage(image.width, image.height)
   for y in 0 ..< image.height:
     for x in 0 ..< image.width:
       var alpha: float32
@@ -303,32 +305,32 @@ proc blurAlpha*(image: Image, radius: float32): Image =
         let c2 = blurX[x, y + yb]
         let a = lookup[yb + radius]
         alpha += c2.a.float32 * a
-      blurY.setRgbaUnsafe(x, y, rgba(0, 0, 0, alpha.uint8))
+      image.setRgbaUnsafe(x, y, rgba(0, 0, 0, alpha.uint8))
 
-  return blurY
+proc shift*(image: Image, offset: Vec2) =
-
-proc shift*(image: Image, offset: Vec2): Image =
   ## Shifts the image by offset.
-  result = newImage(image.width, image.height)
+  let copy = image.copy() # Copy to read from.
-  result.draw(image, offset)
+  image.fill(rgba(0, 0, 0, 0)) # Reset this for being drawn to.
+  image.draw(copy, offset) # Draw copy into image.
 
-proc spread*(image: Image, spread: float32): Image =
+proc spread*(image: Image, spread: float32) =
   ## Grows the image as a mask by spread.
-  result = newImage(image.width, image.height)
+  let
+    copy = image.copy()
+    spread = round(spread).int
   assert spread > 0
-  for y in 0 ..< result.height:
+  for y in 0 ..< image.height:
-    for x in 0 ..< result.width:
+    for x in 0 ..< image.width:
       var maxAlpha = 0.uint8
       block blurBox:
-        for bx in -spread.int .. spread.int:
+        for bx in -spread .. spread:
-          for by in -spread.int .. spread.int:
+          for by in -spread .. spread:
-            # if vec2(bx.float32, by.float32).length < spread:
+            let alpha = copy[x + bx, y + by].a
-            let alpha = image[x + bx, y + by].a
             if alpha > maxAlpha:
               maxAlpha = alpha
             if maxAlpha == 255:
               break blurBox
-      result[x, y] = rgba(0, 0, 0, maxAlpha)
+      image[x, y] = rgba(0, 0, 0, maxAlpha)
 
 proc shadow*(
   mask: Image,
@@ -339,11 +341,11 @@ proc shadow*(
   ## Create a shadow of the image with the offset, spread and blur.
   var shadow = mask
   if offset != vec2(0, 0):
-    shadow = shadow.shift(offset)
+    shadow.shift(offset)
   if spread > 0:
-    shadow = shadow.spread(spread)
+    shadow.spread(spread)
   if blur > 0:
-    shadow = shadow.blurAlpha(blur)
+    shadow.blurAlpha(blur)
   result = newImage(mask.width, mask.height)
   result.fill(color)
   result.draw(shadow, blendMode = bmMask)