Ajustes

app.antiAlias(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Aplica antisserrilhado no estilo pixel art aos degraus onde a cor A encontra a cor B nos cels de uma camada, como um único passo de desfazer: só mudam os pixels ao lado de um degrau de um pixel, mais quanto mais longo o trecho reto, enquanto bordas retas, cantos e diagonais de 45 graus continuam nítidos (app.setLayerEffects o mantém ao vivo, kind "antiAlias"). Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são suavizados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • cels (Array of { layerId = ..., frameId = ... }) — Suaviza estes cels, em várias camadas e quadros, em vez de layerId/frameIds (passe nil para os dois).
  • a (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); padrão "#000000") — Cor A: a cor cujos degraus são suavizados onde ela encontra a cor B.
  • anyA (boolean; padrão false) — Passe true para tratar como A toda cor visível diferente de B (para suavizar um contorno inteiro).
  • b (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); padrão "#ffffff") — Cor B: a cor que A encontra. Uma cor totalmente transparente ("#00000000") significa qualquer pixel transparente; as intermediárias então esmaecem o alfa de A.
  • steps (integer 1–4; padrão 2) — Quantas cores intermediárias são geradas de A até B (em OKLCH), e o máximo de pixels que um degrau recebe.
  • into (string; padrão "b") — Qual lado da borda é repintado: "a", "b" ou "both".
  • strength (integer 0–100; padrão 100) — Até onde a suavização vai ao longo de cada trecho reto: 100 vai até a metade do trecho.
  • colors (string; padrão "any") — Passe "palette" para ajustar as cores intermediárias às entradas da paleta mais próximas. Sprites indexados sempre fazem isso.
  • respectSelection (boolean; padrão false) — Passe true para alterar só os pixels dentro da seleção atual. Por padrão a seleção é ignorada.

Não retorna nada.

app.autoShade(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Sombreia cores chapadas a partir da direção da luz, como um único passo de desfazer (app.setLayerEffects com kind "autoShade" o mantém ao vivo): os pixels perto da borda iluminada de cada região recebem passos mais claros, os perto da borda oposta passos mais escuros. Os passos seguem a rampa quando ela contém a cor; senão, são calculados em OKLCH. Apenas camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são sombreados (um quadro para o cel ativo, todos para todos).
• opts (table, opcional)
  • cels (Array of { layerId = ..., frameId = ... }) — Sombreia estes cels, em várias camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • target (string; padrão "base") — O que sombrear: "base" sombreia apenas os pixels da cor base, "all" sombreia cada cor chapada com uma rampa própria.
  • base (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); padrão "#808080") — A cor a sombrear quando target é "base".
  • angle (integer 0–359; padrão 135) — De onde vem a luz, em graus no sentido anti-horário a partir da direita: 90 é em cima, 135 em cima à esquerda, 270 embaixo.
  • highlights (integer 0–5; padrão 2) — Quantos passos mais claros o lado iluminado recebe; a borda é a mais clara.
  • shadows (integer 0–5; padrão 2) — Quantos passos mais escuros o lado oposto recebe; a borda é a mais escura.
  • width (integer 1–4; padrão 1) — Quantos pixels de profundidade tem cada passo.
  • hueShift (integer 0–100; padrão 30) — O quanto os realces calculados viram para o amarelo quente e as sombras para o azul frio.
  • chroma (integer -100–100; padrão 0) — O quanto cada passo calculado fica mais (ou, se negativo, menos) colorido.
  • rim (boolean; padrão false) — Passe true para um realce de 1 px ao longo da borda externa do lado em sombra.
  • outline (boolean; padrão false) — Passe true para pintar a borda externa da forma um passo mais escuro que a sombra mais profunda.
  • colors (string; padrão "any") — "palette" ajusta os passos calculados à paleta do quadro; sprites indexados sempre fazem isso.
  • ramp (Array of colors) — Uma rampa de cores, em qualquer ordem, percorrida em vez de calcular os passos quando contém a cor sombreada (por exemplo app.getContext().shades). Vazia: calculados.
  • respectSelection (boolean; padrão false) — Passe true para sombrear apenas dentro da seleção atual. Por padrão a seleção é ignorada.

Não retorna nada.

