pixel-data-js 0.24.0 → 0.25.0

package/src/History/PixelMutator/mutatorApplyRectPencil.ts

@@ -1,65 +0,0 @@
-import type { BlendColor32, Color32, HistoryMutator, Rect } from '../../_types'
-import { applyRectBrushToPixelData } from '../../PixelData/applyRectBrushToPixelData'
-import { getRectBrushOrPencilBounds } from '../../Rect/getRectBrushOrPencilBounds'
-import { PixelWriter } from '../PixelWriter'
-
-const defaults = {
-  applyRectBrushToPixelData,
-  getRectBrushOrPencilBounds,
-  fallOff: () => 1,
-}
-
-type Deps = Partial<typeof defaults>
-
-/**
- * @param deps - @hidden
- */
-export const mutatorApplyRectPencil = ((writer: PixelWriter<any>, deps: Deps = defaults) => {
-  const {
-    applyRectBrushToPixelData = defaults.applyRectBrushToPixelData,
-    getRectBrushOrPencilBounds = defaults.getRectBrushOrPencilBounds,
-    fallOff = defaults.fallOff,
-  } = deps
-
-  const boundsOut: Rect = { x: 0, y: 0, w: 0, h: 0 }
-
-  return {
-    applyRectPencil(
-      color: Color32,
-      centerX: number,
-      centerY: number,
-      brushWidth: number,
-      brushHeight: number,
-      alpha = 255,
-      blendFn?: BlendColor32,
-    ): boolean {
-
-      const target = writer.config.target
-      const b = getRectBrushOrPencilBounds(
-        centerX,
-        centerY,
-        brushWidth,
-        brushHeight,
-        target.width,
-        target.height,
-        boundsOut,
-      )
-
-      const didChange = writer.accumulator.storeRegionBeforeState(b.x, b.y, b.w, b.h)
-      return didChange(
-        applyRectBrushToPixelData(
-          target,
-          color,
-          centerX,
-          centerY,
-          brushWidth,
-          brushHeight,
-          alpha,
-          fallOff,
-          blendFn,
-          b,
-        ),
-      )
-    },
-  }
-}) satisfies HistoryMutator<any, Deps>

package/src/History/PixelMutator/mutatorApplyRectPencilStroke.ts

