Comment puis-je manipuler des feuilles de sprite avec des dimensions de sprite non uniformes?

Pour une feuille de sprite avec des dimensions de sprite non uniformes , comment puis-je obtenir les rectangles de délimitation pour chaque sprite individuel (c'est-à-dire les cases bleues dans l'image suivante / je n'ai dessiné que quelques exemples)?

Ce que je voudrais déterminer sont: offset_x, offset_y, width, height

Jusqu'à présent, je n'ai utilisé que des feuilles de sprites sur lesquelles tous les sprites ont des dimensions identiques . Dans ce cas, il suffit de spécifier le décalage x et y pour obtenir un sprite particulier. Cependant, pour les feuilles de sprites non uniformes dimensions , cela ne fonctionne pas.

EDIT: Après avoir lu les commentaires et les réponses, j'ai reformulé ma question pour la rendre plus inclusive. le processus réel d'utilisation d'une feuille de sprites dans un jeu. Auparavant, la question contenait les points pourquoi les gens produisent des feuilles de sprites de dimensions non uniformes et comment je peux y faire face.

La plupart des feuilles de sprite de dimensions non identiques ont généralement une sorte de métadonnées avec l'emplacement de l'ancre du sprite. Il existe de nombreux outils qui permettent de supprimer les pixels alpha complets et de vous fournir les données dont vous avez besoin pour que ces données ne soient pas générées manuellement.

Si vous ne disposez pas de ces métadonnées, vous devez les créer vous-même. Le moyen le plus précis est celui que vous avez dit dans votre question, qui est de le faire à la main. Cela peut prendre un certain temps, mais c'est probablement plus rapide que de créer de nouveaux sprites.

Vous pouvez effectuer une analyse sur l'image pour localiser les rectangles de délimitation de chaque image-objet, trier ces rectangles de délimitation (peut-être en augmentant au minimum X, puis Y) et vous aurez un ensemble de régions de délimitation qui correspondent aux cadres de la feuille d'image-objet.

Parce que ce processus peut être relativement coûteux, vous voudrez probablement le faire hors ligne, par exemple dans le cadre du processus de construction de votre jeu. Vous pouvez ensuite sérialiser les informations de la région englobante dans un fichier que vous stockez avec l'image de feuille de sprite correspondante. Au moment de l'exécution, vous chargez à la fois l'image et le fichier de définition des limites et vous disposez des informations dont vous avez besoin pour accéder à chaque sprite individuel.

C'est plus facile à dire qu'à faire, cependant. Essentiellement, vous voudrez faire détection des fonctionnalités et en particulier la détection des blobs qui sont des problèmes de vision industrielle. Vous pouvez également seuiller l'image (en noir et blanc) et utiliser une technique de détection des bords . Les mathématiques pertinentes derrière ces techniques sont bien mieux expliquées sur ces liens que moi, et dans le cas où vous ne vous sentez pas prêt à implémenter ces mathématiques vous-même, il existe quelques bibliothèques disponibles qui peuvent vous aider. L'ensemble de liens suivant m'a paru le plus prometteur:

• AForge a un composant de vision industrielle (pour C #); voici un exemple d'utilisation pertinent
• OpenCV (une bibliothèque C ++ avec un wrapper C # )
• Ce thread fournit une bibliothèque de détection d'objets blob pour l'encapsuleur C # pour OpenCV.

J'ai fait mon propre outil pour ce genre de feuille de sprites non uniforme. Il permet de modifier les décalages, et cetera. Voici une capture d'écran pour vous donner une idée:

Découvrez Texturepacker

http://www.texturepacker.com/

Il génère un fichier comme celui-ci (en fonction de vos paramètres préférés)

    {
    "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}
}

En utilisant ces données, vous pouvez facilement saisir les rectangles séparés de l'image.

spritebuddy.com a très bien fonctionné pour moi. Impossible de trouver de l'aide sur le site lui-même, mais ce message de Google Groupes l' explique très bien. Il devine automatiquement les limites de vos sprites, vous permet de les ajuster ET vous permet de les organiser en séquences d'animation. Ensuite, il crache un fichier de métadonnées pour tout cela en JSON ou XML. Ensuite, tout ce que vous avez à faire est d'analyser ce fichier de données dans votre jeu pour obtenir les rectangles de délimitation corrects.