pixel-data-js 0.15.1 → 0.17.0

package/src/PixelData/applyCircleBrushToPixelData.ts

@@ -0,0 +1,69 @@
+import type { BlendColor32, Color32 } from '../_types'
+import { sourceOverPerfect } from '../BlendModes/blend-modes-perfect'
+import type { PixelData } from './PixelData'
+
+/**
+ * Applies a circular brush to pixel data, blending a color with optional falloff.
+ *
+ * @param target The PixelData to modify.
+ * @param color The brush color.
+ * @param centerX The center x-coordinate of the brush.
+ * @param centerY The center y-coordinate of the brush.
+ * @param brushSize The diameter of the brush.
+ * @param alpha The overall opacity of the brush (0-255).
+ * @default 255
+ * @param fallOff A function that returns an alpha multiplier (0-1) based on the normalized distance (0-1) from the circle's center.
+ * @param blendFn
+ * @default sourceOverPerfect
+ */
+export function applyCircleBrushToPixelData(
+  target: PixelData,
+  color: Color32,
+  centerX: number,
+  centerY: number,
+  brushSize: number,
+  alpha = 255,
+  fallOff?: (dist: number) => number,
+  blendFn: BlendColor32 = sourceOverPerfect,
+): void {
+  const r = brushSize / 2
+  const rSqr = r * r
+  const centerOffset = (brushSize % 2 === 0) ? 0.5 : 0
+
+  const xStart = Math.max(0, Math.ceil(centerX - r))
+  const xEnd = Math.min(target.width - 1, Math.floor(centerX + r))
+  const yStart = Math.max(0, Math.ceil(centerY - r))
+  const yEnd = Math.min(target.height - 1, Math.floor(centerY + r))
+
+  const data32 = target.data32
+  const targetWidth = target.width
+  const baseColor = color & 0x00ffffff
+  const invR = 1 / r
+
+  // Pre-calculate the constant source for cases where fallOff is null
+  const constantSrc = ((alpha << 24) | baseColor) >>> 0 as Color32
+
+  for (let cy = yStart; cy <= yEnd; cy++) {
+    const dy = cy - centerY + centerOffset
+    const dySqr = dy * dy
+    const rowOffset = cy * targetWidth
+
+    for (let cx = xStart; cx <= xEnd; cx++) {
+      const dx = cx - centerX + centerOffset
+      const dSqr = dx * dx + dySqr
+
+      if (dSqr <= rSqr) {
+        const idx = rowOffset + cx
+
+        if (fallOff) {
+          const strength = fallOff(Math.sqrt(dSqr) * invR)
+          const fAlpha = (alpha * strength) & 0xFF
+          const src = ((fAlpha << 24) | baseColor) >>> 0 as Color32
+          data32[idx] = blendFn(src, data32[idx] as Color32)
+        } else {
+          data32[idx] = blendFn(constantSrc, data32[idx] as Color32)
+        }
+      }
+    }
+  }
+}

package/src/PixelData/applyMaskToPixelData.ts