@@ -1,166 +0,0 @@
-import {
-  type BinaryMask,
-  type BlendColor32,
-  type Color32,
-  type ColorBlendOptions,
-  type HistoryMutator,
-  MaskType,
-  type Rect,
-} from '../../_types'
-import { forEachLinePoint } from '../../Algorithm/forEachLinePoint'
-import { sourceOverPerfect } from '../../BlendModes/blend-modes-perfect'
-import { blendColorPixelDataBinaryMask } from '../../PixelData/blendColorPixelDataBinaryMask'
-import { getRectBrushOrPencilBounds } from '../../Rect/getRectBrushOrPencilBounds'
-import { getRectBrushOrPencilStrokeBounds } from '../../Rect/getRectBrushOrPencilStrokeBounds'
-import { PixelWriter } from '../PixelWriter'
-
-const defaults = {
-  forEachLinePoint,
-  getRectBrushOrPencilBounds,
-  getRectBrushOrPencilStrokeBounds,
-  blendColorPixelDataBinaryMask,
-}
-
-type Deps = Partial<typeof defaults>
-
-/**
- * @param deps - @hidden
- */
-export const mutatorApplyRectPencilStroke = ((writer: PixelWriter<any>, deps: Deps = defaults) => {
-  const {
-    forEachLinePoint = defaults.forEachLinePoint,
-    blendColorPixelDataBinaryMask = defaults.blendColorPixelDataBinaryMask,
-    getRectBrushOrPencilBounds = defaults.getRectBrushOrPencilBounds,
-    getRectBrushOrPencilStrokeBounds = defaults.getRectBrushOrPencilStrokeBounds,
-  } = deps
-
-  const strokeBoundsOut: Rect = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0,
-  }
-
-  const rectPencilBounds: Rect = {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0,
-  }
-
-  const blendColorPixelOptions: ColorBlendOptions = {
-    alpha: 255,
-    blendFn: sourceOverPerfect,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0,
-  }
-
-  const mask = {
-    type: MaskType.BINARY,
-    data: null as unknown as Uint8Array,
-    w: 0,
-    h: 0,
-  }
-
-  return {
-    applyRectPencilStroke(
-      color: Color32,
-      x0: number,
-      y0: number,
-      x1: number,
-      y1: number,
-      brushWidth: number,
-      brushHeight: number,
-      alpha = 255,
-      blendFn: BlendColor32 = sourceOverPerfect,
-    ) {
-      const {
-        x: bx,
-        y: by,
-        w: bw,
-        h: bh,
-      } = getRectBrushOrPencilStrokeBounds(
-        x0,
-        y0,
-        x1,
-        y1,
-        brushWidth,
-        brushHeight,
-        strokeBoundsOut,
-      )
-
-      if (bw <= 0 || bh <= 0) return
-
-      mask.data = new Uint8Array(bw * bh)
-      mask.w = bw
-      mask.h = bh
-
-      const maskData = mask.data
-
-      const halfW = brushWidth / 2
-      const halfH = brushHeight / 2
-      const centerOffset = (brushWidth % 2 === 0) ? 0.5 : 0
-
-      const target = writer.config.target
-      const targetWidth = target.width
-      const targetHeight = target.height
-
-      forEachLinePoint(x0, y0, x1, y1, (px, py) => {
-        const {
-          x: rbx,
-          y: rby,
-          w: rbw,
-          h: rbh,
-        } = getRectBrushOrPencilBounds(
-          px,
-          py,
-          brushWidth,
-          brushHeight,
-          targetWidth,
-          targetHeight,
-          rectPencilBounds,
-        )
-
-        writer.accumulator.storeRegionBeforeState(
-          rbx,
-          rby,
-          rbw,
-          rbh,
-        )
-
-        const startX = Math.max(bx, rbx)
-        const startY = Math.max(by, rby)
-        const endX = Math.min(bx + bw, rbx + rbw)
-        const endY = Math.min(by + bh, rby + rbh)
-
-        const fPx = Math.floor(px)
-        const fPy = Math.floor(py)
-
-        for (let my = startY; my < endY; my++) {
-          const dy = Math.abs((my - fPy) + centerOffset)
-          const maskRowOffset = (my - by) * bw
-
-          for (let mx = startX; mx < endX; mx++) {
-            const dx = Math.abs((mx - fPx) + centerOffset)
-            const maskIdx = maskRowOffset + (mx - bx)
-
-            if (dx <= halfW && dy <= halfH) {
-              maskData[maskIdx] = 1
-            }
-          }
-        }
-      })
-
-      blendColorPixelOptions.blendFn = blendFn
-      blendColorPixelOptions.alpha = alpha
-      blendColorPixelOptions.x = bx
-      blendColorPixelOptions.y = by
-      blendColorPixelOptions.w = bw
-      blendColorPixelOptions.h = bh
-
-      blendColorPixelDataBinaryMask(target, color, mask as BinaryMask, blendColorPixelOptions)
-    },
-  }
-}) satisfies HistoryMutator<any, Deps>

package/src/History/PixelMutator/mutatorBlendColorCircleMask.ts

@@ -1,71 +0,0 @@
-import type { BlendColor32, CircleMask, Color32, ColorBlendMaskOptions, HistoryMutator, Rect } from '../../_types'
-import { sourceOverPerfect } from '../../BlendModes/blend-modes-perfect'
-import { blendColorPixelDataCircleMask } from '../../PixelData/blendColorPixelDataCircleMask'
-import { getCircleBrushOrPencilBounds } from '../../Rect/getCircleBrushOrPencilBounds'
-import { PixelWriter } from '../PixelWriter'
-
-const defaults = {
-  blendColorPixelDataCircleMask,
-  getCircleBrushOrPencilBounds,
-}
-
-type Deps = Partial<typeof defaults>
-
-/**
- * @param deps - @hidden
- */
-export const mutatorBlendColorCircleMask = ((writer: PixelWriter<any>, deps: Deps = defaults) => {
-  const {
-    blendColorPixelDataCircleMask = defaults.blendColorPixelDataCircleMask,
-    getCircleBrushOrPencilBounds = defaults.getCircleBrushOrPencilBounds,
-
-  } = deps
-
-  const boundsOut: Rect = { x: 0, y: 0, w: 0, h: 0 }
-
-  const blendColorPixelOptions: ColorBlendMaskOptions = {
-    alpha: 255,
-    blendFn: sourceOverPerfect,
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0,
-  }
-
-  return {
-    applyCircleMask(
-      color: Color32,
-      centerX: number,
-      centerY: number,
-      brush: CircleMask,
-      alpha = 255,
-      blendFn?: BlendColor32,
-    ): boolean {
-
-      const target = writer.config.target
-      const b = getCircleBrushOrPencilBounds(
-        centerX,
-        centerY,
-        brush.size,
-        target.width,
-        target.height,
-        boundsOut,
-      )
-
-      const didChange = writer.accumulator.storeRegionBeforeState(b.x, b.y, b.w, b.h)
-      return didChange(
-        blendColorPixelDataCircleMask(
-          target,
-          color,
-          centerX,
-          centerY,
-          brush,
-          alpha,
-          blendFn,
-          blendColorPixelOptions,
-          b,
-        ),
-      )
-    },
-  }
-}) satisfies HistoryMutator<any, Deps>

