¿Cómo puedo manejar hojas de sprites con dimensiones de sprites no uniformes?

Para una hoja de sprites con dimensiones de sprites no uniformes , ¿cómo puedo obtener los rectángulos delimitadores para cada sprite individual (es decir, los cuadros azules en la siguiente imagen / solo dibujé algunos ejemplos)?

Lo que me gustaría determinar son: offset_x, offset_y, width, height

Hasta ahora, solo he usado hojas de sprites en las que todos los sprites tienen dimensiones idénticas . En ese caso, uno simplemente necesita especificar el desplazamiento x e y para obtener un sprite particular. Sin embargo, para las hojas de sprites de dimensiones no uniformes esto no funciona.

EDITAR: Después de leer los comentarios y las respuestas, reformulé mi pregunta para hacerla más inclusiva. El proceso real de usar una hoja de sprites en un juego. Anteriormente, la pregunta contenía los puntos por los cuales las personas producen hojas de sprites de dimensiones no uniformes y cómo puedo lidiar con eso.

La mayoría de las hojas de sprites de dimensiones no idénticas generalmente tienen algún tipo de metadatos con la ubicación del ancla del sprite. Hay muchas herramientas que hacen cosas como eliminar píxeles alfa completos y proporcionarle los datos que necesita para que estos datos no se generen manualmente.

Si no tiene estos metadatos, debe crearlos usted mismo. La forma más precisa es la que dijo en su pregunta, que es hacerlo a mano. Puede llevar un tiempo, pero probablemente sea más rápido que hacer nuevos sprites.

Puede realizar un análisis en la imagen para ubicar los rectángulos delimitadores de cada sprite, ordenar esos rectángulos delimitadores (quizás aumentando el mínimo X, luego Y) y tendrá un conjunto de regiones de delimitación que corresponden a los marcos de la hoja del sprite.

Debido a que este proceso puede ser relativamente costoso, probablemente querrás hacerlo sin conexión, por ejemplo, como parte del proceso de compilación de tu juego. Luego puede serializar la información de la región delimitadora en un archivo que almacene con la imagen de hoja de sprite correspondiente. En el tiempo de ejecución, carga tanto la imagen como el archivo de definición de límite y tiene la información que necesita para acceder a cada sprite individual.

Sin embargo, eso es más fácil decirlo que hacerlo. Esencialmente, querrá hacer la detección de funciones y específicamente la detección de manchas que son problemas de visión artificial. También puede limitar la imagen (en blanco y negro) y utilizar una técnica de detección de bordes . La matemática relevante detrás de esas técnicas se explica mucho mejor en esos enlaces de lo que yo podría, y en el caso de que no tenga ganas de implementar esa matemática usted mismo, hay algunas bibliotecas disponibles que pueden ayudarlo. El siguiente conjunto de enlaces me pareció el más prometedor:

• AForge tiene un componente de visión artificial (para C #); Aquí hay un ejemplo de uso relevante
• OpenCV (una biblioteca de C ++ con un contenedor de C # )
• Este hilo proporciona una biblioteca de detección de blobs para el contenedor de C # para OpenCV.

Hice mi propia herramienta para ese tipo de spritesheet no uniforme. Permite editar compensaciones, etc. Aquí hay una captura de pantalla para darle una idea:

Echa un vistazo a texturepacker

http://www.texturepacker.com/

Produce un archivo como este (dependiendo de su configuración preferida)

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

Con estos datos, puede tomar fácilmente los rectángulos separados de la imagen.

spritebuddy.com ha funcionado muy bien para mí. No se pudo encontrar ayuda en el sitio en sí, pero esta publicación de Grupos de Google lo explica muy bien. Adivina automáticamente los límites de sus sprites, le permite ajustarlo Y le permite organizarlos en secuencias de animación. Luego escupe un archivo de metadatos para todo esto en JSON o XML. Entonces todo lo que tienes que hacer es analizar ese archivo de datos en tu juego para obtener los rectángulos delimitadores correctos.