feat: Use nearest-neighbor scaling in pi.Stretch

Because it is more accurate than the current algorithm and the performance is similar.

Author: elgopher

internal/test/stretch/sprite-2x6.png

@@ -72,31 +72,55 @@ func Stretch(sprite Sprite, dx, dy, dw, dh int) {
 	targetStride := drawTarget.width - int(dst.W)
 	srcSource := sprite.Source
 
-	if sprite.FlipY {
-		src.Y += float64(dh-1) * stepY
-		stepY *= -1
-	}
+	stepXAbs := src.W / dst.W
+	stepYAbs := src.H / dst.H
 
+	// start sampling from half-step offsets
 	if sprite.FlipX {
-		src.X += float64(dw-1) * stepX
-		stepX *= -1
+		src.X += src.W - stepXAbs/2
+		stepXAbs = -stepXAbs
+	} else {
+		src.X += stepXAbs / 2
+	}
+
+	if sprite.FlipY {
+		src.Y += src.H - stepYAbs/2
+		stepYAbs = -stepYAbs
+	} else {
+		src.Y += stepYAbs / 2
 	}
 
-	srcX, srcY := src.X, src.Y
+	srcY := src.Y
 
-	for line := 0.0; line < dst.H; line++ {
-		srcLineIdx := int(srcY) * srcSource.width // multiplication, but only once per line, so it's not a performance problem
+	srcMaxX := int(src.X + src.W)
+	srcMaxY := int(src.Y + src.H)
 
-		for cell := 0.0; cell < dst.W; cell++ {
-			sourceColor := srcSource.data[srcLineIdx+int(srcX)] & ReadMask
+	for line := 0.0; line < dst.H; line++ {
+		syIndex := int(srcY)
+		if syIndex < 0 {
+			syIndex = 0
+		} else if syIndex >= srcMaxY {
+			syIndex = srcMaxY - 1
+		}
+		srcLineIdx := syIndex * srcSource.width
+
+		srcX := src.X
+		for cell := 0; cell < int(dst.W); cell++ {
+			sxIndex := int(srcX)
+			if sxIndex < 0 {
+				sxIndex = 0
+			} else if sxIndex >= srcMaxX {
+				sxIndex = srcMaxX - 1
+			}
+
+			sourceColor := srcSource.data[srcLineIdx+sxIndex] & ReadMask
 			targetColor := drawTarget.data[targetIdx] & TargetMask
 			drawTarget.data[targetIdx] =
 				ColorTables[(sourceColor|targetColor)>>6][sourceColor&(MaxColors-1)][targetColor&(MaxColors-1)]
-			srcX += stepX
+			srcX += stepXAbs
 			targetIdx++
 		}
-		srcX = src.X
-		srcY += stepY
+		srcY += stepYAbs
 		targetIdx += targetStride
 	}
 }