Merge pull request #16 from guzba/master

from chatting

src/pixie/blends.nim

@@ -248,7 +248,7 @@ proc mix*(blendMode: BlendMode, target, blend: Color): Color =
   result.b /= result.a
 
 proc mix*(blendMode: BlendMode, dest, src: ColorRGBA): ColorRGBA {.inline.} =
-  return blendMode.mix(dest.color, src.color).rgba
+  blendMode.mix(dest.color, src.color).rgba
 
   # TODO: Fix fast paths
   # if blendMode == Normal:
@@ -271,15 +271,14 @@ proc mix*(blendMode: BlendMode, dest, src: ColorRGBA): ColorRGBA {.inline.} =
   # else:
   #   return blendMode.mix(target.color, blend.color).rgba
 
-proc multiply(Cb, Cs: float32): float32 {.inline.} =
-  Cb * Cs
-
 proc screen(Cb, Cs: float32): float32 {.inline.} =
   1 - (1 - Cb) * (1 - Cs)
 
 proc hardLight(Cb, Cs: float32): float32 {.inline.} =
-  if Cs <= 0.5: multiply(Cb, 2 * Cs)
+  if Cs <= 0.5:
-  else: screen(Cb, 2 * Cs - 1)
+    Cb * 2 * Cs
+  else:
+    screen(Cb, 2 * Cs - 1)
 
 proc softLight(a, b: float32): float32 {.inline.} =
   ## Pegtop
@@ -365,7 +364,7 @@ proc blendDarken(Cb, Cs: float32): float32 {.inline.} =
   min(Cb, Cs)
 
 proc blendMultiply(Cb, Cs: float32): float32 {.inline.} =
-  multiply(Cb, Cs)
+  Cb * Cs
 
 proc blendLinearBurn(Cb, Cs: float32): float32 {.inline.} =
   Cb + Cs - 1
@@ -675,7 +674,6 @@ proc mix2*(blendMode: BlendMode, dest, src: ColorRGBA): ColorRGBA {.inline.} =
   of bmIntersectMask: blendIntersectMask(dest, src)
   of bmExcludeMask: blendExcludeMask(dest, src)
 
-
 proc mixStatic*(blendMode: static[BlendMode], dest, src: ColorRGBA): ColorRGBA {.inline.} =
   when blendMOde == bmNormal: blendNormal(dest, src)
   elif blendMOde == bmDarken: blendDarken(dest, src)

src/pixie/images.nim

@@ -6,8 +6,8 @@ type
     width*, height*: int
     data*: seq[ColorRGBA]
 
-proc draw*(a: Image, b: Image, mat: Mat3, blendMode = bmNormal)
+proc draw*(a, b: Image, mat: Mat3, blendMode = bmNormal)
-proc draw*(a: Image, b: Image, pos = vec2(0, 0), blendMode = bmNormal)
+proc draw*(a, b: Image, pos = vec2(0, 0), blendMode = bmNormal) {.inline.}
 
 proc newImage*(width, height: int): Image =
   ## Creates a new image with appropriate dimensions.
@@ -47,8 +47,7 @@ proc `$`*(image: Image): string =
 
 proc inside*(image: Image, x, y: int): bool {.inline.} =
   ## Returns true if (x, y) is inside the image.
-  x >= 0 and x < image.width and
+  x >= 0 and x < image.width and y >= 0 and y < image.height
-  y >= 0 and y < image.height
 
 proc inside1px*(image: Image, x, y: float): bool {.inline.} =
   ## Returns true if (x, y) is inside the image.
@@ -66,7 +65,7 @@ proc getRgbaUnsafe*(image: Image, x, y: int): ColorRGBA {.inline.} =
 proc getAddr*(image: Image, x, y: int): pointer {.inline.} =
   ## Gets a address of the color from (x, y) coordinates.
   ## Unsafe make sure x, y are in bounds.
-  addr image.data[image.width * y + x]
+  image.data[image.width * y + x].addr
 
 proc `[]`*(image: Image, x, y: int): ColorRGBA {.inline.} =
   ## Gets a pixel at (x, y) or returns transparent black if outside of bounds.
@@ -85,19 +84,17 @@ proc `[]=`*(image: Image, x, y: int, rgba: ColorRGBA) {.inline.} =
   if image.inside(x, y):
     image.setRgbaUnsafe(x, y, rgba)
 
-proc newImageFill*(width, height: int, rgba: ColorRgba): Image =
-  ## Fills the image with a solid color.
-  result = newImageNoInit(width, height)
-  for y in 0 ..< result.height:
-    for x in 0 ..< result.width:
-      result.setRgbaUnsafe(x, y, rgba)
-
 proc fill*(image: Image, rgba: ColorRgba) =
   ## Fills the image with a solid color.
   for y in 0 ..< image.height:
     for x in 0 ..< image.width:
       image.setRgbaUnsafe(x, y, rgba)
 