@@ -8,7 +8,7 @@ import type { PixelData } from './PixelData'
 export function applyMaskToPixelData(
   dst: PixelData,
   mask: AnyMask,
-  opts: ApplyMaskOptions,
+  opts: ApplyMaskOptions = {},
 ): void {
   const {
     x: targetX = 0,

package/src/PixelData/applyRectBrushToPixelData.ts

@@ -0,0 +1,102 @@
+import type { BlendColor32, Color32, Rect } from '../_types'
+import { sourceOverPerfect } from '../BlendModes/blend-modes-perfect'
+import { PixelData } from './PixelData'
+
+/**
+ * Applies a rectangular brush to pixel data, blending a color with optional falloff.
+ *
+ * @param target The PixelData to modify.
+ * @param color The brush color.
+ * @param centerX The center x-coordinate of the brush.
+ * @param centerY The center y-coordinate of the brush.
+ * @param brushWidth
+ * @param brushHeight
+ * @param alpha The overall opacity of the brush (0-255).
+ * @default 255
+ * @param fallOff A function that returns an alpha multiplier (0-1) based on the normalized distance (0-1) from the circle's center.
+ * @param blendFn
+ * @default sourceOverPerfect
+ */
+export function applyRectBrushToPixelData(
+  target: PixelData,
+  color: Color32,
+  centerX: number,
+  centerY: number,
+  brushWidth: number,
+  brushHeight: number,
+  alpha = 255,
+  fallOff?: (dist: number) => number,
+  blendFn: BlendColor32 = sourceOverPerfect,
+): void {
+  const targetWidth = target.width
+  const targetHeight = target.height
+  const data32 = target.data32
+
+  const rawStartX = Math.floor(centerX - brushWidth / 2)
+  const rawStartY = Math.floor(centerY - brushHeight / 2)
+  const endX = Math.min(targetWidth, rawStartX + brushWidth)
+  const endY = Math.min(targetHeight, rawStartY + brushHeight)
+  const startX = Math.max(0, rawStartX)
+  const startY = Math.max(0, rawStartY)
+
+  const baseColor = color & 0x00ffffff
+  const constantSrc = ((alpha << 24) | baseColor) >>> 0 as Color32
+  const invHalfW = 1 / (brushWidth / 2)
+  const invHalfH = 1 / (brushHeight / 2)
+
+  for (let py = startY; py < endY; py++) {
+    const rowOffset = py * targetWidth
+    const dy = Math.abs(py + 0.5 - centerY) * invHalfH
+
+    for (let px = startX; px < endX; px++) {
+      if (fallOff) {
+        const dx = Math.abs(px + 0.5 - centerX) * invHalfW
+        const dist = dx > dy ? dx : dy
+        const fAlpha = (alpha * fallOff(dist)) | 0
+        const src = ((fAlpha << 24) | baseColor) >>> 0 as Color32
+        data32[rowOffset + px] = blendFn(src, data32[rowOffset + px] as Color32)
+      } else {
+        data32[rowOffset + px] = blendFn(constantSrc, data32[rowOffset + px] as Color32)
+      }
+    }
+  }
+}
+
+export function getRectBrushBounds(
+  centerX: number,
+  centerY: number,
+  brushWidth: number,
+  brushHeight: number,
+  targetWidth?: number,
+  targetHeight?: number,
+): Rect {
+
+  const rawStartX = Math.floor(centerX - brushWidth / 2)
+  const rawStartY = Math.floor(centerY - brushHeight / 2)
+
+  const rawEndX = rawStartX + brushWidth
+  const rawEndY = rawStartY + brushHeight
+
+  const startX = targetWidth !== undefined
+    ? Math.max(0, rawStartX)
+    : rawStartX
+
+  const startY = targetHeight !== undefined
+    ? Math.max(0, rawStartY)
+    : rawStartY
+
+  const endX = targetWidth !== undefined
+    ? Math.min(targetWidth, rawEndX)
+    : rawEndX
+
+  const endY = targetHeight !== undefined
+    ? Math.min(targetHeight, rawEndY)
+    : rawEndY
+
+  return {
+    x: startX,
+    y: startY,
+    w: endX - startX,
+    h: endY - startY,
+  }
+}

package/src/PixelData/blendPixelData.ts

@@ -1,6 +1,5 @@
 import { type Color32, MaskType, type PixelBlendOptions } from '../_types'
-import { BlendMode } from '../BlendModes/blend-modes'
-import { FAST_BLEND_MODES } from '../BlendModes/blend-modes-fast'
+import { sourceOverFast } from '../BlendModes/blend-modes-fast'
 import type { PixelData } from './PixelData'
 
 /**
@@ -30,7 +29,7 @@ export function blendPixelData(
     w: width = src.width,
     h: height = src.height,
     alpha: globalAlpha = 255,
-    blendFn = FAST_BLEND_MODES[BlendMode.sourceOver],
+    blendFn = sourceOverFast,
     mask,
     maskType = MaskType.ALPHA,
     mw,

package/src/PixelData/invertPixelData.ts

@@ -1,16 +1,83 @@
+import { type PixelMutateOptions } from '../_types'
 import type { PixelData } from './PixelData'
 
 export function invertPixelData(
   pixelData: PixelData,
-): PixelData {
+  opts: PixelMutateOptions = {},
+): void {
+  const dst = pixelData
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
 
-  const data32 = pixelData.data32
-  const len = data32.length
+    w: width = pixelData.width,
+    h: height = pixelData.height,
+    mask,
+    mw,
+    mx = 0,
+    my = 0,
+    invertMask = false,
+  } = opts
 
-  for (let i = 0; i < len; i++) {
-    // XOR with 0x00FFFFFF flips RGB bits and ignores Alpha (the top 8 bits)
-    data32[i] = data32[i] ^ 0x00FFFFFF
+  let x = targetX
+  let y = targetY
+  let w = width
+  let h = height
+
+  // Destination Clipping
+  if (x < 0) {
+    w += x
+    x = 0
+  }
+  if (y < 0) {
+    h += y
+    y = 0
   }
 
-  return pixelData
+  const actualW = Math.min(w, dst.width - x)
+  const actualH = Math.min(h, dst.height - y)
+
+  if (actualW <= 0 || actualH <= 0) return
+
+  const dst32 = dst.data32
+  const dw = dst.width
+  const mPitch = mw ?? width
+
+  const dx = x - targetX
+  const dy = y - targetY
+
+  let dIdx = y * dw + x
+  let mIdx = (my + dy) * mPitch + (mx + dx)
+
+  const dStride = dw - actualW
+  const mStride = mPitch - actualW
+
+  // Optimization: Split loops to avoid checking `if (mask)` for every pixel.
+  if (mask) {
+    for (let iy = 0; iy < actualH; iy++) {
+      for (let ix = 0; ix < actualW; ix++) {
+        const mVal = mask[mIdx]
+        const isHit = invertMask
+          ? mVal === 0
+          : mVal === 1
+
+        if (isHit) {
+          // XOR with 0x00FFFFFF flips RGB bits and ignores Alpha (the top 8 bits)
+          dst32[dIdx] = dst32[dIdx] ^ 0x00FFFFFF
+        }
+        dIdx++
+        mIdx++
+      }
+      dIdx += dStride
+      mIdx += mStride
+    }
+  } else {
+    for (let iy = 0; iy < actualH; iy++) {
+      for (let ix = 0; ix < actualW; ix++) {
+        dst32[dIdx] = dst32[dIdx] ^ 0x00FFFFFF
+        dIdx++
+      }
+      dIdx += dStride
+    }
+  }
 }

package/src/PixelData/writePixelDataBuffer.ts

@@ -0,0 +1,65 @@
+import type { PixelData } from './PixelData'
+import { type Rect } from '../_types'
+
+/**
+ * Copies a pixel buffer into a specific region of a {@link PixelData} object.
+ *
+ * This function performs a direct memory copy from a {@link Uint32Array}
+ * into the target {@link PixelData} buffer.
+ */
+export function writePixelDataBuffer(
+  target: PixelData,
+  data: Uint32Array,
+  rect: Rect,
+): void
+export function writePixelDataBuffer(
+  target: PixelData,
+  data: Uint32Array,
+  x: number,
+  y: number,
+  w: number,
+  h: number,
+): void
+export function writePixelDataBuffer(
+  target: PixelData,
+  data: Uint32Array,
+  _x: Rect | number,
+  _y?: number,
+  _w?: number,
+  _h?: number,
+): void {
+  const { x, y, w, h } = typeof _x === 'object'
+    ? _x
+    : {
+      x: _x,
+      y: _y!,
+      w: _w!,
+      h: _h!,
+    }
+
+  const dstW = target.width
+  const dstH = target.height
+  const dstData = target.data32
+
+  const x0 = Math.max(0, x)
+  const y0 = Math.max(0, y)
+  const x1 = Math.min(dstW, x + w)
+  const y1 = Math.min(dstH, y + h)
+
+  if (x1 <= x0 || y1 <= y0) {
+    return
+  }
+
+  const rowLen = x1 - x0
+  const srcCol = x0 - x
+  const srcYOffset = y0 - y
+  const actualH = y1 - y0
+
+  for (let row = 0; row < actualH; row++) {
+    const dstStart = (y0 + row) * dstW + x0
+    const srcRow = srcYOffset + row
+    const srcStart = srcRow * w + srcCol
+
+    dstData.set(data.subarray(srcStart, srcStart + rowLen), dstStart)
+  }
+}

package/src/_types.ts

@@ -66,33 +66,33 @@ export type AnyMask = BinaryMask | AlphaMask
  * Configuration for pixel manipulation operations.
  * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
  */
-export interface PixelOptions {
+export interface PixelRectOptions {
   /**
    * The starting X coordinate in the destination buffer.
    * @default 0
    */
   x?: number
+
   /**
    * The starting Y coordinate in the destination buffer.
    * @default 0
    */
   y?: number
+
   /**
    * The width of the region to process.
    * @default Source width.
    */
   w?: number
+
   /**
    * The height of the region to process.
    * @default Source height.
    */
   h?: number
+}
 
-  /**
-   * Overall layer opacity 0-255.
-   * @default 255
-   */
-  alpha?: number
+export interface PixelMaskRectOptions {
 
   /**
    * Mask width.
@@ -111,6 +111,27 @@ export interface PixelOptions {
    * @default 0
    */
   my?: number
+}
+
+export interface PixelMaskInvertOptions {
+
+  /**
+   * If true the inverse of the mask will be applied
+   * @default false
+   */
+  invertMask?: boolean
+}
+
+/**
+ * Configuration for pixel manipulation operations.
+ * Designed to be used by spreading a Rect object ({x, y, w, h}) directly.
+ */
+export interface PixelOptions extends PixelRectOptions, PixelMaskRectOptions, PixelMaskInvertOptions {
+  /**
+   * Overall layer opacity 0-255.
+   * @default 255
+   */
+  alpha?: number
 
   /** An optional mask to restrict where pixels are written. */
   mask?: AnyMask | null
@@ -119,12 +140,11 @@ export interface PixelOptions {
    * @default {@link MaskType.ALPHA}
    */
   maskType?: MaskType
+}
 
-  /**
-   * If true the inverse of the mask will be applied
-   * @default false
-   */
-  invertMask?: boolean
+export interface PixelMutateOptions extends PixelRectOptions, PixelMaskRectOptions, PixelMaskInvertOptions {
+  /** An optional mask to restrict where pixels are mutated. */
+  mask?: BinaryMask | null
 }
 
 /**

package/src/index.ts

@@ -3,15 +3,8 @@ export * from './color'
 
 export * from './Algorithm/floodFillSelection'
 
-export {
-  BlendMode,
-  type BlendModeIndex,
-} from './BlendModes/blend-modes'
-export {
-  type BlendToIndexGetter,
-  type IndexToBlendGetter,
-} from './BlendModes/blend-mode-getters'
-
+export * from './BlendModes/BlendModeRegistry'
+export * from './BlendModes/blend-modes'
 export * from './BlendModes/blend-modes-fast'
 export * from './BlendModes/blend-modes-perfect'
 
@@ -22,6 +15,20 @@ export * from './Clipboard/getImageDataFromClipboard'
 export * from './Clipboard/writeImageDataToClipboard'
 export * from './Clipboard/writeImgBlobToClipboard'
 
+export * from './History/PixelAccumulator'
+export * from './History/HistoryManager'
+export * from './History/PixelEngineConfig'
+export * from './History/PixelMutator'
+export * from './History/PixelPatchTiles'
+export * from './History/PixelWriter'
+
+export * from './History/PixelMutator/mutatorApplyMask'
+export * from './History/PixelMutator/mutatorBlendColor'
+export * from './History/PixelMutator/mutatorBlendPixel'
+export * from './History/PixelMutator/mutatorBlendPixelData'
+export * from './History/PixelMutator/mutatorFillPixelData'
+export * from './History/PixelMutator/mutatorInvert'
+
 export * from './ImageData/ReusableImageData'
 export * from './ImageData/copyImageData'
 export * from './ImageData/extractImageDataBuffer'
@@ -35,7 +42,7 @@ export * from './ImageData/resampleImageData'
 export * from './ImageData/resizeImageData'
 export * from './ImageData/serialization'
 export * from './ImageData/writeImageData'
-export * from './ImageData/writeImageDataPixels'
+export * from './ImageData/writeImageDataBuffer'
 
 export * from './IndexedImage/IndexedImage'
 export * from './IndexedImage/getIndexedImageColorCounts'
@@ -53,7 +60,9 @@ export * from './Mask/invertMask'
 export * from './Mask/mergeMasks'
 
 export * from './PixelData/PixelData'
+export * from './PixelData/applyCircleBrushToPixelData'
 export * from './PixelData/applyMaskToPixelData'
+export * from './PixelData/applyRectBrushToPixelData'
 export * from './PixelData/blendColorPixelData'
 export * from './PixelData/blendPixelData'
 export * from './PixelData/clearPixelData'
@@ -65,5 +74,6 @@ export * from './PixelData/pixelDataToAlphaMask'
 export * from './PixelData/reflectPixelData'
 export * from './PixelData/resamplePixelData'
 export * from './PixelData/rotatePixelData'
+export * from './PixelData/writePixelDataBuffer'
 
 export * from './Rect/trimRectBounds'

package/src/BlendModes/blend-mode-getters.ts

@@ -1,14 +0,0 @@
-import type { BlendColor32 } from '../_types'
-import type { BlendModeIndex } from './blend-modes'
-import { FAST_BLEND_TO_INDEX, INDEX_TO_FAST_BLEND } from './blend-modes-fast'
-import { type INDEX_TO_PERFECT_BLEND, PERFECT_BLEND_TO_INDEX } from './blend-modes-perfect'
-
-export type BaseIndexToBlendGetter<B extends BlendColor32> = {
-  get: (index: BlendModeIndex) => B
-}
-export type IndexToBlendGetter = typeof INDEX_TO_FAST_BLEND | typeof INDEX_TO_PERFECT_BLEND
-
-export type BaseBlendToIndexGetter<B extends BlendColor32> = {
-  get: (blend: B) => BlendModeIndex
-}
-export type BlendToIndexGetter = typeof FAST_BLEND_TO_INDEX | typeof PERFECT_BLEND_TO_INDEX