Como lidar com folhas de sprite com dimensões de sprite não uniformes?

Para uma planilha com dimensões de sprite não uniformes , como posso obter os retângulos delimitadores cada sprite individual (por exemplo, as caixas azuis na imagem a seguir / apenas alguns exemplos)?

O que eu gostaria de determinar são: offset_x, offset_y, width, height

Até agora, usei apenas planilhas em que todos os sprites têm dimensões idênticas . Nesse caso, basta especificar o deslocamento x e y para obter um sprite específico. No entanto, para planilhas de dimensões não uniformes, isso não funciona.

EDIT: Depois de ler os comentários e as respostas, reformulei minha pergunta para torná-la mais abrangente. o processo real de usar uma planilha em um jogo. Anteriormente, a pergunta continha os pontos por que as pessoas produzem planilhas de dimensões não uniformes e como eu posso lidar com isso.

A maioria das folhas de sprite de dimensões não idênticas geralmente possui algum tipo de metadado com a localização da âncora do sprite. Existem muitas ferramentas que fazem coisas como remover pixels alfa completos e fornecer os dados necessários para que esses dados não sejam gerados manualmente.

Se você não possui esses metadados, é necessário que você mesmo os crie. A maneira mais precisa é a que você disse na sua pergunta, que é apenas fazê-lo manualmente. Pode demorar um pouco, mas provavelmente é mais rápido do que fazer novos sprites.

Você pode executar uma análise na imagem para localizar os retângulos delimitadores de cada sprite, classificá-los (talvez aumentando X mínimo e depois Y) e terá um conjunto de regiões delimitadoras que correspondem aos quadros da folha de sprite.

Como esse processo pode ser relativamente caro, você provavelmente desejará fazer isso offline, por exemplo, como parte do processo de compilação do seu jogo. Em seguida, você pode serializar as informações da região delimitadora em um arquivo armazenado com a imagem da folha de sprite correspondente. No tempo de execução, você carrega a imagem e o arquivo de definição de limite e possui as informações necessárias para acessar cada sprite individual.

Isso é mais fácil dizer do que fazer, no entanto. Essencialmente, você desejará fazer a detecção de recursos e especificamente os blob, que são problemas de visão de máquina. Você também pode limitar a imagem (para preto e branco) e usar uma técnica de detecção de borda . A matemática relevante por trás dessas técnicas é explicada muito melhor nesses links do que eu poderia e, no caso de você não querer implementar essa matemática, existem algumas bibliotecas disponíveis que podem ajudá-lo. O seguinte conjunto de links parecia o mais promissor para mim:

• O AForge possui um componente de visão de máquina (para C #); aqui está um exemplo de uso relevante
• OpenCV (uma biblioteca C ++ com um wrapper C # )
• Esse encadeamento fornece uma biblioteca de detecção de blob para o wrapper C # para OpenCV.

Fiz minha própria ferramenta para esse tipo de planilha não uniforme. Permite editar deslocamentos, etc. Aqui está uma captura de tela para você ter uma ideia:

Confira o texturepacker

http://www.texturepacker.com/

Ele gera um arquivo como este (dependendo das configurações preferidas)

    {
    "filename": "image_front_1",
    "frame": {"x":1,"y":160,"w":34,"h":52},
    "rotated": false,
    "trimmed": false,
    "spriteSourceSize": {"x":0,"y":2,"w":36,"h":40},
    "sourceSize": {"w":36,"h":40}
},
{
    "filename": "image_front_2.png",
    "frame": {"x":36,"y":160,"w":34,"h":52},
    "rotated": false,
    "trimmed": false,
    "spriteSourceSize": {"x":0,"y":0,"w":36,"h":42},
    "sourceSize": {"w":36,"h":42}
},
{
    "filename": "image_front_3.png",
    "frame": {"x":71,"y":160,"w":34,"h":52},
    "rotated": false,
    "trimmed": false,
    "spriteSourceSize": {"x":0,"y":0,"w":34,"h":52},
    "sourceSize": {"w":36,"h":42}
},
{
    "filename": "image_front_4.png",
    "frame": {"x":106,"y":160,"w":34,"h":52},
    "rotated": false,
    "trimmed": false,
    "spriteSourceSize": {"x":0,"y":0,"w":34,"h":52},
    "sourceSize": {"w":36,"h":42}
}

Usando esses dados, você pode facilmente pegar os retângulos separados da imagem.

spritebuddy.com funcionou muito bem para mim. Não foi possível encontrar nenhuma ajuda no próprio site, mas esta postagem dos Grupos do Google explica muito bem. Adivinha automaticamente os limites dos seus sprites, permite ajustá-los e organiza-os em sequências de animação. Em seguida, ele lança um arquivo de metadados para tudo isso em JSON ou XML. Então tudo o que você precisa fazer é analisar esse arquivo de dados no seu jogo para obter os retângulos delimitadores corretos.