+proc newImageFill*(width, height: int, rgba: ColorRgba): Image =
+  ## Fills the image with a solid color.
+  result = newImageNoInit(width, height)
+  result.fill(rgba)
+
 proc invert*(image: Image) =
   ## Inverts all of the colors and alpha.
   for y in 0 ..< image.height:
@@ -222,25 +219,27 @@ proc getRgbaSmooth*(image: Image, x, y: float32): ColorRGBA {.inline.} =
 
   return finalMix.fromAlphy().rgba()
 
-proc hasEffect*(blendMode: BlendMode, rgba: ColorRGBA): bool =
+# @andre: unused, delete?
-  ## Returns true if applying rgba with current blend mode has effect.
-  case blendMode
-  of bmMask:
-    rgba.a != 255
-  of bmOverwrite:
-    true
-  of bmIntersectMask:
-    true
-  else:
-    rgba.a > 0
 
-proc allowCopy*(blendMode: BlendMode): bool =
+# proc hasEffect*(blendMode: BlendMode, rgba: ColorRGBA): bool =
-  ## Returns true if applying rgba with current blend mode has effect.
+#   ## Returns true if applying rgba with current blend mode has effect.
-  case blendMode
+#   case blendMode
-  of bmIntersectMask:
+#   of bmMask:
-    false
+#     rgba.a != 255
-  else:
+#   of bmOverwrite:
-    true
+#     true
+#   of bmIntersectMask:
+#     true
+#   else:
+#     rgba.a > 0
+
+# proc allowCopy*(blendMode: BlendMode): bool =
+#   ## Returns true if applying rgba with current blend mode has effect.
+#   case blendMode
+#   of bmIntersectMask:
+#     false
+#   else:
+#     true
 
 proc resize*(srcImage: Image, width, height: int): Image =
   result = newImage(width, height)
@@ -252,7 +251,6 @@ 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
@@ -369,21 +367,18 @@ proc spread*(image: Image, spread: float32): Image =
       var maxAlpha = 0.uint8
       for bx in -spread.int .. spread.int:
         for by in -spread.int .. spread.int:
-          #if vec2(bx.float32, by.float32).length < spread:
+          # if vec2(bx.float32, by.float32).length < spread:
           let alpha = image[x + bx, y + by].a
           if alpha > maxAlpha:
             maxAlpha = alpha
           if maxAlpha == 255:
             break
-        if maxAlpha == 255:
-            break
       result[x, y] = rgba(0, 0, 0, maxAlpha)
 
 proc shadow*(
   mask: Image,
   offset: Vec2,
-  spread: float32,
+  spread, blur: float32,
-  blur: float32,
   color: ColorRGBA
 ): Image =
   ## Create a shadow of the image with the offset, spread and blur.
