Skip to content

Free open-source image editor for the browser

11.9 KB
Raw Blame
import { Button } from "@roprgm/ui/button";
import { Slider } from "@roprgm/ui/slider";
import { type ReactNode, useCallback, useState } from "react";
import { useStore } from "zustand";
import { effectKinds } from "@/app/editor/layers";
import { DockChips, DockControls } from "@/components/editor/dock";
import { PanelBody, PanelHeader } from "@/components/editor/panel";
import type { Parameter } from "@/components/editor/parameter";
import { useRenderer } from "@/components/editor/pipeline";
import { useDocument, useScene } from "@/components/editor/session";
import {
  adjustmentTarget,
  type EditorDocument,
  findLayer,
  type ImageLayer,
  type Layer,
  type MaskLayer,
  type ToneCurve,
} from "@/core/document";
import {
  AdjustmentControls,
  adjustmentParameters,
  color,
  tone,
} from "@/features/adjustments/controls";
import { setExposure } from "@/features/adjustments/edits";
import {
  ColorMixerControls,
  mixerParameters,
} from "@/features/color-mixer/controls";
import { channels, type MixerChannel } from "@/features/color-mixer/model";
import {
  DetailsControls,
  detailsParameters,
} from "@/features/details/controls";
import { FillControls } from "@/features/fill/controls";
import { GrainControls, grainParameters } from "@/features/grain/controls";
import { HealControls } from "@/features/heal/controls";
import { HealModeButtons } from "@/features/heal/mode-buttons";
import { Histogram } from "@/features/histogram";
import { setLayer } from "@/features/layers/edits";
import { OverlayToggle } from "@/features/layers/overlay-toggle";
import { LutCurves } from "@/features/lut/curves";
import { PaintControls } from "@/features/paint/controls";
import { defaultCurve } from "@/features/tone-curves/curve";
import { setToneCurve } from "@/features/tone-curves/edits";
import { ToneCurves } from "@/features/tone-curves/tone-curves";
import {
  VignetteControls,
  vignetteParameters,
} from "@/features/vignette/controls";
import {
  useWhiteBalance,
  WhiteBalanceControls,
} from "@/features/white-balance/controls";
import { useEditGesture } from "@/hooks/use-edit-gesture";

type Kind<K extends Layer["kind"]> = Extract<Layer, { kind: K }>;

/** Names what the controls edit, not the layer, whose name the stack already shows. */
function panelTitle(layer: Layer) {
  if (layer.kind === "image") return "Adjustments";
  if (layer.kind === "mask") return "Mask adjustments";
  return effectKinds.find((entry) => entry.kind === layer.kind)?.label;
}

const curveHistogramColors = ["#a3a3a3"] as const;

function CurveInputHistogram({ id }: { id: string }) {
  const renderer = useRenderer();
  const image = useCallback(() => renderer.inputImage(id), [renderer, id]);
  return (
    <Histogram
      image={image}
      subscribe={renderer.subscribe}
      colors={curveHistogramColors}
      working
      fillOpacity={0.65}
      aria-label="curve input histogram"
      className="pointer-events-none absolute inset-0 h-full w-full opacity-25"
    />
  );
}

function LayerCurve({
  id,
  toneCurve,
  fill,
}: {
  id: string;
  toneCurve: ToneCurve;
  fill?: boolean;
}) {
  const document = useDocument();
  return (
    <ToneCurves
      points={toneCurve}
      fill={fill}
      onChange={(points) => setToneCurve(document, points, id)}
    >
      <CurveInputHistogram id={id} />
    </ToneCurves>
  );
}

function exposureParameter(
  document: EditorDocument,
  layer: Kind<"exposure">,
): Parameter {
  return {
    id: "exposure",
    label: "Exposure",
    value: layer.exposure,
    min: -5,
    max: 5,
    step: 0.01,
    defaultValue: 0,
    onChange: (value) => setExposure(document, layer.id, value),
  };
}

