# API de scripts Lua de pxstud.io — Ajustements > Fait partie de la référence de scripts Lua de pxstud.io, dont la vue d'ensemble (https://pxstud.io/fr/docs/scripting.md) explique les conventions. Les groupes d'options et les types auxquels elle renvoie se trouvent dans https://pxstud.io/fr/docs/scripting/option-groups.md et https://pxstud.io/fr/docs/scripting/types.md. Tout dans un seul fichier (en anglais) : https://pxstud.io/llms-full.txt. L'index de tout le site (en anglais) : https://pxstud.io/llms.txt. ### Ajustements Les ajustements de couleur et les effets de couleur (FX) du menu Filtre, chacun en une étape d'annulation sur les cels d'un calque dans les images que tu listes. Ils ignorent la sélection sauf si tu passes respectSelection = true, et ne touchent jamais les pixels totalement transparents. Sur les sprites indexés, indexedMode choisit entre aligner les pixels recolorés sur l'entrée de palette la plus proche ("remap") et modifier les entrées de palette que les cels utilisent ("palette"). #### `app.antiAlias(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Anticrénèle façon pixel art les marches d'escalier là où la couleur A rencontre la couleur B sur les cels d'un calque, en une seule étape d'annulation : seuls les pixels à côté d'une marche d'un pixel changent, d'autant plus que le segment droit est long, tandis que les bords droits, les coins et les diagonales à 45 degrés restent nets (app.setLayerEffects le garde actif à la place, kind "antiAlias"). Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont lissés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `cels` (Array of { layerId = ..., frameId = ... }) — Lisse ces cels, sur plusieurs calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `a` (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); par défaut "#000000") — Couleur A : la couleur dont les marches d'escalier sont lissées là où elle rencontre la couleur B. - `anyA` (boolean; par défaut false) — Passe true pour traiter comme A toute couleur visible autre que B (pour lisser tout un contour). - `b` (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); par défaut "#ffffff") — Couleur B : la couleur que rencontre A. Une couleur entièrement transparente (`"#00000000"`) signifie n'importe quel pixel transparent ; les intermédiaires estompent alors l'alpha de A. - `steps` (integer 1–4; par défaut 2) — Combien de couleurs intermédiaires sont générées de A à B (en OKLCH), et le nombre maximal de pixels qu'une marche prend. - `into` (string; par défaut "b") — Quel côté du bord est repeint : "a", "b" ou "both". - `strength` (integer 0–100; par défaut 100) — Jusqu'où le lissage s'étend le long de chaque segment droit : 100 va jusqu'à la moitié du segment. - `colors` (string; par défaut "any") — Passe "palette" pour ramener les couleurs intermédiaires aux entrées de palette les plus proches. Les sprites indexés le font toujours. - `respectSelection` (boolean; par défaut false) — Passe true pour ne modifier que les pixels à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. Ne renvoie rien. #### `app.autoShade(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Ombre les aplats selon la direction de la lumière, en une seule étape d'annulation (app.setLayerEffects avec kind "autoShade" le garde en direct) : les pixels proches du bord éclairé de chaque région reçoivent des paliers plus clairs, ceux proches du bord opposé des paliers plus sombres. Les paliers suivent la rampe quand elle contient la couleur, sinon ils sont calculés en OKLCH. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ombrés (une image pour le cel actif, toutes pour tous). - `opts` (table, facultatif) - `cels` (Array of { layerId = ..., frameId = ... }) — Ombre ces cels, sur plusieurs calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `target` (string; par défaut "base") — Ce qui est ombré : "base" ombre uniquement les pixels de la couleur de base, "all" ombre chaque aplat avec sa propre rampe. - `base` (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); par défaut "#808080") — La couleur à ombrer quand target vaut "base". - `angle` (integer 0–359; par défaut 135) — D'où vient la lumière, en degrés dans le sens antihoraire depuis la droite : 90 est en haut, 135 en haut à gauche, 270 en bas. - `highlights` (integer 0–5; par défaut 2) — Combien de paliers plus clairs reçoit le côté éclairé ; le bord est le plus clair. - `shadows` (integer 0–5; par défaut 2) — Combien de paliers plus sombres reçoit le côté opposé ; le bord est le plus sombre. - `width` (integer 1–4; par défaut 1) — Combien de pixels de profondeur a chaque palier. - `hueShift` (integer 0–100; par défaut 30) — À quel point les hautes lumières calculées tournent vers le jaune chaud et les ombres vers le bleu froid. - `chroma` (integer -100–100; par défaut 0) — À quel point chaque palier calculé devient plus (ou, en négatif, moins) coloré. - `rim` (boolean; par défaut false) — Passe true pour un reflet de 1 px le long du bord extérieur du côté ombré. - `outline` (boolean; par défaut false) — Passe true pour peindre le bord extérieur de la forme un palier plus sombre que l'ombre la plus profonde. - `colors` (string; par défaut "any") — "palette" aligne les paliers calculés sur la palette de l'image ; les sprites indexés le font toujours. - `ramp` (Array of colors) — Une rampe de couleurs, dans un sens ou dans l'autre, parcourue au lieu de calculer les paliers quand elle contient la couleur ombrée (par exemple app.getContext().shades). Vide : calculés. - `respectSelection` (boolean; par défaut false) — Passe true pour n'ombrer qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. Ne renvoie rien. #### `app.brightnessContrast(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Luminosité/Contraste sur les cels d'un calque, en une seule étape d'annulation : chaque canal devient 128 + factor * (value + brightness * 2.55 - 128), arrondi et borné. Ce n'est pas la courbe d'Aseprite (qui applique le contraste d'abord et met la luminosité à l'échelle). Les pixels totalement transparents sont laissés tels quels. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `brightness` (number -100–100; par défaut 0) — Ajoute brightness * 2.55 à chaque canal de couleur, avant la mise à l'échelle du contraste. - `contrast` (number -100–100; par défaut 0) — Met à l'échelle la distance de chaque canal à 128 par 259(C + 255) / (255(259 - C)), avec C = contrast * 2.55 : -100 aplatit toutes les couleurs à 128, +100 est proche d'un seuil. - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.colorBalance(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Balance des couleurs sur les cels d'un calque, en une seule étape d'annulation : décale la couleur des ombres, des tons moyens et des hautes lumières (pondérée par la luma, 100 = 127.5 niveaux à pleine pondération). Les pixels totalement transparents sont laissés tels quels. Sur les sprites en niveaux de gris, seuls les décalages égaux en rouge, vert et bleu sont acceptés. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `shadows` ({ red = -100..100, green = -100..100, blue = -100..100 }) — Le décalage pour les pixels sombres. Un rouge positif va vers le rouge, un rouge négatif vers le cyan ; de même vert/magenta et bleu/jaune. - `midtones` ({ red = -100..100, green = -100..100, blue = -100..100 }) — Le décalage pour les pixels de luma moyenne. - `highlights` ({ red = -100..100, green = -100..100, blue = -100..100 }) — Le décalage pour les pixels clairs. - `preserveLuminosity` (boolean; par défaut true) — Rétablit la clarté que le décalage a modifiée, pour que seule la couleur bouge. - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.colorCurve(layerId, frameIds, curves, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Courbe de couleur sur les cels d'un calque, en une seule étape d'annulation : une courbe cubique monotone par canal (celle d'Aseprite est linéaire, avec une seule courbe). Les pixels totalement transparents sont laissés tels quels. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `curves` (AdjustCurveChannel: "value" | "red" | "green" | "blue" | "alpha") — Nom de canal vers points de contrôle, par ex. { red = { {0, 0}, {128, 180}, {255, 255} } }. Canaux : "value" (rouge, vert et bleu ensemble), "red", "green", "blue", "alpha" ; les sprites en niveaux de gris n'acceptent que "value" et "alpha". Les points sont des paires {x, y} (0-255, x strictement croissant, 2 ou plus) ; la courbe est une spline monotone lisse passant par eux. - `opts` (table, facultatif) - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.convolutionMatrix(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Matrice de convolution sur les cels d'un calque, en une seule étape d'annulation : flou, netteté, détection de contours, relief, ou n'importe quel noyau que tu fournis. Les voisins transparents n'assombrissent pas les couleurs. Les sprites indexés exigent indexedMode "remap" (les résultats sont alignés sur l'entrée de palette la plus proche). Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `preset` (string) — Un noyau prêt à l'emploi à la place de kernel/width/height : identity, gaussian3, box3, gaussian5, box5, sharpen, edge, emboss, sobelH, sobelV. - `width` (integer 1–9) — Largeur du noyau (impaire). Obligatoire avec kernel. - `height` (integer 1–9) — Hauteur du noyau (impaire). Obligatoire avec kernel. - `kernel` (list of width * height numbers, row by row) — Les poids appliqués au voisinage de chaque pixel, par ex. { 0, -1, 0, -1, 5, -1, 0, -1, 0 } accentue la netteté. - `divisor` (number; par défaut the sum of the kernel (1 if it sums to 0)) — Chaque somme pondérée est divisée par cette valeur (pas 0). - `bias` (number -255–255; par défaut 0) — Ajouté à chaque canal après la division (128 centre un résultat de contours/relief sur le gris). - `red` (boolean; par défaut true) — Applique la convolution au canal rouge. Sur les sprites en niveaux de gris, rouge, vert et bleu forment un seul canal gris : règle les trois de la même façon. - `green` (boolean; par défaut true) — Applique la convolution au canal vert. - `blue` (boolean; par défaut true) — Applique la convolution au canal bleu. - `alpha` (boolean; par défaut false) — Applique aussi la convolution au canal alpha (un flou déborde alors sur les pixels transparents). Désactivé, les pixels totalement transparents restent intacts. - `edges` (ConvolveEdges: "clamp" | "tiled"; par défaut "clamp") — Ce qui est lu au-delà du bord du cel. - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.despeckle(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Antipoussière (un filtre médian) sur les cels d'un calque, en une seule étape d'annulation : retire les pixels isolés et lisse le bruit. Les sprites indexés exigent indexedMode "remap". Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `width` (integer 1–9; par défaut 3) — Largeur de la fenêtre médiane (impaire). - `height` (integer 1–9; par défaut 3) — Hauteur de la fenêtre médiane (impaire). - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. Ne renvoie rien. #### `app.dropShadow(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Dessine une ombre portée, une lueur ou une ombre interne pour les formes des cels d'un calque, en une seule étape d'annulation (app.setLayerEffects la garde dynamique à la place). Les ombres extérieures agrandissent le cel, rogné au canevas, et se placent sous le dessin. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque reçoivent l'ombre (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `cels` (Array of { layerId = ..., frameId = ... }) — Ajoute l'ombre à ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `place` (OutlinePlace: "outside" | "inside"; par défaut "outside") — Une ombre portée ou une lueur sous le dessin ("outside"), ou une ombre interne par-dessus ("inside"). - `dx` (integer -10–10; par défaut 1) — De combien l'ombre tombe vers la droite (négatif : vers la gauche). 0 et 0 donne une lueur. - `dy` (integer -10–10; par défaut 1) — De combien l'ombre tombe vers le bas (négatif : vers le haut). - `spread` (integer 0–10; par défaut 0) — De combien de pixels l'ombre dépasse la silhouette du dessin. - `shape` (FxShape: "circle" | "square" | "diamond"; par défaut "circle") — L'empreinte de l'expansion. - `softness` (integer 0–8; par défaut 0) — Sur combien de pixels le bord de l'ombre s'estompe (un rayon de flou) ; 0 donne un bord net. - `edge` (ShadowEdge: "dithered" | "hard" | "smooth"; par défaut "dithered") — Comment un bord adouci (softness supérieur à 0) est dessiné : "dithered" garde une seule couleur sous forme de tramage ordonné qui reste en place quand le dessin bouge, "hard" le coupe à mi-intensité, "smooth" crée de vrais pixels semi-transparents. - `color` (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); par défaut "#00000080") — La couleur de l'ombre ; son alpha est l'opacité de l'ombre. Sur un sprite indexé, le résultat est aligné sur la palette. - `respectSelection` (boolean; par défaut false) — Passe true pour ne peindre qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. Ne renvoie rien. #### `app.gradientMap(layerId, frameIds, stops, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Courbe de dégradé sur les cels d'un calque, en une seule étape d'annulation : la luma de chaque pixel choisit une couleur dans la rampe. Un pixel garde son alpha. Les pixels totalement transparents sont laissés tels quels. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `stops` (table) — 2 à 32 points de dégradé, `{ { color = ..., position = 0 }, { color = ..., position = 1 } }` : la couleur que prend un pixel à cette luma (0 = le plus sombre, 1 = le plus clair). - `opts` (table, facultatif) - `space` (GradientMapSpace: "rgb" | "oklab" | "oklch"; par défaut "oklab") — L'espace colorimétrique dans lequel on fusionne entre les points. - `reverse` (boolean; par défaut false) — Parcourt la rampe du clair au sombre. - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.hueSaturation(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Teinte/Saturation en mode hsv, hsl ou oklch perceptuel sur les cels d'un calque, en une seule étape d'annulation. Une luminosité et un alpha positifs tirent vers le maximum au lieu de multiplier comme le fait Aseprite, donc +50 de luminosité transforme le noir en gris moyen. Les pixels totalement transparents sont laissés tels quels. Sur les sprites en niveaux de gris, la teinte et la saturation n'ont aucun effet. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `mode` (AdjustHueMode: "hsv" | "hsl" | "oklch"; par défaut "hsv") — Le modèle colorimétrique dans lequel travailler. - `hue` (number -180–180; par défaut 0) — Degrés ajoutés à chaque teinte. - `saturation` (number -100–100; par défaut 0) — Met la saturation à l'échelle (la chroma en mode oklch) : -100 donne du gris, +100 la double (plafonnée au maximum, ou à la gamme sRGB en mode oklch). Les gris restent gris. - `lightness` (number -100–100; par défaut 0) — Clarté en modes hsl et oklch, valeur en mode hsv. Une valeur positive parcourt cette part du chemin restant vers le blanc/le maximum (l + (1 - l) * k, k = lightness / 100), donc +100 l'atteint ; une valeur négative met à l'échelle vers le noir (l * (1 + k)), donc -100 l'atteint. - `alpha` (number -100–100; par défaut 0) — La même élévation sur l'alpha (arrondie) : +100 rend opaque chaque pixel non transparent, -100 les rend transparents. - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.invertColor(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Inverser les couleurs, comme dans Aseprite, sur les cels d'un calque, en une seule étape d'annulation. Les pixels totalement transparents sont laissés tels quels. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `red` (boolean; par défaut true) — Inverse le canal rouge. Sur les sprites en niveaux de gris, rouge, vert et bleu forment un seul canal gris : règle les trois de la même façon. - `green` (boolean; par défaut true) — Inverse le canal vert. - `blue` (boolean; par défaut true) — Inverse le canal bleu. - `alpha` (boolean; par défaut false) — Inverse le canal alpha (les pixels totalement transparents restent transparents). - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.levels(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Niveaux sur les cels d'un calque, en une seule étape d'annulation : chaque canal est remis à l'échelle depuis la plage d'entrée, courbé par le gamma et projeté sur la plage de sortie. Les pixels totalement transparents sont laissés tels quels. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `inBlack` (integer 0–254; par défaut 0) — Les valeurs d'entrée inférieures ou égales à celle-ci deviennent outBlack. - `inWhite` (integer 1–255; par défaut 255) — Les valeurs d'entrée supérieures ou égales à celle-ci deviennent outWhite. Doit être supérieur à inBlack. - `gamma` (number 0.1–10; par défaut 1) — Courbe des tons moyens : au-dessus de 1 éclaircit les tons moyens, en dessous de 1 les assombrit. - `outBlack` (integer 0–255; par défaut 0) — La valeur de sortie pour une entrée noire. - `outWhite` (integer 0–255; par défaut 255) — La valeur de sortie pour une entrée blanche. Inférieure à outBlack, elle inverse. - `red` ({ inBlack, inWhite, gamma, outBlack, outWhite }) — Niveaux pour le seul canal rouge, appliqués après les niveaux principaux. Les sprites en niveaux de gris refusent les canaux seuls. - `green` ({ inBlack, inWhite, gamma, outBlack, outWhite }) — Niveaux pour le seul canal vert. - `blue` ({ inBlack, inWhite, gamma, outBlack, outWhite }) — Niveaux pour le seul canal bleu. - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.posterize(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Postériser : réduit chaque canal de couleur des cels d'un calque à quelques niveaux, en une seule étape d'annulation. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `levels` (integer 2–256; par défaut 4) — Nombre de niveaux distincts conservés par canal de couleur (l'alpha n'est pas touché). - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.reduceColors(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Réduire les couleurs : projette les cels d'un calque sur quelques couleurs (générées à partir de ces cels, ou de la palette), avec tramage en option, en une seule étape d'annulation. L'alpha est conservé ; le sprite garde son mode colorimétrique. Les sprites indexés exigent indexedMode "remap". Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `colors` (integer 1–256; par défaut 16) — Combien de couleurs garder (paletteSource "generate"). - `paletteSource` (ReduceColorsPalette: "generate" | "palette"; par défaut "generate") — Génère les couleurs à partir des cels, ou utilise la palette du sprite. - `dithering` (DitherMethod: "none" | "bayer2" | "bayer4" | "bayer8" | "floydSteinberg" | "atkinson"; par défaut "none") — Comment les couleurs intermédiaires sont approchées. - `ditherAmount` (integer 0–100; par défaut 100) — Force du tramage (0 = couleur la plus proche uniquement). - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. Ne renvoie rien. #### `app.replaceColor(layerId, frameIds, from, to, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Remplacer la couleur, comme dans Aseprite, sur les cels d'un calque, en une seule étape d'annulation. Les pixels totalement transparents ne correspondent jamais. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `from` (color) — La couleur à trouver. - `to` (color) — La couleur à mettre à sa place (alpha compris). - `opts` (table, facultatif) - `tolerance` (integer 0–255; par défaut 0) — Un pixel correspond quand aucun de ses canaux r, g, b, a n'est plus éloigné que cela de `from`. - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien. #### `app.threshold(layerId, frameIds, opts?)` — modifie, annulable, refusée sur un calque verrouillé Filtre > Seuil sur les cels d'un calque, en une seule étape d'annulation : chaque pixel devient l'une de deux couleurs selon sa luma (le rgb_luma d'Aseprite). Les pixels totalement transparents sont laissés tels quels. Calques d'image uniquement. - `layerId` (string) - `frameIds` (table) — Tableau d'ids d'images dont les cels de ce calque sont ajustés (une image pour le cel actif, toutes les images pour tous). - `opts` (table, facultatif) - `level` (integer 0–255; par défaut 128) — Les pixels dont la luma est au moins égale à cette valeur deviennent `above`, les autres `below`. - `below` (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); par défaut "#000000") — La couleur des pixels sous le niveau. L'alpha est ignoré : un pixel garde le sien. - `above` (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); par défaut "#ffffff") — La couleur des pixels au niveau ou au-dessus. L'alpha est ignoré. - `cels` (Array of { layerId = ..., frameId = ... }) — Ajuste ces cels, à travers calques et images, au lieu de layerId/frameIds (passe nil pour les deux). - `respectSelection` (boolean; par défaut false) — Passe true pour n'ajuster qu'à l'intérieur de la sélection actuelle. Par défaut, la sélection est ignorée. - `indexedMode` (AdjustIndexedMode: "remap" | "palette"; par défaut "remap") — Sprites indexés uniquement : recolorer les pixels et les aligner sur l'entrée de palette la plus proche, ou modifier les entrées de palette utilisées par les cels. Ne renvoie rien.