# Redimensionar, recortar e efeitos

Redimensione, recorte, apare, gire e espelhe o sprite inteiro, aplique efeitos e ajustes de cor e volte pelo histórico de desfazer.

_Os atalhos estão escritos para Windows e Linux. No Mac, use ⌘ Cmd onde está Ctrl e ⌥ Option no lugar de Alt._

O menu **Sprite** altera o sprite como um todo: seu tamanho, sua tela, sua orientação. Os efeitos e
ajustes do menu **Filtro** recolorem e filtram os pixels de um cel ou de vários. Cada um deles é uma
única etapa de desfazer.

## Tamanho do sprite e da tela

- Sprite > Tamanho do sprite... (`Ctrl+Alt+I`) **escala** o sprite para uma nova **Largura** e
  **Altura** (de 1 a 4096 pixels). Todos os cels são redimensionados com escala por vizinho mais
  próximo, então os pixels continuam nítidos e nenhuma cor nova aparece; slices, tilesets e a
  seleção são escalados junto. Largura e altura são independentes: calcule o outro lado você mesmo
  para manter as proporções.
- Sprite > Tamanho da tela... (`Alt+C`) muda o tamanho da **tela** sem escalar a arte.
  Escolha uma **Âncora** na grade 3×3: onde a arte existente fica na nova tela (o meio a mantém
  centralizada, o canto superior esquerdo aumenta ou diminui a tela para a direita e para baixo).
  Com a âncora no meio, uma diferença ímpar coloca a coluna extra à direita e a linha extra em
  cima, de modo que reduzir de volta desfaz exatamente. A arte que fica fora de uma tela menor não
  se perde: ela é mantida além da borda, fora de vista, e volta se a tela crescer de novo (como no
  Aseprite). A camada Plano de fundo é cortada pela tela e preenchida com a cor de fundo quando
  ela cresce.

## Recortar e aparar

