From a519ecdf133f58a96bc7ec68529f8ca48e8bbcbe Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <ryan@guzba.com>
Date: Thu, 16 Jun 2022 01:48:34 -0500
Subject: [PATCH 1/5] implement the last 2 mask:mask blends simd
---
src/pixie/blends.nim | 41 ++++++++++++++++++++++++++++++++++++++++-
src/pixie/paths.nim | 19 +++++++++++++++++--
2 files changed, 57 insertions(+), 3 deletions(-)
diff --git a/src/pixie/blends.nim b/src/pixie/blends.nim
index 9f0e652..6b04a32 100644
--- a/src/pixie/blends.nim
+++ b/src/pixie/blends.nim
@@ -647,24 +647,63 @@ when defined(amd64) and allowSimd:
mm_or_si128(backdropEven, mm_slli_epi16(backdropOdd, 8))
+ proc maskBlendSubtractSimd*(backdrop, source: M128i): M128i {.inline.} =
+ let
+ oddMask = mm_set1_epi16(cast[int16](0xff00))
+ vec255 = mm_set1_epi8(255)
+ div255 = mm_set1_epi16(cast[int16](0x8081))
+
+ let sourceMinus255 = mm_sub_epi8(vec255, source)
+
+ var
+ multiplierEven = mm_slli_epi16(sourceMinus255, 8)
+ multiplierOdd = mm_and_si128(sourceMinus255, oddMask)
+ backdropEven = mm_slli_epi16(backdrop, 8)
+ backdropOdd = mm_and_si128(backdrop, oddMask)
+
+ backdropEven = mm_mulhi_epu16(backdropEven, multiplierEven)
+ backdropOdd = mm_mulhi_epu16(backdropOdd, multiplierOdd)
+
+ backdropEven = mm_srli_epi16(mm_mulhi_epu16(backdropEven, div255), 7)
+ backdropOdd = mm_srli_epi16(mm_mulhi_epu16(backdropOdd, div255), 7)
+
+ mm_or_si128(backdropEven, mm_slli_epi16(backdropOdd, 8))
+
+ proc maskBlendExcludeSimd*(backdrop, source: M128i): M128i {.inline.} =
+ mm_sub_epi8(mm_max_epu8(backdrop, source), mm_min_epu8(backdrop, source))
+
proc maskBlendNormalSimdMasker(backdrop, source: M128i): M128i =
maskBlendNormalSimd(backdrop, source)
proc maskBlendMaskSimdMasker(backdrop, source: M128i): M128i =
maskBlendMaskSimd(backdrop, source)
+ proc maskBlendExcludeSimdMasker(backdrop, source: M128i): M128i =
+ maskBlendExcludeSimd(backdrop, source)
+
+ proc maskBlendSubtractSimdMasker(backdrop, source: M128i): M128i =
+ maskBlendSubtractSimd(backdrop, source)
+
proc maskerSimd*(blendMode: BlendMode): MaskerSimd {.raises: [PixieError].} =
## Returns a blend masking function with SIMD support.
case blendMode:
of NormalBlend: maskBlendNormalSimdMasker
of MaskBlend: maskBlendMaskSimdMasker
of OverwriteBlend: overwriteSimdBlender
+ of SubtractMaskBlend: maskBlendSubtractSimdMasker
+ of ExcludeMaskBlend: maskBlendExcludeSimdMasker
else:
raise newException(PixieError, "No SIMD masker for " & $blendMode)
proc hasSimdMasker*(blendMode: BlendMode): bool {.inline, raises: [].} =
## Is there a blend masking function with SIMD support?
- blendMode in {NormalBlend, MaskBlend, OverwriteBlend}
+ blendMode in {
+ NormalBlend,
+ MaskBlend,
+ OverwriteBlend,
+ SubtractMaskBlend,
+ ExcludeMaskBlend
+ }
when defined(release):
{.pop.}
diff --git a/src/pixie/paths.nim b/src/pixie/paths.nim
index a75582b..1fc1e56 100644
--- a/src/pixie/paths.nim
+++ b/src/pixie/paths.nim
@@ -1572,6 +1572,17 @@ proc fillHits(
windingRule: WindingRule,
blendMode: BlendMode
) =
+ template simdBlob(mask: Mask, x: var int, blendProc: untyped) =
+ when allowSimd:
+ when defined(amd64):
+ let vec255 = mm_set1_epi8(255)
+ for _ in 0 ..< fillLen div 16:
+ let
+ index = mask.dataIndex(x, y)
+ backdrop = mm_loadu_si128(mask.data[index].addr)
+ mm_storeu_si128(mask.data[index].addr, blendProc(backdrop, vec255))
+ x += 16
+
case blendMode:
of NormalBlend, OverwriteBlend:
walkHits hits, numHits, windingRule, y, mask.width:
@@ -1590,13 +1601,17 @@ proc fillHits(
of SubtractMaskBlend:
walkHits hits, numHits, windingRule, y, mask.width:
- for x in fillStart ..< fillStart + fillLen:
+ var x = fillStart
+ simdBlob(mask, x, maskBlendSubtractSimd)
+ for x in x ..< fillStart + fillLen:
let backdrop = mask.unsafe[x, y]
mask.unsafe[x, y] = maskBlendSubtract(backdrop, 255)
of ExcludeMaskBlend:
walkHits hits, numHits, windingRule, y, mask.width:
- for x in fillStart ..< fillStart + fillLen:
+ var x = fillStart
+ simdBlob(mask, x, maskBlendExcludeSimd)
+ for x in x ..< fillStart + fillLen:
let backdrop = mask.unsafe[x, y]
mask.unsafe[x, y] = maskBlendExclude(backdrop, 255)
From 1d486783fa9ddd6a022810ca1e9f99158f2b8a93 Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <ryan@guzba.com>
Date: Thu, 16 Jun 2022 21:54:02 -0500
Subject: [PATCH 2/5] better names
---
src/pixie/blends.nim | 46 ++++++++++++++++++++++----------------------
src/pixie/images.nim | 10 +++++-----
src/pixie/paths.nim | 8 ++++----
3 files changed, 32 insertions(+), 32 deletions(-)
diff --git a/src/pixie/blends.nim b/src/pixie/blends.nim
index 6b04a32..4a5e49b 100644
--- a/src/pixie/blends.nim
+++ b/src/pixie/blends.nim
@@ -11,8 +11,8 @@ when defined(amd64) and allowSimd:
type
Blender* = proc(backdrop, source: ColorRGBX): ColorRGBX {.gcsafe, raises: [].}
## Function signature returned by blender.
- Masker* = proc(backdrop, source: uint8): uint8 {.gcsafe, raises: [].}
- ## Function signature returned by masker.
+ MaskBlender* = proc(backdrop, source: uint8): uint8 {.gcsafe, raises: [].}
+ ## Function signature returned by maskBlender.
when defined(release):
{.push checks: off.}
@@ -484,29 +484,29 @@ proc maskBlendExclude*(backdrop, source: uint8): uint8 {.inline.} =
## Exclude blend masks
max(backdrop, source) - min(backdrop, source)
-proc maskBlendNormalMasker(backdrop, source: uint8): uint8 =
+proc maskBlendNormalMaskBlender(backdrop, source: uint8): uint8 =
maskBlendNormal(backdrop, source)
-proc maskBlendMaskMasker(backdrop, source: uint8): uint8 =
+proc maskBlendMaskMaskBlender(backdrop, source: uint8): uint8 =
maskBlendMask(backdrop, source)
-proc maskBlendSubtractMasker(backdrop, source: uint8): uint8 =
+proc maskBlendSubtractMaskBlender(backdrop, source: uint8): uint8 =
maskBlendSubtract(backdrop, source)
-proc maskBlendExcludeMasker(backdrop, source: uint8): uint8 =
+proc maskBlendExcludeMaskBlender(backdrop, source: uint8): uint8 =
maskBlendExclude(backdrop, source)
-proc maskBlendOverwriteMasker(backdrop, source: uint8): uint8 =
+proc maskBlendOverwriteMaskBlender(backdrop, source: uint8): uint8 =
source
-proc masker*(blendMode: BlendMode): Masker {.raises: [PixieError].} =
+proc maskBlender*(blendMode: BlendMode): MaskBlender {.raises: [PixieError].} =
## Returns a blend masking function for a given blend masking mode.
case blendMode:
- of NormalBlend: maskBlendNormalMasker
- of MaskBlend: maskBlendMaskMasker
- of OverwriteBlend: maskBlendOverwriteMasker
- of SubtractMaskBlend: maskBlendSubtractMasker
- of ExcludeMaskBlend: maskBlendExcludeMasker
+ of NormalBlend: maskBlendNormalMaskBlender
+ of MaskBlend: maskBlendMaskMaskBlender
+ of OverwriteBlend: maskBlendOverwriteMaskBlender
+ of SubtractMaskBlend: maskBlendSubtractMaskBlender
+ of ExcludeMaskBlend: maskBlendExcludeMaskBlender
else:
raise newException(PixieError, "No masker for " & $blendMode)
@@ -672,30 +672,30 @@ when defined(amd64) and allowSimd:
proc maskBlendExcludeSimd*(backdrop, source: M128i): M128i {.inline.} =
mm_sub_epi8(mm_max_epu8(backdrop, source), mm_min_epu8(backdrop, source))
- proc maskBlendNormalSimdMasker(backdrop, source: M128i): M128i =
+ proc maskBlendNormalSimdMaskBlender(backdrop, source: M128i): M128i =
maskBlendNormalSimd(backdrop, source)
- proc maskBlendMaskSimdMasker(backdrop, source: M128i): M128i =
+ proc maskBlendMaskSimdMaskBlender(backdrop, source: M128i): M128i =
maskBlendMaskSimd(backdrop, source)
- proc maskBlendExcludeSimdMasker(backdrop, source: M128i): M128i =
+ proc maskBlendExcludeSimdMaskBlender(backdrop, source: M128i): M128i =
maskBlendExcludeSimd(backdrop, source)
- proc maskBlendSubtractSimdMasker(backdrop, source: M128i): M128i =
+ proc maskBlendSubtractSimdMaskBlender(backdrop, source: M128i): M128i =
maskBlendSubtractSimd(backdrop, source)
- proc maskerSimd*(blendMode: BlendMode): MaskerSimd {.raises: [PixieError].} =
+ proc maskBlenderSimd*(blendMode: BlendMode): MaskerSimd {.raises: [PixieError].} =
## Returns a blend masking function with SIMD support.
case blendMode:
- of NormalBlend: maskBlendNormalSimdMasker
- of MaskBlend: maskBlendMaskSimdMasker
+ of NormalBlend: maskBlendNormalSimdMaskBlender
+ of MaskBlend: maskBlendMaskSimdMaskBlender
of OverwriteBlend: overwriteSimdBlender
- of SubtractMaskBlend: maskBlendSubtractSimdMasker
- of ExcludeMaskBlend: maskBlendExcludeSimdMasker
+ of SubtractMaskBlend: maskBlendSubtractSimdMaskBlender
+ of ExcludeMaskBlend: maskBlendExcludeSimdMaskBlender
else:
raise newException(PixieError, "No SIMD masker for " & $blendMode)
- proc hasSimdMasker*(blendMode: BlendMode): bool {.inline, raises: [].} =
+ proc hasSimdMaskBlender*(blendMode: BlendMode): bool {.inline, raises: [].} =
## Is there a blend masking function with SIMD support?
blendMode in {
NormalBlend,
diff --git a/src/pixie/images.nim b/src/pixie/images.nim
index 1f0e26d..ac82d87 100644
--- a/src/pixie/images.nim
+++ b/src/pixie/images.nim
@@ -714,7 +714,7 @@ proc drawUber(
when type(a) is Image:
let blender = blendMode.blender()
else: # a is a Mask
- let masker = blendMode.masker()
+ let maskBlender = blendMode.maskBlender()
if blendMode == MaskBlend:
if yMin > 0:
@@ -777,7 +777,7 @@ proc drawUber(
let sample = b.getRgbaSmooth(srcPos.x, srcPos.y).a
else: # b is a Mask
let sample = b.getValueSmooth(srcPos.x, srcPos.y)
- a.unsafe[x, y] = masker(backdrop, sample)
+ a.unsafe[x, y] = maskBlender(backdrop, sample)
srcPos += dx
@@ -972,8 +972,8 @@ proc drawUber(
x += 16
sx += 16
else: # is a Mask
- if blendMode.hasSimdMasker():
- let maskerSimd = blendMode.maskerSimd()
+ if blendMode.hasSimdMaskBlender():
+ let maskerSimd = blendMode.maskBlenderSimd()
for _ in 0 ..< (xStop - xStart) div 16:
let backdrop = mm_loadu_si128(a.data[a.dataIndex(x, y)].addr)
when type(b) is Image:
@@ -1089,7 +1089,7 @@ proc drawUber(
let sample = b.unsafe[samplePos.x, samplePos.y].a
else: # b is a Mask
let sample = b.unsafe[samplePos.x, samplePos.y]
- a.unsafe[x, y] = masker(backdrop, sample)
+ a.unsafe[x, y] = maskBlender(backdrop, sample)
srcPos += dx
if blendMode == MaskBlend:
diff --git a/src/pixie/paths.nim b/src/pixie/paths.nim
index 1fc1e56..4c5455e 100644
--- a/src/pixie/paths.nim
+++ b/src/pixie/paths.nim
@@ -1443,9 +1443,9 @@ proc fillCoverage(
) =
var x = startX
when defined(amd64) and allowSimd:
- if blendMode.hasSimdMasker():
+ if blendMode.hasSimdMaskBlender():
let
- maskerSimd = blendMode.maskerSimd()
+ maskerSimd = blendMode.maskBlenderSimd()
vecZero = mm_setzero_si128()
for _ in 0 ..< coverages.len div 16:
let
@@ -1465,7 +1465,7 @@ proc fillCoverage(
mm_storeu_si128(mask.data[index].addr, vecZero)
x += 16
- let masker = blendMode.masker()
+ let maskBlender = blendMode.maskBlender()
for x in x ..< startX + coverages.len:
let coverage = coverages[x - startX]
if coverage != 0 or blendMode == ExcludeMaskBlend:
@@ -1473,7 +1473,7 @@ proc fillCoverage(
mask.unsafe[x, y] = coverage
else:
let backdrop = mask.unsafe[x, y]
- mask.unsafe[x, y] = masker(backdrop, coverage)
+ mask.unsafe[x, y] = maskBlender(backdrop, coverage)
elif blendMode == MaskBlend:
mask.unsafe[x, y] = 0
From 2f2fe303ee36ed8517af03c05936133a7a060ab5 Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <ryan@guzba.com>
Date: Thu, 16 Jun 2022 23:16:47 -0500
Subject: [PATCH 3/5] use unsafe
---
src/pixie/paths.nim | 12 ++++--------
1 file changed, 4 insertions(+), 8 deletions(-)
diff --git a/src/pixie/paths.nim b/src/pixie/paths.nim
index 4c5455e..cc158eb 100644
--- a/src/pixie/paths.nim
+++ b/src/pixie/paths.nim
@@ -1511,10 +1511,8 @@ proc fillHits(
when defined(amd64):
let colorVec = mm_set1_epi32(cast[int32](rgbx))
for _ in 0 ..< fillLen div 4:
- let
- index = image.dataIndex(x, y)
- backdrop = mm_loadu_si128(image.data[index].addr)
- mm_storeu_si128(image.data[index].addr, blendProc(backdrop, colorVec))
+ let backdrop = mm_loadu_si128(image.unsafe[x, y].addr)
+ mm_storeu_si128(image.unsafe[x, y].addr, blendProc(backdrop, colorVec))
x += 4
case blendMode:
@@ -1577,10 +1575,8 @@ proc fillHits(
when defined(amd64):
let vec255 = mm_set1_epi8(255)
for _ in 0 ..< fillLen div 16:
- let
- index = mask.dataIndex(x, y)
- backdrop = mm_loadu_si128(mask.data[index].addr)
- mm_storeu_si128(mask.data[index].addr, blendProc(backdrop, vec255))
+ let backdrop = mm_loadu_si128(mask.unsafe[x, y].addr)
+ mm_storeu_si128(mask.unsafe[x, y].addr, blendProc(backdrop, vec255))
x += 16
case blendMode:
From 52bd7bef57a7f4e9e284cecf18616e07b34ccf42 Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <ryan@guzba.com>
Date: Thu, 16 Jun 2022 23:32:19 -0500
Subject: [PATCH 4/5] walkInteger iterator
---
src/pixie/paths.nim | 96 ++++++++++++++++++++++-----------------------
1 file changed, 47 insertions(+), 49 deletions(-)
diff --git a/src/pixie/paths.nim b/src/pixie/paths.nim
index cc158eb..72c0160 100644
--- a/src/pixie/paths.nim
+++ b/src/pixie/paths.nim
@@ -1158,7 +1158,7 @@ proc maxEntryCount(partitioning: var Partitioning): int =
proc fixed32(f: float32): Fixed32 {.inline.} =
Fixed32(f * 256)
-proc integer(p: Fixed32): int {.inline.} =
+proc integer(p: Fixed32): int32 {.inline.} =
p div 256
proc trunc(p: Fixed32): Fixed32 {.inline.} =
@@ -1223,6 +1223,20 @@ iterator walk(
if prevAt != width.float32.fixed32 and count != 0:
echo "Leak detected: ", count, " @ (", prevAt, ", ", y, ")"
+iterator walkInteger(
+ hits: seq[(int32, int16)],
+ numHits: int,
+ windingRule: WindingRule,
+ y, width: int
+): (int32, int32) =
+ for (prevAt, at, count) in hits.walk(numHits, windingRule, y, width):
+ let
+ fillStart = prevAt.integer
+ fillLen = at.integer - fillStart
+ if fillLen <= 0:
+ continue
+ yield (fillStart, fillLen)
+
proc computeCoverage(
coverages: ptr UncheckedArray[uint8],
hits: var seq[(Fixed32, int16)],
@@ -1481,22 +1495,6 @@ proc fillCoverage(
mask.clearUnsafe(0, y, startX, y)
mask.clearUnsafe(startX + coverages.len, y, mask.width, y)
-template walkHits(
- hits: seq[(int32, int16)],
- numHits: int,
- windingRule: WindingRule,
- y, width: int,
- inner: untyped
-) =
- for (prevAt, at, count) in hits.walk(numHits, windingRule, y, width):
- let
- fillStart {.inject.} = prevAt.integer
- fillLen {.inject.} = at.integer - fillStart
- if fillLen <= 0:
- continue
-
- inner
-
proc fillHits(
image: Image,
rgbx: ColorRGBX,
@@ -1506,36 +1504,36 @@ proc fillHits(
windingRule: WindingRule,
blendMode: BlendMode
) =
- template simdBlob(image: Image, x: var int, blendProc: untyped) =
+ template simdBlob(image: Image, x: var int, len: int32, blendProc: untyped) =
when allowSimd:
when defined(amd64):
let colorVec = mm_set1_epi32(cast[int32](rgbx))
- for _ in 0 ..< fillLen div 4:
+ for _ in 0 ..< len div 4:
let backdrop = mm_loadu_si128(image.unsafe[x, y].addr)
mm_storeu_si128(image.unsafe[x, y].addr, blendProc(backdrop, colorVec))
x += 4
case blendMode:
of OverwriteBlend:
- walkHits hits, numHits, windingRule, y, image.width:
- fillUnsafe(image.data, rgbx, image.dataIndex(fillStart, y), fillLen)
+ for (start, len) in hits.walkInteger(numHits, windingRule, y, image.width):
+ fillUnsafe(image.data, rgbx, image.dataIndex(start, y), len)
of NormalBlend:
- walkHits hits, numHits, windingRule, y, image.width:
+ for (start, len) in hits.walkInteger(numHits, windingRule, y, image.width):
if rgbx.a == 255:
- fillUnsafe(image.data, rgbx, image.dataIndex(fillStart, y), fillLen)
+ fillUnsafe(image.data, rgbx, image.dataIndex(start, y), len)
else:
- var x = fillStart
- simdBlob(image, x, blendNormalSimd)
- for x in x ..< fillStart + fillLen:
+ var x = start
+ simdBlob(image, x, len, blendNormalSimd)
+ for x in x ..< start + len:
let backdrop = image.unsafe[x, y]
image.unsafe[x, y] = blendNormal(backdrop, rgbx)
of MaskBlend:
var filledTo = startX
- walkHits hits, numHits, windingRule, y, image.width:
+ for (start, len) in hits.walkInteger(numHits, windingRule, y, image.width):
block: # Clear any gap between this fill and the previous fill
- let gapBetween = fillStart - filledTo
+ let gapBetween = start - filledTo
if gapBetween > 0:
fillUnsafe(
image.data,
@@ -1543,12 +1541,12 @@ proc fillHits(
image.dataIndex(filledTo, y),
gapBetween
)
- filledTo = fillStart + fillLen
+ filledTo = start + len
block: # Handle this fill
if rgbx.a != 255:
- var x = fillStart
- simdBlob(image, x, blendMaskSimd)
- for x in x ..< fillStart + fillLen:
+ var x = start
+ simdBlob(image, x, len, blendMaskSimd)
+ for x in x ..< start + len:
let backdrop = image.unsafe[x, y]
image.unsafe[x, y] = blendMask(backdrop, rgbx)
@@ -1557,8 +1555,8 @@ proc fillHits(
else:
let blender = blendMode.blender()
- walkHits hits, numHits, windingRule, y, image.width:
- for x in fillStart ..< fillStart + fillLen:
+ for (start, len) in hits.walkInteger(numHits, windingRule, y, image.width):
+ for x in start ..< start + len:
let backdrop = image.unsafe[x, y]
image.unsafe[x, y] = blender(backdrop, rgbx)
@@ -1570,44 +1568,44 @@ proc fillHits(
windingRule: WindingRule,
blendMode: BlendMode
) =
- template simdBlob(mask: Mask, x: var int, blendProc: untyped) =
+ template simdBlob(mask: Mask, x: var int, len: int32, blendProc: untyped) =
when allowSimd:
when defined(amd64):
let vec255 = mm_set1_epi8(255)
- for _ in 0 ..< fillLen div 16:
+ for _ in 0 ..< len div 16:
let backdrop = mm_loadu_si128(mask.unsafe[x, y].addr)
mm_storeu_si128(mask.unsafe[x, y].addr, blendProc(backdrop, vec255))
x += 16
case blendMode:
of NormalBlend, OverwriteBlend:
- walkHits hits, numHits, windingRule, y, mask.width:
- fillUnsafe(mask.data, 255, mask.dataIndex(fillStart, y), fillLen)
+ for (start, len) in hits.walkInteger(numHits, windingRule, y, mask.width):
+ fillUnsafe(mask.data, 255, mask.dataIndex(start, y), len)
of MaskBlend:
var filledTo = startX
- walkHits hits, numHits, windingRule,y, mask.width:
- let gapBetween = fillStart - filledTo
+ for (start, len) in hits.walkInteger(numHits, windingRule, y, mask.width):
+ let gapBetween = start - filledTo
if gapBetween > 0:
fillUnsafe(mask.data, 0, mask.dataIndex(filledTo, y), gapBetween)
- filledTo = fillStart + fillLen
+ filledTo = start + len
mask.clearUnsafe(0, y, startX, y)
mask.clearUnsafe(filledTo, y, mask.width, y)
of SubtractMaskBlend:
- walkHits hits, numHits, windingRule, y, mask.width:
- var x = fillStart
- simdBlob(mask, x, maskBlendSubtractSimd)
- for x in x ..< fillStart + fillLen:
+ for (start, len) in hits.walkInteger(numHits, windingRule, y, mask.width):
+ var x = start
+ simdBlob(mask, x, len, maskBlendSubtractSimd)
+ for x in x ..< start + len:
let backdrop = mask.unsafe[x, y]
mask.unsafe[x, y] = maskBlendSubtract(backdrop, 255)
of ExcludeMaskBlend:
- walkHits hits, numHits, windingRule, y, mask.width:
- var x = fillStart
- simdBlob(mask, x, maskBlendExcludeSimd)
- for x in x ..< fillStart + fillLen:
+ for (start, len) in hits.walkInteger(numHits, windingRule, y, mask.width):
+ var x = start
+ simdBlob(mask, x, len, maskBlendExcludeSimd)
+ for x in x ..< start + len:
let backdrop = mask.unsafe[x, y]
mask.unsafe[x, y] = maskBlendExclude(backdrop, 255)
From b0303245f5306cda8a6e64fe1eb5d2cc28edbf2e Mon Sep 17 00:00:00 2001
From: Ryan Oldenburg <ryan@guzba.com>
Date: Fri, 17 Jun 2022 00:19:26 -0500
Subject: [PATCH 5/5] f
---
src/pixie/paths.nim | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/src/pixie/paths.nim b/src/pixie/paths.nim
index 72c0160..d1f2637 100644
--- a/src/pixie/paths.nim
+++ b/src/pixie/paths.nim
@@ -1158,7 +1158,7 @@ proc maxEntryCount(partitioning: var Partitioning): int =
proc fixed32(f: float32): Fixed32 {.inline.} =
Fixed32(f * 256)
-proc integer(p: Fixed32): int32 {.inline.} =
+proc integer(p: Fixed32): int {.inline.} =
p div 256
proc trunc(p: Fixed32): Fixed32 {.inline.} =
@@ -1228,7 +1228,7 @@ iterator walkInteger(
numHits: int,
windingRule: WindingRule,
y, width: int
-): (int32, int32) =
+): (int, int) =
for (prevAt, at, count) in hits.walk(numHits, windingRule, y, width):
let
fillStart = prevAt.integer
@@ -1504,7 +1504,7 @@ proc fillHits(
windingRule: WindingRule,
blendMode: BlendMode
) =
- template simdBlob(image: Image, x: var int, len: int32, blendProc: untyped) =
+ template simdBlob(image: Image, x: var int, len: int, blendProc: untyped) =
when allowSimd:
when defined(amd64):
let colorVec = mm_set1_epi32(cast[int32](rgbx))
@@ -1568,7 +1568,7 @@ proc fillHits(
windingRule: WindingRule,
blendMode: BlendMode
) =
- template simdBlob(mask: Mask, x: var int, len: int32, blendProc: untyped) =
+ template simdBlob(mask: Mask, x: var int, len: int, blendProc: untyped) =
when allowSimd:
when defined(amd64):
let vec255 = mm_set1_epi8(255)