@@ -400,11 +395,11 @@ proc shadow*(
 proc applyOpacity*(image: Image, opacity: float32): Image =
   ## Multiplies alpha of the image by opacity.
   result = newImageNoInit(image.width, image.height)
-  let op = (255 * opacity).uint8
+  let op = (255 * opacity).uint32
   for y in 0 ..< image.height:
     for x in 0 ..< image.width:
       var rgba = image.getRgbaUnsafe(x, y)
-      rgba.a = ((rgba.a.uint32 * op.uint32) div 255).clamp(0, 255).uint8
+      rgba.a = ((rgba.a.uint32 * op) div 255).clamp(0, 255).uint8
       result.setRgbaUnsafe(x, y, rgba)
 
 proc sharpOpacity*(image: Image): Image =
@@ -459,7 +454,6 @@ proc drawUberStatic(
   inPlace: static[bool],
   smooth: static[bool],
 ) =
-
   for y in 0 ..< a.height:
     var
       xMin = 0
@@ -513,13 +507,12 @@ proc drawUberStatic(
         zeroMem(c.getAddr(xMax, y), 4*(a.width - xMax))
     else:
       when not inPlace:
-        #for x in xMax ..< a.width:
+        # for x in xMax ..< a.width:
         #  result.setRgbaUnsafe(x, y, a.getRgbaUnsafe(x, y))
         if a.width - xMax > 0:
           copyMem(c.getAddr(xMax, y), a.getAddr(xMax, y), 4*(a.width - xMax))
 
-
+proc draw*(a, b: Image, mat: Mat3, blendMode: BlendMode) =
-proc draw*(a: Image, b: Image, mat: Mat3, blendMode: BlendMode) =
   ## Draws one image onto another using matrix with color blending.
 
   var
@@ -558,7 +551,6 @@ proc draw*(a: Image, b: Image, mat: Mat3, blendMode: BlendMode) =
     mat[2, 0].fractional == 0.0 and mat[2, 1].fractional == 0.0)
 
   if not smooth:
-    #echo "draw ", b.width, "x", b.height, " fast"
     case blendMode
     of bmNormal: drawUberStatic(a, b, c, start, stepX, stepY, lines, bmNormal, true, false)
     of bmDarken: drawUberStatic(a, b, c, start, stepX, stepY, lines, bmDarken, true, false)
@@ -584,7 +576,6 @@ proc draw*(a: Image, b: Image, mat: Mat3, blendMode: BlendMode) =
     of bmIntersectMask: drawUberStatic(a, b, c, start, stepX, stepY, lines, bmIntersectMask, true, false)
     of bmExcludeMask: drawUberStatic(a, b, c, start, stepX, stepY, lines, bmExcludeMask, true, false)
   else:
-    #echo "draw ", b.width, "x", b.height, " smooth"
     case blendMode
     of bmNormal: drawUberStatic(a, b, c, start, stepX, stepY, lines, bmNormal, true, true)
     of bmDarken: drawUberStatic(a, b, c, start, stepX, stepY, lines, bmDarken, true, true)
@@ -610,5 +601,7 @@ proc draw*(a: Image, b: Image, mat: Mat3, blendMode: BlendMode) =
     of bmIntersectMask: drawUberStatic(a, b, c, start, stepX, stepY, lines, bmIntersectMask, true, true)
     of bmExcludeMask: drawUberStatic(a, b, c, start, stepX, stepY, lines, bmExcludeMask, true, true)
 
-proc draw*(a: Image, b: Image, pos = vec2(0, 0), blendMode = bmNormal) =
+proc draw*(
+  a, b: Image, pos = vec2(0, 0), blendMode = bmNormal
+) {.inline.} =
   a.draw(b, translate(pos), blendMode)

src/pixie/masks.nim

@@ -25,36 +25,36 @@ proc `$`*(mask: Mask): string =
   ## Display the mask size and channels.
   "<Mask " & $mask.width & "x" & $mask.height & ">"
 
-proc getRgbaUnsafe*(mask: Mask, x, y: int): uint8 {.inline.} =
+proc getUnsafe*(mask: Mask, x, y: int): uint8 {.inline.} =
-  ## Gets a alpha from (x, y) coordinates.
+  ## Gets a value from (x, y) coordinates.
   ## * No bounds checking *
   ## Make sure that x, y are in bounds.
   ## Failure in the assumptions will case unsafe memory reads.
   result = mask.data[mask.width * y + x]
 
 proc `[]`*(mask: Mask, x, y: int): uint8 {.inline.} =
-  ## Gets a pixel at (x, y) or returns transparent black if outside of bounds.
+  ## Gets the value at (x, y) or returns transparent black if outside of bounds.
   if mask.inside(x, y):
-    return mask.getRgbaUnsafe(x, y)
+    return mask.getUnsafe(x, y)
 
-proc setRgbaUnsafe*(mask: Mask, x, y: int, alpha: uint8) {.inline.} =
+proc setUnsafe*(mask: Mask, x, y: int, value: uint8) {.inline.} =
-  ## Sets a color from (x, y) coordinates.
+  ## Sets the value from (x, y) coordinates.
   ## * No bounds checking *
   ## Make sure that x, y are in bounds.
   ## Failure in the assumptions will case unsafe memory writes.
-  mask.data[mask.width * y + x] = alpha
+  mask.data[mask.width * y + x] = value
 
-proc `[]=`*(mask: Mask, x, y: int, alpha: uint8) {.inline.} =
+proc `[]=`*(mask: Mask, x, y: int, value: uint8) {.inline.} =
-  ## Sets a pixel at (x, y) or does nothing if outside of bounds.
+  ## Sets the value at (x, y) or does nothing if outside of bounds.
   if mask.inside(x, y):
-    mask.setRgbaUnsafe(x, y, alpha)
+    mask.setUnsafe(x, y, value)
 
-proc fill*(mask: Mask, alpha: uint8) =
+proc fill*(mask: Mask, value: uint8) =
-  ## Fills the mask with a solid color.
+  ## Fills the mask with the parameter value.
   for i in 0 ..< mask.data.len:
-    mask.data[i] = alpha
+    mask.data[i] = value
 
 proc invert*(mask: Mask) =
-  ## Inverts all of the colors and alpha.
+  ## Inverts the entire mask value.
-  for alpha in mask.data.mitems:
+  for value in mask.data.mitems:
-    alpha = 255 - alpha
+    value = 255 - value

src/pixie/paths.nim

@@ -132,7 +132,7 @@ proc parsePath*(path: string): Path =
           number = $c
       of ' ', ',', '\r', '\n', '\t':
         finishDigit()
-      else:
+      else: # TODO: still needed?
         if command == Move and numbers.len == 2:
           finishCommand()
           command = Line
@@ -619,6 +619,7 @@ proc fillPolygons*(
       var colorWithAlpha = color
       colorWithAlpha.a = uint8(clamp(a, 0, 1) * 255.0)
       result[x, y] = colorWithAlpha
+      # TODO: don't double-clamp and can probably be unsafe?
 
 {.pop.}