pixel-data-js 0.23.0 → 0.24.0

package/src/History/PixelMutator.ts

@@ -1,7 +1,7 @@
 import { mutatorApplyAlphaMask } from './PixelMutator/mutatorApplyAlphaMask'
 import { mutatorApplyBinaryMask } from './PixelMutator/mutatorApplyBinaryMask'
-import { mutatorApplyCircleBrush } from './PixelMutator/mutatorApplyCircleBrush'
 import { mutatorApplyCircleBrushStroke } from './PixelMutator/mutatorApplyCircleBrushStroke'
+import { mutatorBlendColorCircleMask } from './PixelMutator/mutatorBlendColorCircleMask'
 import { mutatorApplyCirclePencil } from './PixelMutator/mutatorApplyCirclePencil'
 import { mutatorApplyCirclePencilStroke } from './PixelMutator/mutatorApplyCirclePencilStroke'
 import { mutatorApplyRectBrush } from './PixelMutator/mutatorApplyRectBrush'
@@ -14,7 +14,7 @@ import { mutatorBlendPixelData } from './PixelMutator/mutatorBlendPixelData'
 import { mutatorBlendPixelDataAlphaMask } from './PixelMutator/mutatorBlendPixelDataAlphaMask'
 import { mutatorBlendPixelDataBinaryMask } from './PixelMutator/mutatorBlendPixelDataBinaryMask'
 import { mutatorClear } from './PixelMutator/mutatorClear'
-import { mutatorFill } from './PixelMutator/mutatorFill'
+import { mutatorFill, mutatorFillRect } from './PixelMutator/mutatorFill'
 import { mutatorFillBinaryMask } from './PixelMutator/mutatorFillBinaryMask'
 import { mutatorInvert } from './PixelMutator/mutatorInvert'
 import type { PixelWriter } from './PixelWriter'