- Sprite > Recortar na seleção faz da tela a caixa delimitadora da seleção. Precisa de uma seleção
  ([Selecionar e transformar](https://pxstud.io/pt-br/docs/manual/guides/selection.md)). Uma seleção que passa da tela a faz crescer daquele
  lado.
- Sprite > Recortar corta a tela até o menor retângulo que contém o que foi desenhado, em todos os
  quadros. Ele olha o sprite como é exibido: camadas ocultas não contam, e uma cor sólida de borda
  (como um Plano de fundo opaco) é aparada como se fosse transparência. Quando duas bordas opostas
  são sólidas em cores diferentes, ou nada foi desenhado, o sprite fica como está.

Como Tamanho da tela, recortar e aparar mantêm a arte fora da nova tela em vez de excluí-la.

## Girar e espelhar a tela

Sprite > Girar 90° para a direita e Sprite > Girar 90° para a esquerda giram o sprite inteiro em um quarto de volta
(largura e altura se trocam), e Sprite > Espelhar tela horizontalmente e Sprite > Espelhar tela verticalmente o espelham.
Eles agem sobre todas as camadas e quadros, inclusive as camadas bloqueadas, e levam junto os slices
e a seleção. A arte além da borda da tela gira e se espelha com o resto, então girar de volta a
restaura.

Para girar ou espelhar apenas a seleção ou um cel, use **Editar > Transformar** ou os espelhamentos
do menu Camada ([Selecionar e transformar](https://pxstud.io/pt-br/docs/manual/guides/selection.md#moving-and-transforming)).

## Propriedades do sprite e proporção do pixel

Arquivo > Renomear sprite... mostra o nome e o tamanho do sprite e sua contagem de camadas e quadros, e
tem:

- **Modo de cor**: RGB, Tons de cinza ou Indexado ([Cor e paletas](https://pxstud.io/pt-br/docs/manual/guides/color.md#color-modes));
- **Cor transparente**, o índice da paleta que representa transparente (sprites indexados);
- **Proporção do pixel**: 1:1, 2:1, 1:2 ou **Personalizada** (cada lado de 1 a 255);
- **dados do usuário**: uma cor, uma nota e propriedades personalizadas do sprite
  ([abaixo](https://pxstud.io/pt-br/docs/manual/guides/document.md#user-data-and-custom-properties)).

Nada muda até você escolher **Salvar**, que aplica tudo de uma vez; uma única etapa de desfazer
reverte juntos o modo de cor, a cor transparente, a proporção do pixel e os dados do usuário.
**Cancelar** deixa o sprite como estava.

A **proporção do pixel** torna os pixels não quadrados, como alguns consoles e computadores antigos
os exibiam: em 2:1, cada pixel tem o dobro de largura que de altura. A tela mostra o sprite
esticado; os pixels em si não mudam. As exportações continuam com um pixel de arquivo por pixel do
sprite, a menos que você ative **Aplicar proporção do pixel** na caixa de diálogo Exportar
([Abrir, importar e exportar](https://pxstud.io/pt-br/docs/manual/guides/import-export.md#export)). Você também pode definir a proporção do
pixel ao criar um sprite.

## Dados do usuário e propriedades personalizadas

Tudo o que pode receber anotações tem uma seção **Dados do usuário** na sua caixa de diálogo de
propriedades: o sprite, uma camada ou grupo, um cel, uma tag, um slice e um tileset (**Propriedades
do tileset**). Ela guarda uma **cor** (não nas tags, que têm a sua), uma **nota** e **propriedades
personalizadas**: valores nomeados que um jogo ou ferramenta lê nos dados exportados. Os slices
exportam as suas no JSON da sprite sheet, e os arquivos `.aseprite` guardam todas elas, então elas
voltam quando o arquivo é reaberto.

As propriedades são agrupadas por **namespace**. **Seus** é a lista simples; **Adicionar namespace
de extensão** cria uma lista que pertence a uma extensão com nome, como fazem as extensões do
Aseprite. Em cada lista:

- **Adicionar propriedade** adiciona uma linha com nome, tipo e valor; **Adicionar item** faz o
  mesmo dentro de um vetor. As setas movem uma linha para cima ou para baixo e a lixeira a remove.
- Escolha o **tipo** de um valor: Boolean, Null, String, UUID, um número inteiro de um tamanho
  dado (Int8 a UInt64), Fixed, Float ou Double, Point (X, Y), Size (W, H), Rect (X, Y, W, H), ou um
  **Vector** (uma lista) ou **Map** (propriedades nomeadas) que guarda mais linhas. Mudar o tipo de
  uma linha mantém o valor onde o novo tipo permitir.
- Um valor que não cabe no seu tipo (um UInt8 de 300, um UUID com formato errado, um nome repetido)
  é marcado na linha, e **Salvar** espera até que seja corrigido. Os números inteiros são
  verificados contra o intervalo do tipo.

**Editar como JSON** mostra as mesmas propriedades como texto, para copiar e colar. Tudo, exceto
texto, verdadeiro/falso e números simples, é escrito como `{ "$type": "uint8", "value": 7 }`; os
scripts usam a mesma forma com `app.setUserData`. Voltar para as linhas exige que o JSON seja
válido.

## Duplicar um sprite

Sprite > Duplicar sprite copia o sprite, com todas as suas camadas, quadros e slices, para um novo
sprite chamado "_nome_ cópia" no mesmo projeto.

## Efeitos e ajustes

O menu Filtro tem os mesmos filtros do menu Editar do Aseprite (Brilho/Contraste, Matiz/Saturação
e Curva de cor calculam suas cores à própria maneira; veja cada um abaixo):

- **Tom e cor:** Filtro > Brilho/Contraste..., Filtro > Matiz/Saturação...,
  Filtro > Curva de cor..., Filtro > Níveis..., Filtro > Limiar..., Filtro > Mapa de gradiente... e
  Filtro > Balanço de cores...;
- **Substituir e reduzir cores:** Filtro > Inverter cor... (`Ctrl+I`),
  Filtro > Substituir cor..., Filtro > Posterizar... e Filtro > Reduzir cores...;
- **Formas:** Filtro > Contorno..., Filtro > Sombra projetada..., Filtro > Antisserrilhado... e
  Filtro > Sombreamento automático...;
- **Filtros de vizinhança:** Filtro > Remover manchas... e Filtro > Matriz de convolução....

Cada um abre uma caixa de diálogo. Enquanto ela está aberta, a tela mostra uma **prévia ao vivo** do
cel ativo; desative **Prévia** para comparar. **OK** aplica o efeito como uma única etapa de
desfazer, **Cancelar** deixa o sprite em paz.

**O que eles alteram.** Com uma seleção, um efeito só altera os pixels dentro dela; sem uma, altera
o cel inteiro. A caixa de diálogo diz qual dos dois. **Aplicar a** escolhe os cels:

| Aplicar a | Cels |
| - | - |
| **Cel ativo** | O cel em que você está (o padrão, quando a camada dele pode ser editada). |
| **Cels selecionados na linha do tempo** | Os cels selecionados na linha do tempo. |
| **Todos os quadros desta camada** | O cel da camada ativa em cada quadro. |
| **Todas as camadas neste quadro** | O cel de cada camada no quadro atual. |
| **Tudo** | Todos os cels do sprite. |

Os efeitos funcionam em camadas de imagem. Brilho/Contraste, Matiz/Saturação, Curva de cor, Inverter
cor, Substituir cor e Posterizar também funcionam em camadas de tilemap: eles editam os tiles que o
cel coloca, então todas as colocações desses tiles mudam. As três últimas opções ignoram camadas
bloqueadas ou ocultas e camadas que o efeito não aceita, e avisam quantos cels deixaram de fora. Os
itens de menu só ficam esmaecidos quando nenhuma camada aceita o efeito. Quando a camada ativa não
aceita o efeito (está bloqueada, oculta, é um grupo ou, para os outros efeitos, um tilemap), a caixa
de diálogo começa em **Tudo**.

Na camada Plano de fundo, os efeitos nunca alteram o alfa, porque ela não tem transparência: as
opções de alfa são ignoradas ali, e Substituir cor altera apenas a cor.

### Sprites indexados

Em um sprite indexado, os ajustes de cor (tudo, exceto Remover manchas, Matriz de convolução,
Reduzir cores, Sombra projetada, Antisserrilhado e Sombreamento automático, que sempre remapeiam) têm uma opção **Indexado**:

- **Remapear para o mais próximo** (o padrão) altera os pixels e depois ajusta cada um à cor mais
  próxima da paleta. A paleta fica como está.
- **Modificar paleta** altera as entradas da paleta que os cels escolhidos usam, em vez dos pixels.
  Todo pixel que usa essas entradas muda, em qualquer cel, e a seleção é ignorada. Em um sprite
  cuja paleta muda ao longo do tempo, a paleta de cada quadro é editada.

## Os efeitos

### Contorno

Desenha um contorno em volta das formas, delimitando-as contra os pixels transparentes.

![A caixa de diálogo Contorno: uma cor, Posição definida como Fora, Aplicar a definido como Cel ativo, uma matriz 3 por 3 com os quatro vizinhos laterais ativados, as predefinições Círculo e Quadrado e as caixas de seleção Tratar uma cor também como fundo e Prévia](https://pxstud.io/manual/images/guides/document-outline.light.webp)

_A caixa de diálogo Contorno_

- **Cor:** a cor do contorno; começa como a cor de primeiro plano. Em um sprite indexado, escolha
  uma entrada da paleta.
- **Posição:** **Fora** pinta os pixels transparentes que tocam a forma, então a forma cresce;
  **Dentro** repinta os pixels da própria borda da forma, que mantém o tamanho. A borda da tela não
  conta como transparente, então uma forma que sai da tela não é contornada ao longo dela.
- **Matriz:** quais dos oito vizinhos contam como encostando. **Círculo** usa os quatro de cima, de
  baixo e dos lados (sem cantos); **Quadrado** usa os oito. Clique em uma célula para alterná-la.
- **Tratar uma cor também como fundo:** uma **Cor de fundo** que conta como vazia, como a
  transparência, para contornar arte desenhada sobre uma cor sólida.

### Posterizar

**Níveis** (de 2 a 32, padrão 4): quantos degraus cada canal de cor mantém. Menos níveis dão uma cor
mais chapada e marcante.

### Remover manchas

Remove pixels isolados com um filtro de mediana: cada pixel assume o valor do meio dos pixels ao
redor. **Janela** define a área, de 1 × 1 a 9 × 9 (padrão 3 × 3); janelas maiores suavizam mais.

### Matriz de convolução

Executa um filtro de kernel sobre os pixels.

- **Predefinição:** Identidade, Desfoque gaussiano 3x3 (o padrão, igual ao Blur 3x3 do Aseprite),
  Desfoque de caixa 3x3, Desfoque gaussiano 5x5, Desfoque de caixa 5x5, Nitidez, Detecção de
  bordas, Relevo, Sobel horizontal e Sobel vertical. Um desfoque gaussiano dá mais peso aos pixels
  do meio, então é mais suave que um desfoque de caixa, que pesa todos os pixels igualmente. Editar
  um peso a torna **Personalizada**.
- **Tamanho:** de 1 × 1 a 9 × 9, e a grade de pesos para editar.
- **Divisor:** por quanto a soma ponderada é dividida; **Auto (soma do kernel)** calcula sozinho.
- **Deslocamento:** somado a cada resultado (-255 a 255).
- **Vermelho**, **Verde**, **Azul**, **Alfa:** quais canais ela altera (o alfa vem desativado).
- **Bordas:** na margem do cel, **Estendidas** repete os pixels da borda, **Em mosaico** dá a volta
  até o outro lado.

### Reduzir cores

Mapeia a arte para poucas cores, opcionalmente com dithering, sem mudar o modo de cor: uma forma
rápida de dar uma paleta limitada a uma arte pintada ou importada, ou de ver prévia de como ela
ficaria em cor indexada. A transparência é mantida.

- **Cores:** **Gerar a partir dos cels** escolhe as melhores **Cores** (de 2 a 256) de todos os cels
  que **Aplicar a** abrange, mostradas como amostras; **Paleta do sprite** usa a paleta (sem a
  entrada transparente).
- **Dithering** e **Quantidade:** as mesmas opções de converter para indexado
  ([Modos de cor](https://pxstud.io/pt-br/docs/manual/guides/color.md#color-modes)). Escolha um padrão ordenado para animação.

### Brilho/Contraste

**Brilho** e **Contraste**, cada um de -100 a 100. O brilho soma a mesma quantidade a todos os
canais (em 100, 255 níveis: o preto vira branco), e depois o contraste afasta os canais do cinza
médio ou os aproxima dele (em -100 tudo é cinza médio, em 100 quase todo canal é 0 ou 255). A versão
do Aseprite é diferente: ela escala o brilho, então o preto continua preto.

### Matiz/Saturação

- **Modo:** **HSV**, **HSL** ou **OKLCH**. No HSV, o terceiro controle deslizante é **Valor**, que
  move o canal mais claro para o máximo ou para zero; no HSL e no OKLCH ele é **Luminosidade**, que
  move para o branco ou para o preto.
- O **OKLCH** é perceptual: girar o matiz mantém a luminosidade percebida de cada cor, então os
  amarelos não ficam mais claros nem os azuis mais escuros como acontece no HSV ou no HSL, e a
  **Saturação** escala o croma. Uma cor empurrada além do que a tela consegue mostrar perde
  saturação em vez de mudar o matiz ou a luminosidade. Use-o para recolorir um sprite inteiro
  mantendo o sombreamento legível.
- **Matiz** (-180 a 180), **Saturação**, **Valor** ou **Luminosidade**, e **Alfa** (cada um de -100
  a 100). Luminosidade, Valor e Alfa positivos movem essa parcela do caminho restante até o máximo:
  +50 leva o preto ao cinza médio e pixels meio transparentes a três quartos de opacidade. Os
  negativos escalam para baixo, então -100 chega ao preto ou ao transparente. O do Aseprite
  multiplica, então lá o preto continua preto.

### Níveis

Define onde ficam o preto, o branco e os meios-tons, por canal: **Preto de entrada** e **Branco de
entrada** (0 a 255) são os valores que se tornam o mais escuro e o mais claro; **Meios-tons**
(gama, 0,10 a 5) clareia (acima de 1) ou escurece (abaixo de 1) o que está entre eles; **Preto de
saída** e **Branco de saída** limitam o intervalo que o resultado pode usar, e um branco de saída
abaixo do preto inverte o canal. Escolha **RGB** para alterar os três canais juntos, ou
**Vermelho**, **Verde** ou **Azul** para alterar um depois disso (não em sprites em tons de cinza,
que têm um único canal de cinza).

### Limiar

Transforma cada pixel em uma de duas cores conforme o brilho: **Nível** (0 a 255) é o brilho de que
um pixel precisa para virar a cor **Igual ou acima** em vez da cor **Abaixo** (preto e branco por
padrão). O brilho é a mesma luma que o Aseprite usa para tons de cinza. Os pixels mantêm o próprio
alfa.

### Mapa de gradiente

Recolore a arte pelo brilho por meio de um gradiente: os pixels mais escuros assumem a cor da
primeira parada, os mais claros a da última, e os demais o que fica entre elas. Adicione paradas,
defina a **Posição** e a cor delas e escolha o espaço em que elas se **Misturam**: **RGB**,
**OKLab** (degraus de aparência uniforme, o padrão) ou **OKLCH**. **Inverter** percorre o gradiente
do claro para o escuro. Os pixels mantêm o próprio alfa.

### Balanço de cores

Desloca a cor de uma faixa tonal: escolha **Sombras**, **Meios-tons** ou **Realces** e mova os
controles **Ciano - Vermelho**, **Magenta - Verde** e **Amarelo - Azul** (-100 a 100). Cada pixel é
deslocado conforme o quanto é escuro ou claro, então as sombras se misturam aos meios-tons e os
meios-tons aos realces. **Preservar luminosidade** (ativado por padrão) devolve a luminosidade que o
deslocamento alterou, para que só a cor se mova. Em sprites em tons de cinza há um único controle
**Luminosidade**.

### Sombra projetada

Escreve uma sombra nos cels. **Estilo** é **Sombra projetada** (deslocamento **Na horizontal** e
**Na vertical**, até 10 pixels em cada sentido), **Brilho** (sem deslocamento) ou **Sombra interna**
(sobre a arte, ao longo da borda oposta ao deslocamento). **Propagação** a faz crescer até 10
pixels, em um formato **Redonda**, **Quadrada** ou **Losango**, e a **Opacidade** da cor define o
quanto ela aparece. **Suavidade** (até 8 pixels) esmaece a borda; em 0 a borda é dura. **Bordas**
define como uma borda suave é desenhada: **Com dithering** (o padrão: um padrão de dithering da única
cor da sombra, que fica parado quando a arte se move), **Nítidas** (cortada na metade da intensidade)
ou **Suaves** (pixels semitransparentes). Com dithering e Nítidas não adicionam cores intermediárias.
Uma sombra
fora da arte faz o cel crescer (até a borda da tela) e fica por baixo dela. Em um sprite indexado, o
resultado se ajusta à paleta.

**Adicionar como efeito de camada** nesta caixa de diálogo e nos outros ajustes mantém as mesmas
configurações ativas em vez de gravá-las: veja [Efeitos de camada](https://pxstud.io/pt-br/docs/manual/guides/layers.md#layer-effects).

### Antisserrilhado

Suaviza os degraus onde uma cor encontra outra, do jeito que artistas de pixel art fazem à mão: não é um desfoque, mas
algumas cores intermediárias colocadas ao lado de cada degrau. Escolha **Cor A** e **Cor B** (elas começam como as cores
de primeiro plano e de fundo; as amostras abaixo de cada uma são as cores mais usadas da camada). Bordas retas, cantos e
diagonais de 45 graus continuam nítidos. Quanto mais longo o trecho reto antes de um degrau, mais pixels recebem uma cor
intermediária, até **Cores intermediárias** (de 1 a 4, misturadas de A até B em OKLCH). **Suavizar em** escolhe o lado
que é repintado: **Cor B** (o padrão: ao redor da forma, o melhor para uma linha sobre um fundo conhecido), **Cor A**
(dentro da forma, para a silhueta não crescer; uma linha de um pixel fica como está) ou **Ambos**. **Intensidade** define
até onde a suavização vai ao longo de cada trecho (100: até a metade do trecho). Com **Cores** em **Apenas paleta**, são
usadas as cores da paleta mais próximas; sprites indexados sempre fazem isso.

Para suavizar um contorno sobre um fundo transparente, ponha a **Opacidade** da Cor B em 0 (qualquer pixel
transparente) e marque **Qualquer cor visível é A**: as intermediárias são as próprias cores da borda esmaecendo. Cores
da paleta não podem esmaecer, então com **Apenas paleta** (e em sprites indexados) elas ficam sólidas ou somem.
**Adicionar como efeito de camada** o mantém ao vivo; num sprite com profundidade de cor o resultado fica nessa
profundidade.

### Sombreamento automático

Sombreia cores chapadas de uma vez, do jeito que artistas de pixel art adicionam realces e sombras à
mão. **Sombrear** é **Apenas a cor base** (os pixels da **Cor base**; as amostras em **Cores mais
comuns** são as cores mais usadas do cel) ou **Cada cor chapada** (cada cor recebe uma rampa
própria). A luz vem do **Ângulo da luz**, em graus no sentido anti-horário a partir da direita: 90 é
em cima, 135 em cima à esquerda (o padrão). Pixels perto da borda voltada para a luz recebem até
**Realces** passos mais claros (de 0 a 5) e pixels perto da borda oposta até **Sombras** passos mais
escuros, a própria borda o mais forte; cada passo tem **Largura do passo** pixels de profundidade (de
1 a 4). Uma parte com 1 pixel de espessura mantém a cor e uma com 2 pixels recebe um realce e uma
sombra, então partes finas nunca ficam totalmente escuras.

Os passos são calculados a partir da cor em OKLCH. **Deslocamento de matiz** vira os realces para um
amarelo quente e as sombras para um azul frio, como artistas de pixel art fazem, e **Croma por
passo** deixa cada passo mais (ou menos) colorido. **Luz de contorno** adiciona um realce fino ao
longo da borda externa do lado em sombra; **Contorno mais escuro** pinta a borda externa da forma um
passo mais escuro que a sombra mais profunda. **Cores** em **Apenas paleta** usa as cores mais
próximas da paleta; sprites indexados sempre fazem isso.

As amostras em **Passos (do escuro ao claro)** mostram o resultado. **Editar estas cores** as copia
para **Rampa**, onde você pode mudar qualquer uma: uma rampa é percorrida para cada cor que contém,
em qualquer sentido. **Usar os tons da tinta Sombreamento** copia a rampa da tinta Sombreamento (um
Sombreamento automático novo começa por ela quando ela contém a cor base). **Adicionar como efeito
de camada** o mantém ao vivo, então a arte redesenhada é sombreada de novo; o ângulo da luz pode ser
animado para girar a luz ao longo de uma animação. Em um sprite com profundidade de cor, o resultado
fica nessa profundidade.

### Curva de cor

Remapeia valores por meio de uma curva que você desenha. Escolha um **Canal**: **Valor** (vermelho,
verde e azul por igual), **Vermelho**, **Verde**, **Azul** ou **Alfa**. Cada canal tem a própria
curva, suave, que passa pelos pontos sem ultrapassá-los (o Aseprite une seus pontos com linhas
retas). Em um sprite em tons de cinza, os canais são **Valor** e **Alfa**.

No editor de curvas, clique para adicionar um ponto, arraste um ponto para movê-lo e clique duas
vezes em um para removê-lo. Abaixo dele, a lista **Pontos** tem a entrada e a saída de cada ponto
como campos numéricos, com botões **Remover** e **Adicionar ponto** (no meio do maior intervalo),
para que a curva também possa ser editada pelo teclado. **Redefinir canal** endireita a curva do
canal atual. A curva Valor é aplicada primeiro, depois as de um único canal.

### Inverter cor

Inverte os canais que você marcar: **Vermelho**, **Verde** e **Azul** vêm ativados, **Alfa** vem
desativado. Pixels totalmente transparentes continuam transparentes. Em um sprite em tons de cinza
há um único canal **Cinza** no lugar das três cores (a Matriz de convolução também).

### Substituir cor

Troca cores por outras.

- **De** e **Para**: as cores (entradas da paleta em um sprite indexado). Ou marque **Substituir
  por transparente**. **Adicionar linha** adiciona outro par De e Para; **Remover linha** tira um.
  Todas as linhas se aplicam de uma vez, um pixel assume a primeira linha com que combina, e uma cor
  substituída nunca é substituída de novo por uma linha seguinte, então as linhas podem trocar duas
  cores entre si.
- **Tolerância** (0 a 255): quão longe um pixel pode estar da cor De e ainda ser substituído; 0
  pega apenas aquela cor exata.

## Histórico de desfazer

O botão de histórico abaixo de **Desfazer** e **Refazer** na barra de ferramentas (ou
Editar > Histórico de desfazer) abre o painel Histórico de desfazer ao lado da barra de ferramentas: à
esquerda dela quando a barra está à direita, senão do lado que tiver espaço. Ele lista todas as
etapas que você pode desfazer, da mais antiga para a mais nova, com **Original** (o sprite antes da
etapa mais antiga) no topo. A etapa atual é destacada com um ponto cheio, e as etapas que você
desfez (que refazer traria de volta) ficam esmaecidas. Cada etapa mostra a hora em que foi feita (e
a data, se não foi hoje); passe o mouse sobre ela para ver data e hora completas. Clique em
qualquer linha para levar o sprite àquele ponto. Clique no botão de novo, ou pressione **Esc** no
painel, para fechar.

Desfazer nunca joga trabalho fora. Se você desfaz algumas etapas e depois faz uma nova alteração,
as etapas desfeitas continuam na árvore como um **ramo**, desenhado a partir da etapa em que você
seguiu por outro caminho. Cada nível de ramificação tem a sua cor. Uma etapa com ramos tem uma seta
ao lado: clique nela para recolhê-los (a etapa então mostra quantas etapas estão ocultas) ou
expandi-los. Os ramos começam expandidos até três níveis de profundidade; os mais profundos começam
recolhidos. Clique em qualquer linha de um ramo para voltar a ele. Refazer segue o ramo que você
visitou mais recentemente. O histórico é mantido com o sprite e vai junto nos arquivos `.pxstudio` que você baixa: abra
um deles e o histórico volta.

**Dê um nome a uma etapa** para encontrá-la depois: passe o ponteiro sobre ela e clique no botão
**...** dela, ou clique nela com o botão direito (pelo teclado, pressione a tecla Menu ou Shift+F10
sobre ela) e escolha **Nomear etapa...**. Uma etapa nomeada mostra o nome na frente do rótulo de
sempre, com uma etiqueta e uma borda colorida, para se destacar em um histórico longo. Dar nome a uma
etapa não altera o sprite e não acrescenta nada ao desfazer. Os nomes são guardados com o histórico:
depois de recarregar, nos seus outros dispositivos com o Sync e nos arquivos `.pxstudio` que você
baixa. O mesmo menu tem **Renomear etapa...** e **Remover nome**.

Dar nome a uma etapa também guarda o sprite como estava nessa etapa como uma versão nomeada, com o
mesmo nome, em Sprite > Histórico de versões.... A etapa sai do histórico quando fica entre as mais
antigas descartadas, mas a versão continua até você excluí-la. Renomear uma etapa ou remover o nome
dela deixa a versão como está.

A linha de baixo mostra quanta memória o histórico usa e quantas etapas ele guarda em todos os
ramos, de no máximo 1.000. Depois disso, as etapas mais antigas são descartadas primeiro. [Como seu
trabalho é organizado](https://pxstud.io/pt-br/docs/manual/concepts/how-work-is-organized.md#what-undo-covers) explica o que o
desfazer cobre.

## Em scripts

Os scripts também podem fazer tudo isso: veja [Document](https://pxstud.io/pt-br/docs/scripting/document.md) e
[Adjustments](https://pxstud.io/pt-br/docs/scripting/adjustments.md) na referência de scripts (o contorno está em
[Drawing](https://pxstud.io/pt-br/docs/scripting/drawing.md)).