/** A LUT's strength is its layer's opacity. */
function intensityParameter(
  document: EditorDocument,
  layer: Kind<"lut">,
): Parameter {
  return {
    id: "intensity",
    label: "Intensity",
    value: layer.opacity * 100,
    min: 0,
    max: 100,
    defaultValue: 100,
    onChange: (value) => setLayer(document, layer.id, { opacity: value / 100 }),
  };
}

function SelectedControls({ layer }: { layer: Layer }) {
  const document = useDocument();
  switch (layer.kind) {
    case "details":
      return <DetailsControls id={layer.id} details={layer.details} />;
    case "image":
    case "mask":
      return (
        <>
          <AdjustmentControls
            id={layer.id}
            adjustments={layer.adjustments}
            whiteBalance={<WhiteBalanceControls layer={layer} />}
          />
          <div className="px-3.5 pb-3.5">
            <LayerCurve id={layer.id} toneCurve={layer.toneCurve} />
          </div>
        </>
      );
    case "color-mixer":
      return <ColorMixerControls id={layer.id} mixer={layer.colorMixer} />;
    case "vignette":
      return <VignetteControls id={layer.id} vignette={layer.vignette} />;
    case "grain":
      return <GrainControls id={layer.id} grain={layer.grain} />;
    case "fill":
      return <FillControls id={layer.id} fill={layer.fill} />;
    case "lut": {
      const { id, ...intensity } = intensityParameter(document, layer);
      return (
        <section className="flex flex-col gap-3.5 p-3.5">
          <Slider {...intensity} />
          <LutCurves lut={layer.lut} opacity={layer.opacity} />
        </section>
      );
    }
    case "heal":
      return <HealControls id={layer.id} patches={layer.patches} />;
    case "paint":
      return <PaintControls layer={layer} />;
    case "exposure": {
      const { id, ...parameter } = exposureParameter(document, layer);
      return (
        <section className="p-3.5">
          <Slider {...parameter} />
        </section>
      );
    }
  }
}

/** The layer the controls edit, the selection or the mask a selected child mask belongs to, and whether a mask is selected. */
function useAdjustmentTarget() {
  const document = useDocument();
  const selected = useStore(document.selection, (state) => state.layerId);
  const target = useScene(
    (scene) => adjustmentTarget(scene.layers, selected) ?? scene.layers[0],
  );
  const mask = useScene(
    (scene) => findLayer(scene.layers, selected)?.kind === "mask",
  );
  return { target, mask };
}

export function AdjustPanel() {
  const document = useDocument();
  const gesture = useEditGesture(document.history);
  const { target, mask } = useAdjustmentTarget();
  return (
    <PanelBody
      header={
        <PanelHeader title={panelTitle(target) ?? target.name}>
          {mask && <OverlayToggle />}
          {target.kind === "heal" && <HealModeButtons />}
        </PanelHeader>
      }
    >
      <div {...gesture}>
        <SelectedControls layer={target} />
      </div>
    </PanelBody>
  );
}

const groups = [
  ["light", "Light"],
  ["color", "Color"],
  ["curve", "Curve"],
] as const;
type Group = (typeof groups)[number][0];

/** An image or mask in the dock: its tone, color, or curve, one group at a time. */
function AdjustmentDials({
  layer,
  group,
  onGroupChange,
  action,
}: {
  layer: ImageLayer | MaskLayer;
  group: Group;
  onGroupChange: (group: Group) => void;
  action: ReactNode;
}) {
  const document = useDocument();
  const whiteBalance = useWhiteBalance(layer);
  const header = (
    <DockChips
      label="Adjustment group"
      items={groups}
      value={group}
      onChange={onGroupChange}
    />
  );
  if (group === "curve") {
    return (
      <DockControls
        tall
        header={header}
        action={
          <>
            <Button
              variant="ghost"
              size="sm"
              aria-label="Reset curve"
              onClick={() => setToneCurve(document, defaultCurve, layer.id)}
            >
              Reset
            </Button>
            {action}
          </>
        }
      >
        <div className="mx-auto min-h-0 w-full max-w-72 flex-1 px-3.5">
          <LayerCurve id={layer.id} toneCurve={layer.toneCurve} fill />
        </div>
      </DockControls>
    );
  }
  const adjustments = (controls: Parameters<typeof adjustmentParameters>[3]) =>
    adjustmentParameters(document, layer.id, layer.adjustments, controls);
  if (group === "color") {
    return (
      <DockControls
        header={header}
        action={
          <>
            {whiteBalance.auto && (
              <Button
                variant="ghost"
                size="sm"
                aria-label="Auto white balance"
                onClick={whiteBalance.auto}
              >
                Auto
              </Button>
            )}
            {action}
          </>
        }
        parameters={[...whiteBalance.parameters, ...adjustments(color)]}
      />
    );
  }
  return (
    <DockControls
      header={header}
      action={action}
      parameters={adjustments(tone)}
    />
  );
}