@@ -24,7 +24,6 @@ export function makeFullPixelMutator(writer: PixelWriter<any>) {
     // @sort
     ...mutatorApplyAlphaMask(writer),
     ...mutatorApplyBinaryMask(writer),
-    ...mutatorApplyCircleBrush(writer),
     ...mutatorApplyCircleBrushStroke(writer),
     ...mutatorApplyCirclePencil(writer),
     ...mutatorApplyCirclePencilStroke(writer),
@@ -33,6 +32,7 @@ export function makeFullPixelMutator(writer: PixelWriter<any>) {
     ...mutatorApplyRectPencil(writer),
     ...mutatorApplyRectPencilStroke(writer),
     ...mutatorBlendColor(writer),
+    ...mutatorBlendColorCircleMask(writer),
     ...mutatorBlendPixel(writer),
     ...mutatorBlendPixelData(writer),
     ...mutatorBlendPixelDataAlphaMask(writer),
@@ -40,6 +40,7 @@ export function makeFullPixelMutator(writer: PixelWriter<any>) {
     ...mutatorClear(writer),
     ...mutatorFill(writer),
     ...mutatorFillBinaryMask(writer),
+    ...mutatorFillRect(writer),
     ...mutatorInvert(writer),
   }
 }

package/src/History/PixelPatchTiles.ts

@@ -1,24 +1,12 @@
 import type { IPixelData } from '../_types'
+import { PixelTile } from '../PixelTile/PixelTile'
 
 export type PixelPatchTiles = {
   beforeTiles: PixelTile[]
   afterTiles: PixelTile[]
 }
 
-export class PixelTile {
-  public data32: Uint32Array
-
-  constructor(
-    public id: number,
-    public tx: number,
-    public ty: number,
-    tileArea: number,
-  ) {
-    this.data32 = new Uint32Array(tileArea)
-  }
-}
-
-export function applyPatchTiles(target: IPixelData, tiles: PixelTile[], tileSize: number = 256) {
+export function applyPatchTiles(target: IPixelData, tiles: PixelTile[], tileSize: number) {
   for (let i = 0; i < tiles.length; i++) {
     const tile = tiles[i]
 
@@ -34,7 +22,7 @@ export function applyPatchTiles(target: IPixelData, tiles: PixelTile[], tileSize
     // Calculate clamping to prevent wrapping artifacts on image edges
     const copyWidth = Math.max(0, Math.min(tileSize, dstWidth - startX))
 
-    if (copyWidth <= 0) return
+    if (copyWidth <= 0) continue
 
     for (let ly = 0; ly < tileSize; ly++) {
       const globalY = startY + ly

package/src/History/PixelWriter.ts

@@ -1,13 +1,16 @@
 import type { IPixelData } from '../_types'
-import { type HistoryAction, HistoryManager } from './HistoryManager'
+import { type HistoryActionFactory, makeHistoryAction } from './HistoryAction'
+import { HistoryManager } from './HistoryManager'
 import { PixelAccumulator } from './PixelAccumulator'
 import { PixelEngineConfig } from './PixelEngineConfig'
-import { applyPatchTiles, type PixelPatchTiles } from './PixelPatchTiles'
+import { PixelTilePool } from '../PixelTile/PixelTilePool'
 
 export interface PixelWriterOptions {
   maxHistorySteps?: number
   tileSize?: number
   historyManager?: HistoryManager
+  historyActionFactory?: HistoryActionFactory
+  pixelTilePool?: PixelTilePool,
 }
 
 /**
@@ -32,52 +35,45 @@ export interface PixelWriterOptions {
  * })
  */
 export class PixelWriter<M> {
-  public target: IPixelData
-  public historyManager: HistoryManager
-  public accumulator: PixelAccumulator
-  protected config: PixelEngineConfig
+  readonly historyManager: HistoryManager
+  readonly accumulator: PixelAccumulator
+  readonly historyActionFactory: HistoryActionFactory
+  readonly config: PixelEngineConfig
   readonly mutator: M
 
   constructor(target: IPixelData, mutatorFactory: (writer: PixelWriter<any>) => M, {
     tileSize = 256,
     maxHistorySteps = 50,
     historyManager = new HistoryManager(maxHistorySteps),
+    historyActionFactory = makeHistoryAction,
+    pixelTilePool,
   }: PixelWriterOptions = {}) {
-    this.target = target
-    this.config = new PixelEngineConfig(tileSize)
+    this.config = new PixelEngineConfig(tileSize, target)
     this.historyManager = historyManager
-    this.accumulator = new PixelAccumulator(target, this.config)
+    pixelTilePool ??= new PixelTilePool(this.config)
+    this.accumulator = new PixelAccumulator(this.config, pixelTilePool)
+    this.historyActionFactory = historyActionFactory
     this.mutator = mutatorFactory(this)
   }
 
-  withHistory(cb: (mutator: M) => void) {
-    cb(this.mutator)
-
-    this.captureHistory()
-  }
-
-  captureHistory() {
-    const beforeTiles = this.accumulator.beforeTiles
-    if (beforeTiles.length === 0) return
-
-    const afterTiles = this.accumulator.extractAfterTiles()
-
-    const patch: PixelPatchTiles = {
-      beforeTiles: beforeTiles,
-      afterTiles: afterTiles,
+  withHistory(
+    cb: (mutator: M) => void,
+    after?: () => void,
+    afterUndo?: () => void,
+    afterRedo?: () => void,
+  ) {
+    try {
+      cb(this.mutator)
+    } catch (e) {
+      this.accumulator.rollback()
+      throw e
     }
 
-    const target = this.target
-    const tileSize = this.config.tileSize
-    const accumulator = this.accumulator
+    if (this.accumulator.beforeTiles.length === 0) return
 
-    const action: HistoryAction = {
-      undo: () => applyPatchTiles(target, patch.beforeTiles, tileSize),
-      redo: () => applyPatchTiles(target, patch.afterTiles, tileSize),
-      dispose: () => accumulator.recyclePatch(patch),
-    }
+    const patch = this.accumulator.extractPatch()
+    const action = this.historyActionFactory(this, patch, after, afterUndo, afterRedo)
 
     this.historyManager.commit(action)
-    this.accumulator.reset()
   }
 }

package/src/ImageData/ReusableImageData.ts

@@ -17,12 +17,10 @@ export function makeReusableImageData() {
    * @returns The cached or newly allocated ImageData object.
    */
   return function getReusableImageData(width: number, height: number) {
-    const hasInstance = !!imageData
-    const widthMatches = hasInstance && imageData!.width === width
-    const heightMatches = hasInstance && imageData!.height === height
-
-    if (!widthMatches || !heightMatches) {
+    if (imageData === null || imageData.width !== width || imageData.height !== height) {
       imageData = new ImageData(width, height)
+    } else {
+      imageData.data.fill(0)
     }
 
     return imageData!

package/src/Mask/{CircleBrushAlphaMask.ts → CircleAlphaMask.ts}

@@ -1,6 +1,6 @@
-import { type CircleBrushAlphaMask, MaskType } from '../_types'
+import { type CircleAlphaMask, MaskType } from '../_types'
 
-export function makeCircleBrushAlphaMask(size: number, fallOff: (d: number) => number = () => 1): CircleBrushAlphaMask {
+export function makeCircleAlphaMask(size: number, fallOff: (d: number) => number = () => 1): CircleAlphaMask {
   const area = size * size
   const data = new Uint8Array(area)
   const radius = size / 2

package/src/Mask/{CircleBrushBinaryMask.ts → CircleBinaryMask.ts}

@@ -1,6 +1,6 @@
-import { type CircleBrushBinaryMask, MaskType } from '../_types'
+import { type CircleBinaryMask, MaskType } from '../_types'
 
-export function makeCircleBrushBinaryMask(size: number): CircleBrushBinaryMask {
+export function makeCircleBinaryMask(size: number): CircleBinaryMask {
   const area = size * size
   const data = new Uint8Array(area)
   const radius = size / 2

package/src/PixelData/PixelData.ts

@@ -1,4 +1,4 @@
-import type { ImageDataLike, ImageDataLikeConstructor, IPixelData } from '../_types'
+import type { ImageDataLike, IPixelData } from '../_types'
 import { imageDataToUInt32Array } from '../ImageData/imageDataToUInt32Array'
 
 export class PixelData<T extends ImageDataLike = ImageData> implements IPixelData {
@@ -20,30 +20,4 @@ export class PixelData<T extends ImageDataLike = ImageData> implements IPixelDat
     ;(this as any).width = imageData.width
     ;(this as any).height = imageData.height
   }
-
-  // should only be used for debug and testing
-  copy(): PixelData<T> {
-    const data = this.imageData.data
-    const buffer = new Uint8ClampedArray(data)
-    const Ctor = this.imageData.constructor
-    const isCtorValid = typeof Ctor === 'function'
-
-    let newImageData: T
-    if (isCtorValid && Ctor !== Object) {
-      const ImageConstructor = Ctor as ImageDataLikeConstructor<T>
-      newImageData = new ImageConstructor(
-        buffer,
-        this.width,
-        this.height,
-      )
-    } else {
-      newImageData = {
-        width: this.width,
-        height: this.height,
-        data: buffer,
-      } as unknown as T
-    }
-
-    return new PixelData<T>(newImageData)
-  }
 }

package/src/PixelData/applyAlphaMaskToPixelData.ts

@@ -1,14 +1,15 @@
-import { type AlphaMask, type ApplyMaskToPixelDataOptions, type IPixelData } from '../_types'
+import { type AlphaMask, type ApplyMaskToPixelDataOptions, type Color32, type IPixelData } from '../_types'
 
 /**
  * Directly applies a mask to a region of PixelData,
  * modifying the destination's alpha channel in-place.
+ * @returns true if any pixels were actually modified.
  */
 export function applyAlphaMaskToPixelData(
   dst: IPixelData,
   mask: AlphaMask,
   opts: ApplyMaskToPixelDataOptions = {},
-): void {
+): boolean {
   const {
     x: targetX = 0,
     y: targetY = 0,
@@ -20,7 +21,7 @@ export function applyAlphaMaskToPixelData(
     invertMask = false,
   } = opts
 
-  if (globalAlpha === 0) return
+  if (globalAlpha === 0) return false
 
   // 1. Initial Destination Clipping
   let x = targetX
@@ -41,12 +42,12 @@ export function applyAlphaMaskToPixelData(
   w = Math.min(w, dst.width - x)
   h = Math.min(h, dst.height - y)
 
-  if (w <= 0) return
-  if (h <= 0) return
+  if (w <= 0) return false
+  if (h <= 0) return false
 
   // 2. Determine Source Dimensions
   const mPitch = mask.w
-  if (mPitch <= 0) return
+  if (mPitch <= 0) return false
 
   // 3. Source Bounds Clipping
   // Calculate where we would start reading in the mask
@@ -63,8 +64,8 @@ export function applyAlphaMaskToPixelData(
   const finalH = sY1 - sY0
 
   // This is where your failing tests are now caught
-  if (finalW <= 0) return
-  if (finalH <= 0) return
+  if (finalW <= 0) return false
+  if (finalH <= 0) return false
 
   // 4. Align Destination with Source Clipping
   // If the source was clipped on the top/left, we must shift the destination start
@@ -80,6 +81,7 @@ export function applyAlphaMaskToPixelData(
   let dIdx = (y + yShift) * dw + (x + xShift)
   let mIdx = sY0 * mPitch + sX0
 
+  let didChange = false
   for (let iy = 0; iy < h; iy++) {
     for (let ix = 0; ix < w; ix++) {
       const mVal = maskData[mIdx]
@@ -101,6 +103,7 @@ export function applyAlphaMaskToPixelData(
       if (weight === 0) {
         // Clear alpha channel
         dst32[dIdx] = (dst32[dIdx] & 0x00ffffff) >>> 0
+        didChange = true
       } else if (weight !== 255) {
         // Merge alpha channel
         const d = dst32[dIdx]
@@ -108,7 +111,13 @@ export function applyAlphaMaskToPixelData(
 
         if (da !== 0) {
           const finalAlpha = da === 255 ? weight : (da * weight + 128) >> 8
-          dst32[dIdx] = ((d & 0x00ffffff) | (finalAlpha << 24)) >>> 0
+
+          const current = dst32[dIdx] as Color32
+          const next = ((d & 0x00ffffff) | (finalAlpha << 24)) >>> 0
+          if (current !== next) {
+            dst32[dIdx] = next
+            didChange = true
+          }
         }
       }
 
@@ -119,4 +128,5 @@ export function applyAlphaMaskToPixelData(
     dIdx += dStride
     mIdx += mStride
   }
+  return didChange
 }

package/src/PixelData/applyBinaryMaskToPixelData.ts

@@ -3,12 +3,13 @@ import { type ApplyMaskToPixelDataOptions, type BinaryMask, type IPixelData } fr
 /**
  * Directly applies a mask to a region of PixelData,
  * modifying the destination's alpha channel in-place.
+ * @returns true if any pixels were actually modified.
  */
 export function applyBinaryMaskToPixelData(
   dst: IPixelData,
   mask: BinaryMask,
   opts: ApplyMaskToPixelDataOptions = {},
-): void {
+): boolean {
   const {
     x: targetX = 0,
     y: targetY = 0,
@@ -20,9 +21,8 @@ export function applyBinaryMaskToPixelData(
     invertMask = false,
   } = opts
 
-  if (globalAlpha === 0) return
+  if (globalAlpha === 0) return false
 
-  // 1. Initial Destination Clipping
   let x = targetX
   let y = targetY
   let w = width
@@ -41,12 +41,10 @@ export function applyBinaryMaskToPixelData(
   w = Math.min(w, dst.width - x)
   h = Math.min(h, dst.height - y)
 
-  if (w <= 0) return
-  if (h <= 0) return
+  if (w <= 0 || h <= 0) return false
 
-  // 2. Determine Source Dimensions
   const mPitch = mask.w
-  if (mPitch <= 0) return
+  if (mPitch <= 0) return false
 
   // 3. Source Bounds Clipping
   // Calculate where we would start reading in the mask
@@ -62,9 +60,9 @@ export function applyBinaryMaskToPixelData(
   const finalW = sX1 - sX0
   const finalH = sY1 - sY0
 
-  // This is where your failing tests are now caught
-  if (finalW <= 0) return
-  if (finalH <= 0) return
+  if (finalW <= 0 || finalH <= 0) {
+    return false
+  }
 
   // 4. Align Destination with Source Clipping
   // If the source was clipped on the top/left, we must shift the destination start
@@ -79,24 +77,31 @@ export function applyBinaryMaskToPixelData(
 
   let dIdx = (y + yShift) * dw + (x + xShift)
   let mIdx = sY0 * mPitch + sX0
+  let didChange = false
 
-  for (let iy = 0; iy < h; iy++) {
-    for (let ix = 0; ix < w; ix++) {
+  for (let iy = 0; iy < finalH; iy++) {
+    for (let ix = 0; ix < finalW; ix++) {
       const mVal = maskData[mIdx]
-      // Consistently determines if this pixel should be "masked out" (cleared)
       const isMaskedOut = invertMask ? mVal !== 0 : mVal === 0
 
       if (isMaskedOut) {
-        // Clear alpha channel only (keep RGB)
-        dst32[dIdx] = (dst32[dIdx] & 0x00ffffff) >>> 0
+        const current = dst32[dIdx]
+        const next = (current & 0x00ffffff) >>> 0
+        if (current !== next) {
+          dst32[dIdx] = next
+          didChange = true
+        }
       } else if (globalAlpha !== 255) {
         const d = dst32[dIdx]
         const da = d >>> 24
 
-        // If pixel isn't already fully transparent, apply global alpha
         if (da !== 0) {
           const finalAlpha = da === 255 ? globalAlpha : (da * globalAlpha + 128) >> 8
-          dst32[dIdx] = ((d & 0x00ffffff) | (finalAlpha << 24)) >>> 0
+          const next = ((d & 0x00ffffff) | (finalAlpha << 24)) >>> 0
+          if (d !== next) {
+            dst32[dIdx] = next
+            didChange = true
+          }
         }
       }
 
@@ -107,4 +112,6 @@ export function applyBinaryMaskToPixelData(
     dIdx += dStride
     mIdx += mStride
   }
+
+  return didChange
 }

package/src/PixelData/applyRectBrushToPixelData.ts

@@ -2,6 +2,10 @@ import type { BlendColor32, Color32, IPixelData, Rect } from '../_types'
 import { sourceOverPerfect } from '../BlendModes/blend-modes-perfect'
 import { getRectBrushOrPencilBounds } from '../Rect/getRectBrushOrPencilBounds'
 
+/**
+ * Applies a rectangular brush to the pixel data.
+ * @returns true if any pixels were actually modified.
+ */
 export function applyRectBrushToPixelData(
   target: IPixelData,
   color: Color32,
@@ -13,7 +17,7 @@ export function applyRectBrushToPixelData(
   fallOff: (dist: number) => number,
   blendFn: BlendColor32 = sourceOverPerfect,
   bounds?: Rect,
-): void {
+): boolean {
   const targetWidth = target.width
   const targetHeight = target.height
 
@@ -26,7 +30,9 @@ export function applyRectBrushToPixelData(
     targetHeight,
   )
 
-  if (b.w <= 0 || b.h <= 0) return
+  if (b.w <= 0 || b.h <= 0) {
+    return false
+  }
 
   const data32 = target.data32
   const baseColor = color & 0x00ffffff
@@ -36,7 +42,6 @@ export function applyRectBrushToPixelData(
   const invHalfW = 1 / (brushWidth / 2)
   const invHalfH = 1 / (brushHeight / 2)
 
-  // Restore the pixel-art centering logic
   const centerOffsetX = (brushWidth % 2 === 0) ? 0.5 : 0
   const centerOffsetY = (brushHeight % 2 === 0) ? 0.5 : 0
   const fCenterX = Math.floor(centerX)
@@ -45,6 +50,7 @@ export function applyRectBrushToPixelData(
   const endX = b.x + b.w
   const endY = b.y + b.h
   const isOverwrite = (blendFn as any).isOverwrite
+  let didChange = false
 
   for (let py = b.y; py < endY; py++) {
     const rowOffset = py * targetWidth
@@ -52,7 +58,6 @@ export function applyRectBrushToPixelData(
 
     for (let px = b.x; px < endX; px++) {
       const idx = rowOffset + px
-
       const dx = Math.abs((px - fCenterX) + centerOffsetX) * invHalfW
       const dist = dx > dy ? dx : dy
 
@@ -79,7 +84,15 @@ export function applyRectBrushToPixelData(
         finalCol = ((a << 24) | baseColor) >>> 0 as Color32
       }
 
-      data32[idx] = blendFn(finalCol, data32[idx] as Color32)
+      const current = data32[idx] as Color32
+      const next = blendFn(finalCol, current)
+
+      if (current !== next) {
+        data32[idx] = next
+        didChange = true
+      }
     }
   }
+
+  return didChange
 }

package/src/PixelData/blendColorPixelData.ts

@@ -1,11 +1,15 @@
 import { type Color32, type ColorBlendOptions, type IPixelData } from '../_types'
 import { sourceOverPerfect } from '../BlendModes/blend-modes-perfect'
 
+/**
+ * Blends a solid color into a target pixel buffer.
+ * @returns true if any pixels were actually modified.
+ */
 export function blendColorPixelData(
   dst: IPixelData,
   color: Color32,
   opts: ColorBlendOptions = {},
-) {
+): boolean {
   const {
     x: targetX = 0,
     y: targetY = 0,
@@ -15,30 +19,40 @@ export function blendColorPixelData(
     blendFn = sourceOverPerfect,
   } = opts
 
-  if (globalAlpha === 0) return
+  if (globalAlpha === 0) return false
+
   const baseSrcAlpha = (color >>> 24)
   const isOverwrite = (blendFn as any).isOverwrite || false
-  if (baseSrcAlpha === 0 && !isOverwrite) return
+
+  if (baseSrcAlpha === 0 && !isOverwrite) return false
 
   // Clipping
-  let x = targetX, y = targetY, w = width, h = height
+  let x = targetX
+  let y = targetY
+  let w = width
+  let h = height
+
   if (x < 0) {
     w += x
     x = 0
   }
+
   if (y < 0) {
     h += y
     y = 0
   }
+
   const actualW = Math.min(w, dst.width - x)
   const actualH = Math.min(h, dst.height - y)
-  if (actualW <= 0 || actualH <= 0) return
+
+  if (actualW <= 0 || actualH <= 0) return false
 
   // Single-color fills can pre-calculate the source color once
   let finalSrcColor = color
+
   if (globalAlpha < 255) {
     const a = (baseSrcAlpha * globalAlpha + 128) >> 8
-    if (a === 0 && !isOverwrite) return
+    if (a === 0 && !isOverwrite) return false
     finalSrcColor = ((color & 0x00ffffff) | (a << 24)) >>> 0 as Color32
   }
 
@@ -46,12 +60,22 @@ export function blendColorPixelData(
   const dw = dst.width
   let dIdx = (y * dw + x) | 0
   const dStride = (dw - actualW) | 0
+  let didChange = false
 
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
-      dst32[dIdx] = blendFn(finalSrcColor, dst32[dIdx] as Color32)
+      const current = dst32[dIdx] as Color32
+      const next = blendFn(finalSrcColor, current)
+
+      if (current !== next) {
+        dst32[dIdx] = next
+        didChange = true
+      }
+
       dIdx++
     }
     dIdx += dStride
   }
+
+  return didChange
 }

package/src/PixelData/blendColorPixelDataAlphaMask.ts

@@ -12,13 +12,14 @@ import { sourceOverPerfect } from '../BlendModes/blend-modes-perfect'
  * @param color - The solid color to apply.
  * @param mask - The mask defining the per-pixel opacity of the target area.
  * @param opts - Configuration options including placement coordinates, bounds, global alpha, and mask offsets.
+ * @returns true if any pixels were actually modified.
  */
 export function blendColorPixelDataAlphaMask(
   dst: IPixelData,
   color: Color32,
   mask: AlphaMask,
   opts: ColorBlendMaskOptions = {},
-): void {
+): boolean {
   const targetX = opts.x ?? 0
   const targetY = opts.y ?? 0
   const w = opts.w ?? mask.w
@@ -29,12 +30,12 @@ export function blendColorPixelDataAlphaMask(
   const my = opts.my ?? 0
   const invertMask = opts.invertMask ?? false
 
-  if (globalAlpha === 0) return
+  if (globalAlpha === 0) return false
 
   const baseSrcAlpha = (color >>> 24)
   const isOverwrite = (blendFn as any).isOverwrite || false
 
-  if (baseSrcAlpha === 0 && !isOverwrite) return
+  if (baseSrcAlpha === 0 && !isOverwrite) return false
 
   let x = targetX
   let y = targetY
@@ -54,7 +55,7 @@ export function blendColorPixelDataAlphaMask(
   actualW = Math.min(actualW, dst.width - x)
   actualH = Math.min(actualH, dst.height - y)
 
-  if (actualW <= 0 || actualH <= 0) return
+  if (actualW <= 0 || actualH <= 0) return false
 
   const dx = (x - targetX) | 0
   const dy = (y - targetY) | 0
@@ -68,9 +69,10 @@ export function blendColorPixelDataAlphaMask(
   let mIdx = ((my + dy) * mPitch + (mx + dx)) | 0
 
   const dStride = (dw - actualW) | 0
-  let mStride = (mPitch - actualW) | 0
+  const mStride = (mPitch - actualW) | 0
   const isOpaque = globalAlpha === 255
   const colorRGB = color & 0x00ffffff
+  let didChange = false
 
   for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
@@ -109,7 +111,13 @@ export function blendColorPixelDataAlphaMask(
         finalCol = ((colorRGB | (a << 24)) >>> 0) as Color32
       }
 
-      dst32[dIdx] = blendFn(finalCol, dst32[dIdx] as Color32)
+      const current = dst32[dIdx] as Color32
+      const next = blendFn(finalCol, current)
+
+      if (current !== next) {
+        dst32[dIdx] = next
+        didChange = true
+      }
 
       dIdx++
       mIdx++
@@ -118,4 +126,6 @@ export function blendColorPixelDataAlphaMask(
     dIdx += dStride
     mIdx += mStride
   }
+
+  return didChange
 }