287 lines
8.2 KiB
TypeScript
287 lines
8.2 KiB
TypeScript
import { ColorAdjustments } from '../types';
|
||
import { EV_PER_UNIT } from './colorUtils';
|
||
|
||
// Static metadata for the continuous (slider) adjustments of the IQ/WB/FILTERS
|
||
// tabs — shared between AdjustmentPanel (chips + slider rows) and App (which
|
||
// needs the open row's bounds to drive drag-on-the-image adjustment). The get
|
||
// /set accessors are stateless so one table serves every render.
|
||
export interface ContinuousParamDef {
|
||
key: string;
|
||
label: string;
|
||
min: number;
|
||
max: number;
|
||
step: number;
|
||
defaultValue: number;
|
||
display: (v: number) => string;
|
||
get: (a: ColorAdjustments) => number;
|
||
set: (v: number) => Partial<ColorAdjustments>;
|
||
// PRO-only knob: the LITE build greys the chip out (PRO corner tag) and
|
||
// cannot open its row, so the value stays at its default there.
|
||
pro?: boolean;
|
||
}
|
||
|
||
const sign = (v: number) => (v > 0 ? `+${v}` : String(v));
|
||
const oneEv = (v: number) => `${v > 0 ? '+' : ''}${v.toFixed(1)} EV`;
|
||
// The spec reads EXPOSURE to two decimals, so "+0.50" and "-0.25" and a plain
|
||
// "0.00" — the EV unit is already on the row's own label, not in its readout.
|
||
const twoStops = (v: number) => `${v > 0 ? '+' : ''}${v.toFixed(2)}`;
|
||
|
||
// The bipolar develop knobs read -100..+100: the spec's own numbers (the panel
|
||
// draws every TONE and PRESENCE slider from -100 to 100, and the tone-mapping doc
|
||
// normalises that /100 on the way to its uniforms). The recipe keeps the ±10 unit
|
||
// every look has always been filed in, so the ×10 belongs to the slider and not
|
||
// to the store: a look saved, shared or shipped in DEFAULT_RECIPES before this
|
||
// still means exactly what it meant. A knob that is not bipolar — a temperature
|
||
// in kelvin, an amount that only goes up — keeps its own scale, because -100 of
|
||
// a percentage is nothing. EXPOSURE is the odd one out: its slider is in stops
|
||
// (-5..+5, two decimals, the spec's own numbers) while the store still holds the
|
||
// ±10 units EV_PER_UNIT converts, so its accessors translate instead of scaling
|
||
// and every recipe's brightness is untouched.
|
||
const HUNDRED = new Set(['contrast', 'color', 'vibrance', 'highlight', 'shadow', 'whites', 'blacks', 'tint', 'denoise', 'clarity', 'dehaze', 'sharpening']);
|
||
const deepen = (def: ContinuousParamDef): ContinuousParamDef =>
|
||
HUNDRED.has(def.key)
|
||
? { ...def, min: -100, max: 100, get: (a) => def.get(a) * 10, set: (v) => def.set(v / 10) }
|
||
: def;
|
||
|
||
export const PARAM_DEFS: {
|
||
iq: ContinuousParamDef[];
|
||
wb: ContinuousParamDef[];
|
||
filters: ContinuousParamDef[];
|
||
} = {
|
||
iq: ([
|
||
{
|
||
key: 'exposure',
|
||
label: 'EXPOSURE',
|
||
min: -5,
|
||
max: 5,
|
||
step: 0.01,
|
||
defaultValue: 0,
|
||
display: twoStops,
|
||
// Stops out, units in: the store has carried ±10 units since the first
|
||
// recipe, so the knob translates rather than replacing the scale. The
|
||
// /4 lands on a whole 0.04 for every step the slider can emit, which keeps
|
||
// the stored number readable in a recipe file.
|
||
get: (a) => (a.exposure ?? 0) * EV_PER_UNIT,
|
||
set: (v) => ({ exposure: Math.round((v / EV_PER_UNIT) * 1e4) / 1e4 }),
|
||
},
|
||
{
|
||
key: 'ev',
|
||
label: 'EV',
|
||
min: -3,
|
||
max: 3,
|
||
step: 0.1,
|
||
defaultValue: 0,
|
||
display: oneEv,
|
||
get: (a) => a.exposureCompensation ?? 0,
|
||
set: (v) => ({ exposureCompensation: v }),
|
||
},
|
||
{
|
||
key: 'contrast',
|
||
label: 'CONTRAST',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.contrast,
|
||
set: (v) => ({ contrast: v }),
|
||
},
|
||
{
|
||
key: 'color',
|
||
label: 'COLOR',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.saturation,
|
||
set: (v) => ({ saturation: v }),
|
||
},
|
||
{
|
||
key: 'vibrance',
|
||
label: 'VIBRANCE',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.vibrance ?? 0,
|
||
set: (v) => ({ vibrance: v }),
|
||
},
|
||
{
|
||
key: 'highlight',
|
||
label: 'HIGHLIGHT',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.highlight ?? 0,
|
||
set: (v) => ({ highlight: v }),
|
||
},
|
||
{
|
||
key: 'shadow',
|
||
label: 'SHADOW',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.shadow ?? 0,
|
||
set: (v) => ({ shadow: v }),
|
||
},
|
||
{
|
||
// The two ends of the same ramp the four tone sliders move together (see
|
||
// TONE_SKSL): WHITE is the knot on 1.00 and BLACK the one on 0.00, each
|
||
// pulled toward the middle as the knob comes down. Not a white-balance
|
||
// move any more, so they sit with the other two on the TONE panel. Same
|
||
// range as the CREATE form's rows, so a look round-trips.
|
||
key: 'whites',
|
||
label: 'WHITE',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.whites ?? 0,
|
||
set: (v) => ({ whites: v }),
|
||
},
|
||
{
|
||
key: 'blacks',
|
||
label: 'BLACK',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.blacks ?? 0,
|
||
set: (v) => ({ blacks: v }),
|
||
},
|
||
] as ContinuousParamDef[]).map(deepen),
|
||
wb: ([
|
||
{
|
||
key: 'temperature',
|
||
label: 'COLOR TEMP',
|
||
min: 2500,
|
||
max: 10000,
|
||
step: 100,
|
||
defaultValue: 5500,
|
||
display: (v) => `${v}K`,
|
||
get: (a) => a.temperature,
|
||
set: (v) => ({ temperature: v }),
|
||
},
|
||
{
|
||
key: 'tint',
|
||
label: 'TINT',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.tint ?? 0,
|
||
set: (v) => ({ tint: v }),
|
||
},
|
||
] as ContinuousParamDef[]).map(deepen),
|
||
filters: ([
|
||
{
|
||
key: 'denoise',
|
||
label: 'NOISE REDUCTION',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: String,
|
||
get: (a) => a.denoise,
|
||
set: (v) => ({ denoise: v }),
|
||
},
|
||
{
|
||
key: 'clarity',
|
||
label: 'CLARITY',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.clarity,
|
||
set: (v) => ({ clarity: v }),
|
||
},
|
||
{
|
||
// The haze the frame's own pixels carry (dark channel prior, toneShader's
|
||
// DEHAZE_SKSL): positive takes the scattered light out, negative puts it
|
||
// back — the same expression, with the transmission pushed above 1, which
|
||
// is the knob a photo shot through mist wants from this side. Its chip sits
|
||
// with the other spatial knob, CLARITY.
|
||
key: 'dehaze',
|
||
label: 'DEHAZE',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: sign,
|
||
get: (a) => a.dehaze ?? 0,
|
||
set: (v) => ({ dehaze: v }),
|
||
},
|
||
{
|
||
key: 'sharpening',
|
||
label: 'SHARPENING',
|
||
min: -10,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: String,
|
||
get: (a) => a.sharpening ?? 0,
|
||
set: (v) => ({ sharpening: v }),
|
||
},
|
||
{
|
||
key: 'grain',
|
||
label: 'MONOCHROME GRAIN',
|
||
min: 0,
|
||
max: 10,
|
||
// Half a step: the grain is a look, not a switch, and the AMOUNT chip in
|
||
// the GRAIN strip is what spends the half.
|
||
step: 0.5,
|
||
defaultValue: 0,
|
||
display: String,
|
||
get: (a) => a.grain,
|
||
set: (v) => ({ grain: v }),
|
||
},
|
||
{
|
||
// The SIZE knob: percent of the stock's own cell (grainShader.ts), so the
|
||
// same number means the same texture RELATIVE to the picture on both
|
||
// platforms and the readout beside it is the stock's, scaled.
|
||
key: 'grainSize',
|
||
label: 'GRAIN SIZE',
|
||
min: 50,
|
||
max: 200,
|
||
step: 5,
|
||
defaultValue: 100,
|
||
display: (v) => `${v}%`,
|
||
get: (a) => a.grainSize ?? 100,
|
||
set: (v) => ({ grainSize: v }),
|
||
},
|
||
{
|
||
key: 'hdf',
|
||
label: 'HDF EFFECT',
|
||
pro: true,
|
||
min: 0,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: String,
|
||
get: (a) => a.hdf ?? 0,
|
||
set: (v) => ({ hdf: v }),
|
||
},
|
||
{
|
||
key: 'vignette',
|
||
label: 'VIGNETTING',
|
||
min: 0,
|
||
max: 10,
|
||
step: 1,
|
||
defaultValue: 0,
|
||
display: String,
|
||
get: (a) => a.vignette ?? 0,
|
||
set: (v) => ({ vignette: v }),
|
||
},
|
||
] as ContinuousParamDef[]).map(deepen),
|
||
};
|