function MixerDials({ layer }: { layer: Kind<"color-mixer"> }) {
  const document = useDocument();
  const [channel, setChannel] = useState<MixerChannel>("hue");
  return (
    <DockControls
      header={
        <DockChips
          label="Color Mixer adjustment"
          items={channels.map(({ id, label }) => [id, label] as const)}
          value={channel}
          onChange={setChannel}
        />
      }
      parameters={mixerParameters(
        document,
        layer.id,
        layer.colorMixer,
        channel,
      )}
    />
  );
}

function DockTitle({ layer }: { layer: Layer }) {
  return <h2 className="font-medium text-foreground">{panelTitle(layer)}</h2>;
}

function SelectedDials({
  layer,
  mask,
  group,
  onGroupChange,
}: {
  layer: Layer;
  mask: boolean;
  group: Group;
  onGroupChange: (group: Group) => void;
}) {
  const document = useDocument();
  switch (layer.kind) {
    case "image":
    case "mask":
      return (
        <AdjustmentDials
          layer={layer}
          group={group}
          onGroupChange={onGroupChange}
          action={mask && <OverlayToggle />}
        />
      );
    case "color-mixer":
      return <MixerDials layer={layer} />;
    case "details":
      return (
        <DockControls
          header={<DockTitle layer={layer} />}
          parameters={detailsParameters(document, layer.id, layer.details)}
        />
      );
    case "vignette":
      return (
        <DockControls
          header={<DockTitle layer={layer} />}
          parameters={vignetteParameters(document, layer.id, layer.vignette)}
        />
      );
    case "grain":
      return (
        <DockControls
          header={<DockTitle layer={layer} />}
          parameters={grainParameters(document, layer.id, layer.grain)}
        />
      );
    case "exposure":
      return (
        <DockControls
          header={<DockTitle layer={layer} />}
          parameters={[exposureParameter(document, layer)]}
        />
      );
    case "fill":
      return (
        <DockControls header={<DockTitle layer={layer} />}>
          <FillControls id={layer.id} fill={layer.fill} />
        </DockControls>
      );
    case "lut":
      return (
        <DockControls
          header={<DockTitle layer={layer} />}
          parameters={[intensityParameter(document, layer)]}
        />
      );
    case "heal":
      return (
        <DockControls header={<DockTitle layer={layer} />}>
          <div className="max-h-48 overflow-y-auto">
            <HealControls id={layer.id} patches={layer.patches} />
          </div>
        </DockControls>
      );
    case "paint":
      return (
        <DockControls header={<DockTitle layer={layer} />}>
          <PaintControls layer={layer} />
        </DockControls>
      );
  }
}

/** The selected layer's controls in the dock: dials where the sidebar has sliders. */
export function AdjustDock() {
  const document = useDocument();
  const gesture = useEditGesture(document.history);
  const { target, mask } = useAdjustmentTarget();
  // The group stays as the selection moves between images and masks.
  const [group, setGroup] = useState<Group>("light");
  return (
    <div className="flex min-h-0 flex-1 flex-col" {...gesture}>
      <SelectedDials
        layer={target}
        mask={mask}
        group={group}
        onGroupChange={setGroup}
      />
    </div>
  );
}