app.brightnessContrast(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Brilho/Contraste nos cels de uma camada, como uma única etapa de desfazer: cada canal vira 128 + factor * (value + brightness * 2.55 - 128), arredondado e limitado. Não é a curva do Aseprite (que aplica o contraste primeiro e escala o brilho). Pixels totalmente transparentes são deixados como estão. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • brightness (number -100–100; padrão 0) — Soma brightness * 2.55 a cada canal de cor, antes da escala de contraste.
  • contrast (number -100–100; padrão 0) — Escala a distância de cada canal até 128 por 259(C + 255) / (255(259 - C)), com C = contrast * 2.55: -100 achata toda a cor para 128, +100 fica próximo de um limiar.
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.colorBalance(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Balanço de cores nos cels de uma camada, como uma única etapa de desfazer: desloca a cor das sombras, dos meios-tons e das altas luzes (ponderadas por luma, 100 = 127.5 níveis com peso total). Pixels totalmente transparentes são deixados como estão. Em sprites em tons de cinza, só são aceitos deslocamentos com vermelho, verde e azul iguais. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • shadows ({ red = -100..100, green = -100..100, blue = -100..100 }) — O deslocamento para pixels escuros. Vermelho positivo vai em direção ao vermelho, negativo em direção ao ciano; da mesma forma verde/magenta e azul/amarelo.
  • midtones ({ red = -100..100, green = -100..100, blue = -100..100 }) — O deslocamento para pixels de luma média.
  • highlights ({ red = -100..100, green = -100..100, blue = -100..100 }) — O deslocamento para pixels claros.
  • preserveLuminosity (boolean; padrão true) — Devolve a luminosidade que o deslocamento alterou, para que só a cor se mova.
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.colorCurve(layerId, frameIds, curves, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Curva de cores nos cels de uma camada, como uma única etapa de desfazer: uma curva cúbica monótona por canal (a do Aseprite é linear, com uma única curva). Pixels totalmente transparentes são deixados como estão. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• curves (AdjustCurveChannel: "value" | "red" | "green" | "blue" | "alpha") — Nome do canal para pontos de controle, p. ex. { red = { {0, 0}, {128, 180}, {255, 255} } }. Canais: "value" (vermelho, verde e azul juntos), "red", "green", "blue", "alpha"; sprites em tons de cinza aceitam apenas "value" e "alpha". Os pontos são pares {x, y} (0-255, x estritamente crescente, 2 ou mais); a curva é uma spline monótona suave que passa por eles.
• opts (table, opcional)
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.convolutionMatrix(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Matriz de convolução nos cels de uma camada, como uma única etapa de desfazer: desfoque, nitidez, detecção de bordas, relevo ou qualquer kernel que você fornecer. Vizinhos transparentes não escurecem as cores. Sprites indexados precisam de indexedMode "remap" (os resultados se ajustam à entrada da paleta mais próxima). Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • preset (string) — Um kernel pronto em vez de kernel/width/height: identity, gaussian3, box3, gaussian5, box5, sharpen, edge, emboss, sobelH, sobelV.
  • width (integer 1–9) — Largura do kernel (ímpar). Obrigatória com kernel.
  • height (integer 1–9) — Altura do kernel (ímpar). Obrigatória com kernel.
  • kernel (list of width * height numbers, row by row) — Os pesos aplicados à vizinhança de cada pixel, p. ex. { 0, -1, 0, -1, 5, -1, 0, -1, 0 } aumenta a nitidez.
  • divisor (number; padrão the sum of the kernel (1 if it sums to 0)) — Cada soma ponderada é dividida por isto (não 0).
  • bias (number -255–255; padrão 0) — Somado a cada canal após a divisão (128 centraliza em cinza um resultado de borda/relevo).
  • red (boolean; padrão true) — Aplica a convolução ao canal vermelho. Em sprites em tons de cinza, vermelho, verde e azul são o único canal cinza: defina os três igualmente.
  • green (boolean; padrão true) — Aplica a convolução ao canal verde.
  • blue (boolean; padrão true) — Aplica a convolução ao canal azul.
  • alpha (boolean; padrão false) — Aplica a convolução também ao canal alfa (um desfoque então se expande para pixels transparentes). Desativado, pixels totalmente transparentes ficam intocados.
  • edges (ConvolveEdges: "clamp" | "tiled"; padrão "clamp") — O que é lido além da borda do cel.
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.despeckle(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Remover manchas (um filtro de mediana) nos cels de uma camada, como uma única etapa de desfazer: remove pixels isolados e suaviza ruído. Sprites indexados precisam de indexedMode "remap". Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • width (integer 1–9; padrão 3) — Largura da janela da mediana (ímpar).
  • height (integer 1–9; padrão 3) — Altura da janela da mediana (ímpar).
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.

Não retorna nada.

app.dropShadow(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Desenha uma sombra projetada, um brilho ou uma sombra interna para as formas nos cels de uma camada, como uma única etapa de desfazer (app.setLayerEffects a mantém ativa). Sombras externas expandem o cel, recortadas pela tela, e ficam sob a arte. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada recebem a sombra (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • cels (Array of { layerId = ..., frameId = ... }) — Aplica a sombra a estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • place (OutlinePlace: "outside" | "inside"; padrão "outside") — Uma sombra projetada ou brilho sob a arte ("outside"), ou uma sombra interna sobre ela ("inside").
  • dx (integer -10–10; padrão 1) — Quanto a sombra cai para a direita (negativo: esquerda). 0 e 0 produz um brilho.
  • dy (integer -10–10; padrão 1) — Quanto a sombra cai para baixo (negativo: para cima).
  • spread (integer 0–10; padrão 0) — Quantos pixels a sombra se expande além da silhueta da arte.
  • shape (FxShape: "circle" | "square" | "diamond"; padrão "circle") — O formato da expansão.
  • softness (integer 0–8; padrão 0) — Em quantos pixels a borda da sombra se esvai (um raio de desfoque); 0 é uma borda dura.
  • edge (ShadowEdge: "dithered" | "hard" | "smooth"; padrão "dithered") — Como uma borda suave (softness acima de 0) é desenhada: "dithered" mantém uma única cor como um pontilhado ordenado que fica parado quando a arte se move, "hard" a corta na metade da intensidade, "smooth" cria pixels semitransparentes de verdade.
  • color (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); padrão "#00000080") — A cor da sombra; seu alfa é a opacidade da sombra. Em um sprite indexado, o resultado se ajusta à paleta.
  • respectSelection (boolean; padrão false) — Passe true para pintar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.

Não retorna nada.

app.gradientMap(layerId, frameIds, stops, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Mapa de gradiente nos cels de uma camada, como uma única etapa de desfazer: a luma de cada pixel escolhe uma cor da rampa. Um pixel mantém seu alfa. Pixels totalmente transparentes são deixados como estão. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• stops (table) — 2-32 paradas do gradiente, { { color = ..., position = 0 }, { color = ..., position = 1 } }: a cor que um pixel assume nessa luma (0 = mais escuro, 1 = mais claro).
• opts (table, opcional)
  • space (GradientMapSpace: "rgb" | "oklab" | "oklch"; padrão "oklab") — O espaço de cor usado na mistura entre as paradas.
  • reverse (boolean; padrão false) — Percorre a rampa do claro para o escuro.
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.hueSaturation(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Matiz/Saturação nos modos hsv, hsl ou oklch (perceptual) nos cels de uma camada, como uma única etapa de desfazer. Luminosidade e alfa positivos elevam em direção ao máximo em vez de multiplicar como o Aseprite faz, então +50 de luminosidade transforma preto em cinza médio. Pixels totalmente transparentes são deixados como estão. Em sprites em tons de cinza, matiz e saturação não têm efeito. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • mode (AdjustHueMode: "hsv" | "hsl" | "oklch"; padrão "hsv") — O modelo de cor em que trabalhar.
  • hue (number -180–180; padrão 0) — Graus somados a todo matiz.
  • saturation (number -100–100; padrão 0) — Escala a saturação (croma no modo oklch): -100 é cinza, +100 a dobra (limitada ao máximo, ou à gama sRGB no modo oklch). Cinzas continuam cinzas.
  • lightness (number -100–100; padrão 0) — Luminosidade nos modos hsl e oklch, valor no modo hsv. Positivo avança essa fração do caminho restante até branco/máximo (l + (1 - l) * k, k = lightness / 100), então +100 o alcança; negativo escala em direção ao preto (l * (1 + k)), então -100 o alcança.
  • alpha (number -100–100; padrão 0) — O mesmo aumento no alfa (arredondado): +100 torna opaco todo pixel não transparente, -100 os torna transparentes.
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.invertColor(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Inverter cor, como no Aseprite, nos cels de uma camada, como uma única etapa de desfazer. Pixels totalmente transparentes são deixados como estão. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • red (boolean; padrão true) — Inverte o canal vermelho. Em sprites em tons de cinza, vermelho, verde e azul são o único canal cinza: defina os três igualmente.
  • green (boolean; padrão true) — Inverte o canal verde.
  • blue (boolean; padrão true) — Inverte o canal azul.
  • alpha (boolean; padrão false) — Inverte o canal alfa (pixels totalmente transparentes continuam transparentes).
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.levels(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Níveis nos cels de uma camada, como uma única etapa de desfazer: cada canal é reescalado a partir do intervalo de entrada, curvado pela gama e mapeado para o intervalo de saída. Pixels totalmente transparentes são deixados como estão. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • inBlack (integer 0–254; padrão 0) — Valores de entrada iguais ou abaixo deste viram outBlack.
  • inWhite (integer 1–255; padrão 255) — Valores de entrada iguais ou acima deste viram outWhite. Deve ser maior que inBlack.
  • gamma (number 0.1–10; padrão 1) — Curva dos meios-tons: acima de 1 clareia os meios-tons, abaixo de 1 os escurece.
  • outBlack (integer 0–255; padrão 0) — O valor de saída para a entrada preta.
  • outWhite (integer 0–255; padrão 255) — O valor de saída para a entrada branca. Abaixo de outBlack inverte.
  • red ({ inBlack, inWhite, gamma, outBlack, outWhite }) — Níveis só para o canal vermelho, aplicados depois dos principais. Sprites em tons de cinza recusam canais individuais.
  • green ({ inBlack, inWhite, gamma, outBlack, outWhite }) — Níveis só para o canal verde.
  • blue ({ inBlack, inWhite, gamma, outBlack, outWhite }) — Níveis só para o canal azul.
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.posterize(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Posterizar: reduz cada canal de cor dos cels de uma camada a poucos níveis, como uma única etapa de desfazer. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • levels (integer 2–256; padrão 4) — Níveis distintos mantidos por canal de cor (o alfa não é alterado).
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.reduceColors(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Reduzir cores: mapeia os cels de uma camada para poucas cores (geradas a partir desses cels, ou da paleta), opcionalmente com dithering, como uma única etapa de desfazer. O alfa é mantido; o sprite continua em seu modo de cor. Sprites indexados precisam de indexedMode "remap". Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • colors (integer 1–256; padrão 16) — Quantas cores manter (paletteSource "generate").
  • paletteSource (ReduceColorsPalette: "generate" | "palette"; padrão "generate") — Gera as cores a partir dos cels, ou usa a paleta do sprite.
  • dithering (DitherMethod: "none" | "bayer2" | "bayer4" | "bayer8" | "floydSteinberg" | "atkinson"; padrão "none") — Como as cores intermediárias são aproximadas.
  • ditherAmount (integer 0–100; padrão 100) — Intensidade do dithering (0 = só a cor mais próxima).
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.

Não retorna nada.

app.replaceColor(layerId, frameIds, from, to, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Substituir cor, como no Aseprite, nos cels de uma camada, como uma única etapa de desfazer. Pixels totalmente transparentes nunca correspondem. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• from (color) — A cor a encontrar.
• to (color) — A cor a colocar no lugar (alfa incluído).
• opts (table, opcional)
  • tolerance (integer 0–255; padrão 0) — Um pixel corresponde quando nenhum de seus canais r, g, b, a está mais distante de from do que isto.
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

app.threshold(layerId, frameIds, opts?) — altera, desfazível, recusada em uma camada bloqueada

Filtro > Limiar nos cels de uma camada, como uma única etapa de desfazer: cada pixel vira uma de duas cores conforme sua luma (rgb_luma do Aseprite). Pixels totalmente transparentes são deixados como estão. Somente camadas de imagem.

• layerId (string)
• frameIds (table) — Array de ids de quadros cujos cels nesta camada são ajustados (um quadro para o cel ativo, todos os quadros para todos eles).
• opts (table, opcional)
  • level (integer 0–255; padrão 128) — Pixels cuja luma é pelo menos esta viram above, os demais below.
  • below (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); padrão "#000000") — A cor dos pixels abaixo do nível. O alfa é ignorado: o pixel mantém o seu.
  • above (color ("#rgb", "#rrggbb[aa]" or { r, g, b, a }); padrão "#ffffff") — A cor dos pixels no nível ou acima dele. O alfa é ignorado.
  • cels (Array of { layerId = ..., frameId = ... }) — Ajusta estes cels, entre camadas e quadros, em vez de layerId/frameIds (passe nil para ambos).
  • respectSelection (boolean; padrão false) — Passe true para ajustar apenas dentro da seleção atual. Por padrão, a seleção é ignorada.
  • indexedMode (AdjustIndexedMode: "remap" | "palette"; padrão "remap") — Somente sprites indexados: recolorir os pixels e ajustá-los à entrada da paleta mais próxima, ou editar as entradas da paleta que os cels usam.

Não retorna nada.

Em Markdown: adjustments.md.