Come posso gestire fogli sprite con dimensioni sprite non uniformi?

Per un foglio di calcolo con dimensioni di sprite non uniformi , come posso ottenere i rettangoli di delimitazione per ogni singolo sprite (ovvero le caselle blu nell'immagine seguente / ho disegnato solo alcuni esempi)?

Quello che vorrei determinare sono: offset_x, offset_y, width, height

Finora ho usato solo fogli di calcolo su cui tutti gli sprite hanno dimensioni identiche . In tal caso, è sufficiente specificare l'offset xe y per ottenere uno sprite particolare. Tuttavia, per fogli di calcolo di dimensioni non uniformi questo non funziona.

EDIT: dopo aver letto i commenti e le risposte, ho riformulato la mia domanda per renderlo più inclusivo. il processo effettivo di utilizzo di un foglio di calcolo in un gioco. In precedenza, la domanda conteneva i punti per cui le persone producono fogli di calcolo di dimensioni non uniformi e come posso gestirlo.

La maggior parte dei fogli sprite di dimensioni non identiche di solito hanno una sorta di metadati con dove si trova l'ancora dello sprite. Ci sono molti strumenti che fanno cose come eliminare i pixel alfa completi e ti danno i dati di cui hai bisogno in modo che questi dati non vengano generati manualmente.

Se non disponi di questi metadati, devi crearli tu stesso. Il modo più preciso è quello che hai detto nella tua domanda, che è semplicemente farlo a mano. Potrebbe volerci un po ', ma probabilmente è più veloce di fare nuovi sprite.

Puoi eseguire analisi sull'immagine per individuare i rettangoli di delimitazione di ogni sprite, ordinare quei rettangoli di delimitazione (forse aumentando il minimo X, quindi Y) e avrai un insieme di regioni di delimitazione che corrispondono ai frame del foglio sprite.

Poiché questo processo può essere relativamente costoso, probabilmente vorrai farlo offline, ad esempio come parte del processo di generazione del tuo gioco. È quindi possibile serializzare le informazioni sulla regione di delimitazione in un file memorizzato con l'immagine del foglio sprite corrispondente. In fase di runtime carichi sia l'immagine che il file di definizione del confine e hai le informazioni necessarie per accedere a ogni singolo sprite.

Questo è più facile a dirsi che a farsi, però. Fondamentalmente ti consigliamo di eseguire il rilevamento delle funzionalità e in particolare il rilevamento BLOB che sono problemi di visione artificiale. È inoltre possibile impostare la soglia dell'immagine (su bianco e nero) e utilizzare una tecnica di rilevamento dei bordi . La matematica pertinente alla base di queste tecniche è spiegata molto meglio su quei collegamenti di quanto potessi io, e nel caso in cui non ti senti in grado di implementare quella matematica da solo, ci sono alcune librerie disponibili che possono aiutarti. La seguente serie di collegamenti mi è sembrata la più promettente:

• AForge ha un componente di visione artificiale (per C #); ecco un esempio di utilizzo pertinente
• OpenCV (una libreria C ++ con un wrapper C # )
• Questo thread fornisce una libreria di rilevamento BLOB per il wrapper C # per OpenCV.

Ho creato il mio strumento per quel tipo di spritesheet non uniforme. Permette di modificare offset, eccetera. Ecco uno screenshot per darti un'idea:

Dai un'occhiata a texturepacker

http://www.texturepacker.com/

Emette un file come questo (a seconda delle impostazioni preffered)

    {
    "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 questi dati, puoi facilmente afferrare i rettangoli separati dall'immagine.

spritebuddy.com ha funzionato benissimo per me. Non è stato possibile trovare alcun aiuto sul sito stesso, ma questo post di Google Gruppi lo spiega davvero bene. Indovina automaticamente i limiti per i tuoi sprite, ti consente di regolarli e ti consente di disporli in sequenze di animazione. Quindi sputa un file di metadati per tutto ciò in JSON o XML. Quindi tutto ciò che devi fare è analizzare quel file di dati nel tuo gioco per ottenere i rettangoli di delimitazione corretti.