package/src/Mask/CircleAlphaMask.ts

@@ -1,32 +0,0 @@
-import { type CircleAlphaMask, MaskType } from '../_types'
-
-export function makeCircleAlphaMask(size: number, fallOff: (d: number) => number = () => 1): CircleAlphaMask {
-  const area = size * size
-  const data = new Uint8Array(area)
-  const radius = size / 2
-  const invR = 1 / radius
-
-  const minOffset = -Math.ceil(radius - 0.5)
-
-  for (let y = 0; y < size; y++) {
-    for (let x = 0; x < size; x++) {
-      const dx = x - radius + 0.5
-      const dy = y - radius + 0.5
-      const distSqr = dx * dx + dy * dy
-      if (distSqr <= (radius * radius)) {
-        const dist = Math.sqrt(distSqr)
-        data[y * size + x] = (fallOff(1 - (dist * invR)) * 255) | 0
-      }
-    }
-  }
-
-  return {
-    type: MaskType.ALPHA,
-    data,
-    w: size,
-    h: size,
-    radius,
-    size,
-    minOffset,
-  }
-}

package/src/PixelData/applyRectBrushToPixelData.ts

@@ -1,98 +0,0 @@
-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,
-  centerX: number,
-  centerY: number,
-  brushWidth: number,
-  brushHeight: number,
-  alpha = 255,
-  fallOff: (dist: number) => number,
-  blendFn: BlendColor32 = sourceOverPerfect,
-  bounds?: Rect,
-): boolean {
-  const targetWidth = target.width
-  const targetHeight = target.height
-
-  const b = bounds ?? getRectBrushOrPencilBounds(
-    centerX,
-    centerY,
-    brushWidth,
-    brushHeight,
-    targetWidth,
-    targetHeight,
-  )
-
-  if (b.w <= 0 || b.h <= 0) {
-    return false
-  }
-
-  const data32 = target.data32
-  const baseColor = color & 0x00ffffff
-  const baseSrcAlpha = color >>> 24
-  const isOpaque = alpha === 255
-
-  const invHalfW = 1 / (brushWidth / 2)
-  const invHalfH = 1 / (brushHeight / 2)
-
-  const centerOffsetX = (brushWidth % 2 === 0) ? 0.5 : 0
-  const centerOffsetY = (brushHeight % 2 === 0) ? 0.5 : 0
-  const fCenterX = Math.floor(centerX)
-  const fCenterY = Math.floor(centerY)
-
-  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
-    const dy = Math.abs((py - fCenterY) + centerOffsetY) * invHalfH
-
-    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
-
-      const strength = fallOff(dist)
-      const maskVal = (strength * 255) | 0
-
-      if (maskVal <= 0) continue
-
-      let weight = alpha
-
-      if (isOpaque) {
-        weight = maskVal
-      } else if (maskVal !== 255) {
-        weight = (maskVal * alpha + 128) >> 8
-      }
-
-      let finalCol = color
-
-      if (weight < 255) {
-        const a = (baseSrcAlpha * weight + 128) >> 8
-
-        if (a === 0 && !isOverwrite) continue
-
-        finalCol = ((a << 24) | baseColor) >>> 0 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/blendColorPixelDataCircleMask.ts

@@ -1,92 +0,0 @@
-import {
-  type BlendColor32,
-  type CircleMask,
-  type Color32,
-  type ColorBlendMaskOptions,
-  type IPixelData,
-  MaskType,
-  type Rect,
-} from '../_types'
-import { sourceOverPerfect } from '../BlendModes/blend-modes-perfect'
-import { getCircleBrushOrPencilBounds } from '../Rect/getCircleBrushOrPencilBounds'
-import { blendColorPixelDataAlphaMask } from './blendColorPixelDataAlphaMask'
-import { blendColorPixelDataBinaryMask } from './blendColorPixelDataBinaryMask'
-
-/**
- * Applies a circular mask to pixel data using a pre-calculated alpha mask.
- *
- * @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 brush The pre-calculated CircleBrushAlphaMask.
- * @param alpha The overall opacity of the brush (0-255).
- * @param blendFn
- * @param scratchOptions
- * @param bounds precalculated result from {@link getCircleBrushOrPencilBounds}
- */
-export function blendColorPixelDataCircleMask(
-  target: IPixelData,
-  color: Color32,
-  centerX: number,
-  centerY: number,
-  brush: CircleMask,
-  alpha = 255,
-  blendFn: BlendColor32 = sourceOverPerfect,
-  scratchOptions: ColorBlendMaskOptions = {},
-  bounds?: Rect,
-): boolean {
-  const b = bounds ?? getCircleBrushOrPencilBounds(
-    centerX,
-    centerY,
-    brush.size,
-    target.width,
-    target.height,
-  )
-
-  if (b.w <= 0 || b.h <= 0) return false
-
-  const unclippedStartX = Math.floor(centerX + brush.minOffset)
-  const unclippedStartY = Math.floor(centerY + brush.minOffset)
-
-  // Calculate the intersection between the unclipped mask rect and the allowed bounds
-  const ix = Math.max(unclippedStartX, b.x)
-  const iy = Math.max(unclippedStartY, b.y)
-  const ir = Math.min(unclippedStartX + brush.w, b.x + b.w)
-  const ib = Math.min(unclippedStartY + brush.h, b.y + b.h)
-
-  const iw = ir - ix
-  const ih = ib - iy
-
-  // If the mask falls entirely outside the bounds, exit
-  if (iw <= 0 || ih <= 0) return false
-
-  scratchOptions.x = ix
-  scratchOptions.y = iy
-  scratchOptions.w = iw
-  scratchOptions.h = ih
-  scratchOptions.mx = ix - unclippedStartX
-  scratchOptions.my = iy - unclippedStartY
-  scratchOptions.alpha = alpha
-  scratchOptions.blendFn = blendFn
-
-  if (brush.type === MaskType.ALPHA) {
-    return blendColorPixelDataAlphaMask(
-      target,
-      color,
-      brush,
-      scratchOptions,
-    )
-  }
-
-  if (brush.type === MaskType.BINARY) {
-    return blendColorPixelDataBinaryMask(
-      target,
-      color,
-      brush,
-      scratchOptions,
-    )
-  }
-
-  return false
-}

package/src/PixelTile/PaintBuffer.ts

@@ -1,122 +0,0 @@
-import type { AlphaMaskRect, BinaryMaskRect, Color32, Rect } from '../_types'
-import type { PixelEngineConfig } from '../History/PixelEngineConfig'
-import type { PixelTile } from './PixelTile'
-import type { PixelTilePool } from './PixelTilePool'
-
-export class PaintBuffer {
-  readonly lookup: (PixelTile | undefined)[]
-
-  constructor(
-    readonly config: PixelEngineConfig,
-    readonly tilePool: PixelTilePool,
-  ) {
-    this.lookup = []
-  }
-
-  private processMaskTiles(
-    mask: Rect,
-    callback: (tile: PixelTile, bX: number, bY: number, bW: number, bH: number, mX: number, mY: number) => void,
-  ): void {
-    const { tileShift, targetColumns } = this.config
-
-    const x1 = mask.x >> tileShift
-    const y1 = mask.y >> tileShift
-    const x2 = (mask.x + mask.w - 1) >> tileShift
-    const y2 = (mask.y + mask.h - 1) >> tileShift
-
-    for (let ty = y1; ty <= y2; ty++) {
-      const tileRowIndex = ty * targetColumns
-      const tileTop = ty << tileShift
-
-      for (let tx = x1; tx <= x2; tx++) {
-        const id = tileRowIndex + tx
-        let tile = this.lookup[id]
-
-        if (!tile) {
-          tile = this.tilePool.getTile(id, tx, ty)
-          this.lookup[id] = tile
-        }
-
-        const tileLeft = tx << tileShift
-
-        const startX = Math.max(mask.x, tileLeft)
-        const endX = Math.min(mask.x + mask.w, tileLeft + this.config.tileSize)
-        const startY = Math.max(mask.y, tileTop)
-        const endY = Math.min(mask.y + mask.h, tileTop + this.config.tileSize)
-
-        // Passing 7 primitive arguments to avoid object allocation
-        callback(
-          tile,
-          startX,
-          startY,
-          endX - startX,
-          endY - startY,
-          startX - mask.x,
-          startY - mask.y,
-        )
-      }
-    }
-  }
-
-  writeColorBinaryMaskRect(color: Color32, mask: BinaryMaskRect): void {
-    const { tileShift, tileMask } = this.config
-    const maskData = mask.data
-    const maskW = mask.w
-
-    this.processMaskTiles(mask, (tile, bX, bY, bW, bH, mX, mY) => {
-      const data32 = tile.data32
-      const startTileX = bX & tileMask
-
-      for (let i = 0; i < bH; i++) {
-        const tileY = (bY + i) & tileMask
-        const maskY = mY + i
-        const tileRowOffset = tileY << tileShift
-        const maskRowOffset = maskY * maskW
-
-        const destStart = tileRowOffset + startTileX
-        const maskStart = maskRowOffset + mX
-
-        for (let j = 0; j < bW; j++) {
-          if (maskData[maskStart + j]) {
-            data32[destStart + j] = color
-          }
-        }
-      }
-    })
-  }
-
-  writeColorAlphaMaskRect(color: Color32, mask: AlphaMaskRect): void {
-    const { tileShift, tileMask } = this.config
-    const maskData = mask.data
-    const maskW = mask.w
-    const colorRGB = color & 0x00ffffff
-    const colorA = color >>> 24
-
-    this.processMaskTiles(mask, (tile, bX, bY, bW, bH, mX, mY) => {
-      const data32 = tile.data32
-      const startTileX = bX & tileMask
-
-      for (let i = 0; i < bH; i++) {
-        const tileY = (bY + i) & tileMask
-        const maskY = mY + i
-        const tileRowOffset = tileY << tileShift
-        const maskRowOffset = maskY * maskW
-
-        const destStart = tileRowOffset + startTileX
-        const maskStart = maskRowOffset + mX
-
-        for (let j = 0; j < bW; j++) {
-          const maskA = maskData[maskStart + j]
-          if (maskA > 0) {
-            const finalA = (colorA * maskA + 128) >> 8
-            data32[destStart + j] = (colorRGB | (finalA << 24)) >>> 0 as Color32
-          }
-        }
-      }
-    })
-  }
-
-  clear(): void {
-    this.tilePool.releaseTiles(this.lookup)
-  }
-}

package/src/Rect/getCircleBrushOrPencilBounds.ts

@@ -1,43 +0,0 @@
-import type { Rect } from '../_types'
-
-export function getCircleBrushOrPencilBounds(
-  centerX: number,
-  centerY: number,
-  brushSize: number,
-  targetWidth: number,
-  targetHeight: number,
-  out?: Rect,
-): Rect {
-  const r = brushSize / 2
-
-  const minOffset = -Math.ceil(r - 0.5)
-  const maxOffset = Math.floor(r - 0.5)
-
-  // start is inclusive, end is exclusive
-  const startX = Math.floor(centerX + minOffset)
-  const startY = Math.floor(centerY + minOffset)
-  const endX = Math.floor(centerX + maxOffset) + 1
-  const endY = Math.floor(centerY + maxOffset) + 1
-
-  const res = out ?? {
-    x: 0,
-    y: 0,
-    w: 0,
-    h: 0,
-  }
-
-  const cStartX = Math.max(0, startX)
-  const cStartY = Math.max(0, startY)
-  const cEndX = Math.min(targetWidth, endX)
-  const cEndY = Math.min(targetHeight, endY)
-
-  const w = cEndX - cStartX
-  const h = cEndY - cStartY
-
-  res.x = cStartX
-  res.y = cStartY
-  res.w = w < 0 ? 0 : w
-  res.h = h < 0 ? 0 : h
-
-  return res
-}