Skip to content

Free open-source image editor for the browser

6.7 KB
Raw Blame
import { BrushIcon } from "@/components/icons/brush";
import { ColorMixerIcon } from "@/components/icons/color-mixer";
import { DetailsIcon } from "@/components/icons/details";
import { ExposureIcon } from "@/components/icons/exposure";
import { GrainIcon } from "@/components/icons/grain";
import { HealIcon } from "@/components/icons/heal";
import { LutIcon } from "@/components/icons/lut";
import { VignetteIcon } from "@/components/icons/vignette";
import {
  type EditorDocument,
  type EffectLayer,
  findLayer,
  hasPaint,
  type ImageLayer,
  type Layer,
  type LookupTable,
  type Mask,
  type MaskLayer,
  type ProcessingLayer,
} from "@/core/document";
import type { WhiteBalance } from "@/core/image";
import { defaultAdjustments } from "@/features/adjustments/model";
import { defaultMixer, isNeutral } from "@/features/color-mixer/model";
import { defaultDetails } from "@/features/details/model";
import { defaultFill } from "@/features/fill/model";
import { defaultGrain } from "@/features/grain/model";
import type { EffectKind } from "@/features/layers/controls";
import type { LayerPlacement } from "@/features/layers/edits";
import { defaultCurve } from "@/features/tone-curves/curve";
import { defaultVignette } from "@/features/vignette/model";

function baseLayer() {
  return { id: crypto.randomUUID(), visible: true, opacity: 1, children: [] };
}

export function createImageLayer(
  source: string,
  name: string,
  whiteBalance?: WhiteBalance,
): ImageLayer {
  return {
    kind: "image",
    id: crypto.randomUUID(),
    name,
    source,
    whiteBalance,
    adjustments: { ...defaultAdjustments },
    toneCurve: defaultCurve,
    children: [],
  };
}

/** Every effect kind's name and mark, in Add menu order; the stack and new layers read it. */
export const effectKinds = [
  { kind: "details", label: "Details", Icon: DetailsIcon, addable: true },
  { kind: "exposure", label: "Exposure", Icon: ExposureIcon, addable: true },
  {
    kind: "color-mixer",
    label: "Color Mixer",
    Icon: ColorMixerIcon,
    addable: true,
  },
  { kind: "vignette", label: "Vignette", Icon: VignetteIcon, addable: true },
  { kind: "grain", label: "Grain", Icon: GrainIcon, addable: true },
  { kind: "fill", label: "Color", addable: true },
  { kind: "lut", label: "LUT", Icon: LutIcon, addable: true },
  { kind: "heal", label: "Healing", Icon: HealIcon, addable: false },
  { kind: "paint", label: "Paint", Icon: BrushIcon, addable: false },
] as const satisfies readonly EffectKind[];

/** Effects that start from defaults; a LUT layer needs its table first. */
export type DefaultEffect = Exclude<EffectLayer["kind"], "lut">;

export function createLayer<K extends DefaultEffect>(
  kind: K,
): Extract<EffectLayer, { kind: K }>;
export function createLayer(kind: DefaultEffect): EffectLayer {
  const name = effectKinds.find((entry) => entry.kind === kind)?.label ?? kind;
  const base = { ...baseLayer(), name };
  switch (kind) {
    case "details":
      return { ...base, kind, details: { ...defaultDetails } };
    case "exposure":
      return { ...base, kind, exposure: 1 };
    case "vignette":
      return { ...base, kind, vignette: { ...defaultVignette, intensity: 50 } };
    case "grain":
      return { ...base, kind, grain: { ...defaultGrain, amount: 25 } };
    case "color-mixer":
      return { ...base, kind, colorMixer: defaultMixer };
    case "fill":
      return { ...base, kind, fill: { ...defaultFill } };
    case "heal":
      return { ...base, kind, patches: [] };
    case "paint":
      return { ...base, kind, blend: "normal", strokes: [] };
  }
}

export function createLutLayer(
  name: string,
  lut: LookupTable,
): Extract<EffectLayer, { kind: "lut" }> {
  return { ...baseLayer(), kind: "lut", name, lut };
}

/** Where a new effect goes: inside a selected root mask, or above the selection. */
export function newLayerPlacement(document: EditorDocument): LayerPlacement {
  const scene = document.scene.getState();
  const selected = document.selection.getState().layerId;
  const layer = findLayer(scene.layers, selected);
  return layer?.kind === "mask" && scene.layers.includes(layer)
    ? { inside: selected }
    : { above: selected };
}

const maskNames: Record<Mask["kind"], string> = {
  linear: "Linear Gradient",
  radial: "Radial Gradient",
  brush: "Brush",
  "luminance-range": "Luminance Range",
  "color-range": "Color Range",
};

export function createMask(
  mask: Mask,
  operation: MaskLayer["operation"] = "add",
): MaskLayer {
  return {
    ...baseLayer(),
    kind: "mask",
    name: maskNames[mask.kind],
    operation,
    adjustments: { ...defaultAdjustments },
    toneCurve: defaultCurve,
    mask,
  };
}

function effectNeutral(layer: ProcessingLayer): boolean {
  if (!layer.visible || layer.opacity === 0) {
    return true;
  }
  switch (layer.kind) {
    case "details":
      return layer.details.clarity === 0 && layer.details.sharpening === 0;
    case "exposure":
      return layer.exposure === 0;
    case "vignette":
      return layer.vignette.intensity === 0;
    case "grain":
      return layer.grain.amount === 0;
    case "color-mixer":
      return isNeutral(layer.colorMixer);
    case "fill":
    case "lut":
      return false;
    case "heal":
      return layer.patches.length === 0;
    case "paint":
      return !hasPaint(layer);
    case "mask":
      return true;
  }
}

/** A mask that changes nothing yet: default adjustments and curve, and no active child effect. */
export function maskNeutral(layer: MaskLayer) {
  return (
    Object.entries(defaultAdjustments).every(
      ([key, value]) => Reflect.get(layer.adjustments, key) === value,
    ) &&
    layer.toneCurve.every((point) => point.x === point.y) &&
    layer.children.every(effectNeutral)
  );
}

/** The first root effect of a kind. */
export function findEffect<K extends EffectLayer["kind"]>(
  layers: readonly Layer[],
  kind: K,
) {
  return layers.find(
    (layer): layer is Extract<EffectLayer, { kind: K }> => layer.kind === kind,
  );
}

/** Convenience commands address the first root effect of a kind or create one on top of the stack as one entry; returns the layer edited. */
export function editEffect(
  document: EditorDocument,
  kind: DefaultEffect,
  id: string | undefined,
  edit: (id: string) => void,
) {
  const scene = document.scene.getState();
  const existing = id ?? findEffect(scene.layers, kind)?.id;
  if (existing) {
    edit(existing);
    return existing;
  }
  const layer = createLayer(kind);
  const opened = document.history.begin();
  try {
    document.edit({ ...scene, layers: [...scene.layers, layer] });
    edit(layer.id);
    if (opened) {
      document.history.commit();
    }
  } catch (error) {
    if (opened) {
      document.history.cancel();
    }
    throw error;
  }
  return layer.id;
}