pixel-data-js 0.23.1 → 0.25.0

package/src/PixelData/applyCircleBrushToPixelData.ts

@@ -1,91 +0,0 @@
-import {
-  type BlendColor32,
-  type CircleBrushMask,
-  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 brush 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 applyCircleBrushToPixelData(
-  target: IPixelData,
-  color: Color32,
-  centerX: number,
-  centerY: number,
-  brush: CircleBrushMask,
-  alpha = 255,
-  blendFn: BlendColor32 = sourceOverPerfect,
-  scratchOptions: ColorBlendMaskOptions = {},
-  bounds?: Rect,
-): void {
-  const b = bounds ?? getCircleBrushOrPencilBounds(
-    centerX,
-    centerY,
-    brush.size,
-    target.width,
-    target.height,
-  )
-
-  if (b.w <= 0 || b.h <= 0) return
-
-  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
-
-  // Apply the intersected coordinates and internal mask offsets
-  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) {
-    blendColorPixelDataAlphaMask(
-      target,
-      color,
-      brush,
-      scratchOptions,
-    )
-  }
-
-  if (brush.type === MaskType.BINARY) {
-    blendColorPixelDataBinaryMask(
-      target,
-      color,
-      brush,
-      scratchOptions,
-    )
-  }
-}

package/src/PixelData/applyRectBrushToPixelData.ts

@@ -1,85 +0,0 @@
-import type { BlendColor32, Color32, IPixelData, Rect } from '../_types'
-import { sourceOverPerfect } from '../BlendModes/blend-modes-perfect'
-import { getRectBrushOrPencilBounds } from '../Rect/getRectBrushOrPencilBounds'
-
-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,
-): void {
-  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
-
-  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)
-
-  // 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)
-  const fCenterY = Math.floor(centerY)
-
-  const endX = b.x + b.w
-  const endY = b.y + b.h
-  const isOverwrite = (blendFn as any).isOverwrite
-
-  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
-      }
-
-      data32[idx] = blendFn(finalCol, data32[idx] as Color32)
-    }
-  }
-}

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
-}

package/src/Rect/getCircleBrushOrPencilStrokeBounds.ts

@@ -1,24 +0,0 @@
-import type { Rect } from '../_types'
-
-export function getCircleBrushOrPencilStrokeBounds(
-  x0: number,
-  y0: number,
-  x1: number,
-  y1: number,
-  brushSize: number,
-  result: Rect,
-): Rect {
-  const r = Math.ceil(brushSize / 2)
-
-  const minX = Math.min(x0, x1) - r
-  const minY = Math.min(y0, y1) - r
-  const maxX = Math.max(x0, x1) + r
-  const maxY = Math.max(x0, y1) + r
-
-  result.x = Math.floor(minX)
-  result.y = Math.floor(minY)
-  result.w = Math.ceil(maxX - minX)
-  result.h = Math.ceil(maxY - minY)
-
-  return result
-}

package/src/Rect/getRectBrushOrPencilBounds.ts

@@ -1,38 +0,0 @@
-import type { Rect } from '../_types'
-
-export function getRectBrushOrPencilBounds(
-  centerX: number,
-  centerY: number,
-  brushWidth: number,
-  brushHeight: number,
-  targetWidth: number,
-  targetHeight: number,
-  out?: Rect,
-): Rect {
-  const startX = Math.floor(centerX - brushWidth / 2)
-  const startY = Math.floor(centerY - brushHeight / 2)
-  const endX = startX + brushWidth
-  const endY = startY + brushHeight
-
-  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
-}

package/src/Rect/getRectBrushOrPencilStrokeBounds.ts

@@ -1,26 +0,0 @@
-import type { Rect } from '../_types'
-
-export function getRectBrushOrPencilStrokeBounds(
-  x0: number,
-  y0: number,
-  x1: number,
-  y1: number,
-  brushWidth: number,
-  brushHeight: number,
-  result: Rect,
-): Rect {
-  const halfW = brushWidth / 2
-  const halfH = brushHeight / 2
-
-  const minX = Math.min(x0, x1) - halfW
-  const minY = Math.min(y0, y1) - halfH
-  const maxX = Math.max(x0, x1) + halfW
-  const maxY = Math.max(y0, y1) + halfH
-
-  result.x = Math.floor(minX)
-  result.y = Math.floor(minY)
-  result.w = Math.ceil(maxX - minX)
-  result.h = Math.ceil(maxY - minY)
-
-  return result
-}