Thejuster

Dopo un lungo lavoro, penso di essere riuscito ad accontentarti. Ho ulteriormente elaborato l'algoritmo di generazione con ulteriori 5 passaggi. 1° Si dà in pasto al programma una screen di un gioco qualsiasi di snes. 2° Il programma elabora l'immagine simulando un hardware snes modalità 256 colori ma con palette a 5 bit 56 colori. 3° L'algoritmo non si limita a ridurre i colori, ma si limita a ricreare la grafica sfruttando la palette generata dall'immagine come campione. Prima di tutto, estrae e campiona i colori eliminando quelli superflui e ripetuti per poi adattarli ancora una volta a 5 bit. Ad esempio ho usato questa screen di Chrono trigger Recuperato e generati i colori limitati per l'hardware snes, si può salvare la palette e tenerla per poi applicare sempre la stessa risonanza alle altre screen. Ma come funziona? L'algoritmo genera una sorta di Luminance Key dando dei pesi sui colori, in modo da ricreare uno spettrogramma e dare più rilevanza a dei colori rispetto ad altri. Non ho fatto molti test anche perché ho avuto poco tempo per testare ma molto lavoro fatto sull'algoritmo. Prendendo questa screen da google: Caricando la palette precedentemente generata ottengo questo risultato Sembra un vero gioco snes. Ovviamente alcuni colori possono sembrare fuori luogo. Semplicemente perché ho caricato una palette generata da una screen di una foresta con prevalenza di rosso per le foglie. Ma una qualche screen di qualche taverna per snes il risultato è sicuramente diverso. Ad esempio puoi notare i bordi delle pareti. da sfumature e colori tenui, a pixel evidenti e netti. In più oltre a questo, come annunciato su itch, Filtri come GameBoy ed altri in arrivo

Ti descrivo cosa c'è dietro al tool che normalmente non si vede o non si percepisce. In sintesi, il mio strumento non si limita a pixellare un'immagine ad esempio come fa photoshop, ma offre strumenti più avanzati per personalizzare il risultato. Ci sono molti fattori che vanno analizzati. Prendiamo spunto proprio da photoshop. Cluster Strength: A differenza di photoshop che applica una pixelizzazione uniforme, il mio algortimo introduce un parametro chiamato Cluster Strenght, che controlla il livello di aggregazione dei pixel. Puoi decidere quanto grandi devono essere i blocchi di pixel e quanto devono essere raggruppati i colori ottenendo un effetto più personalizzato e marcato. Palette Colori Intelligente: A differenza del filtro di phoshop che si limita a pixelizzare l'immagine mantenendo i colori originali, il mio algoritmo genera una palette di colori ridotta e sostituisce i colori dell'immagine con quelli più vicini nella palette generata, creando un effetto più retro e controllato. In più giocando con il cluster Strenght, nella riduzione dei colori aiuta a mantenere una transizione più naturale trai i pixel migliorando l'output visivo. anche in questo strumento, segretamente viene abilitato un upscaling. Photoshop ha strumenti di ridimensionamento, il mio strumento sfrutta un upscaling con interpolazione bilineare, che evita il classico effetto a blocchi, in più si aggiunge anche lo smoothing Factor che controlla quanto l'upscaling deve essere morbido o mantenere l'effetto pixel art. Questo è particolarmente utile proprio quando si usano immagini di grandi dimensioni e si decide di pixelizzarle. Preservazione della Trasparenza: I pixel trasparenti vengono preservati, evitando che vengano sostituiti da blocchi opachi. Utile soprattutto per i game designer che necessitano di sprite trasparenti. In più altre aggiunte come: Edge Detector ( Canny ) e struttura a Reticolo con l'Algoritmo di Voronoi Aggiungerò altre feature? Sicuramente! Migliorerò maggiormente l'output grafico? Ovvio! Dietro al tool, non c'è un IA che genera immagini o quant'altro. Ma il frutto della mia esperienza maturata negli anni nello sviluppo di motori grafici, IDE, Editor Grafici ed Game Engine. Tutto ciò realizzato con un approccio ingegneristico basato su C++ ottimizzando ogni passaggio per garantire equilibrio, stabilità e prestazioni. Ovviamente, questo tool offre una soluzione su misura, con caratteristiche che possono essere ulteriormente espanse e migliorate proprio per adattarsi alle esigenze degli sviluppatori. Spero di essere stato esaustivo almeno per quel che riguarda le informazioni principali del tool. Il tool è molto giovane, ha appena qualche anno. Sicuramente migliorerà questo grazie anche al supporto di tutti voi.

Si grazie per la segnalazione mi era sfuggita quella parte. Ho appena rilasciato una nuova release per i vari bugfix.

Scusami non ho capito a quale strumento ti riferisci, Pixelizer o Upscaling? PS: Le feature di ridimensionamento le sto applicando ora. Upscaling come ho allegato sopra nel rar il progetto di esempio, ingrandisce l'immagine aumentando i pixel Ovvero ricreando sfumature che mancano per realizzare immagini più dettagliate ovviamente per ottenere questo effetto, L'immagine viene ingrandita, ma Ahimè mi sono accorto del bug che l'immagine non viene ridimensionata correttamente. Quando si aumenta il fattore scala ignora le dimensioni impostate sul lato destro. Questo perché ho rimasto attivo di default durante l'esportazione il Keep Transform, che cerca di stabilizzare l'immagine senza storcerla (Esempio più larga e più corta) ma rispettando le proporzioni. Quindi per ora si, L'Upscaling, ingrandisce solo, ma sto appunto modificando per ridimensionare dopo aver upscalato i pixel. Riguardo al Pixelizer, ho già completato la parte per ridimensionare e tutto. Ora tocca solo all'upscaler per poi rilasciare un nuovo aggiornamento con altre funzionalità.

Lo scrivo anche qui, in modo da essere più chiaro anche con chi legge il topic. In anzi tutto spiego esattamente cosa fà. Per prima cosa, genera una palette di colori, più simile possibile a quella utilizzata dalla risorsa. L'intensità ovviamente è variabile. P={(r,g,b)∣r,g,b∈L} In questo esempio, ho impostato dei valori consigliati per il tipo di risorsa Passaggi Filtro: Indica quanti colori (ricreati dalla palette) deve raggruppare. Il processo funziona in modo inverso, quindi: Maggiore sarà il valore, più colori della risorsa saranno visibili. Più il valore e basso, più l'algoritmo tenterà di raggruppare i colori. Mentre il Cluster Strenght, non fà altro che amplificare l'area di gruppo dei pixel. Maggiore sarà il valore, più elementi saranno pixellati. Questa funzione, e consigliabile quando si hanno immagini di grandi dimensioni, in modo prima di pixellarle, in seguito eseguire un downscaling. In modo che questa: Diventi questa Ovviamente si può giocare come si vuole con i parametri. Dipende dal risultato che si cerca di ottenere. L'upscaling ve lo faccio provare in diretta. includo anche i sorgenti per i più curiosi. E' una prova che avevo fatto prima di completare tutto nel programma definitivo. Perché non amo incasinare i progetti. Faccio prima delle prove in progetti random per osservarne i risultati e come si comporta. Poi ricompongo tutto nel programma principale. Questo è un esempio, quindi non è funzionale al 100%, ma fà quello che deve fare in termini di operazione. Manca la parte più importante ovvero la rimozione del background e l'affino dei bordi. UpscalingTest.rar

Grazie mille lord soprattutto per il tuo supporto. Ne approfitto per annunciare che anche l'upscaling è completato. Si, come già presente (in parte) per l'upscaling che al momento ridimensiona in proporzione ^ 2, ci sarà anche per il pixelizer. A questi due strumenti volevo aggiungere una funzione per un autodetect della risorsa utilizzata. Un pò come accade per l'editor di chipset per il 2k3. Nel senso che si carica una risorsa da mz esempio, il tool capisce che è una charaset, quindi oltre a pixellare l'immagine, la ridimensiona in modo che rispetta l'output ( per 2k3, XP, ACE o ) che si disedera.

Personalmente stimo molto freank, ma tutto quello che riguarda l'uso delle IA per me è croce nera. Posso tollerare l'IA unicamente su una cosa. All'epoca ho dovuto affrontare algoritmi o processi che mi hanno bloccato per più mesi su un progetto, e trovare qualcuno che ne capisse qualcosa era estremamente difficile. Se non provare a chiudere su Stack Overflow ed aspettare qualcuno di buona anima che riuscisse a risolverti il problema. Allora, posso appoggiare l'ia. Ma non accetto IA Generative, del tipo che si chiede pappa pronta e puff. Sono sempre stato contro questa filosofia che non è diversa dal vecchio "Copia / Incolla" usato prima che uscissero ste ia. Il problema e che le gente sta prendendo troppo sotto gamba sta cosa e sta sfuggendo di mano. E spuntano persone dette esperte come funghi, nascosti dietro ad un IA anche per risponderti nel caso gli poni una domanda di programmazione. Eh si, ho incontrato anche persone del genere. Che non sanno una virgola di programmazione, gli chiedi una cosa per metterli alla prova, e ti rispondono chiedendola prima l'IA e poi a te. Cosa veramente pietosa.... Dico sempre una cosa ad i miei amici. Se vuoi fare una cosa, falla, ma con la tua testa e con le tue mani. Sbaglia ed impara da dove hai sbagliato, riscrivila da capo che sarà ancora migliore. Solo così sarai fiero di quello che hai fatto ma soprattutto, uno dei principali motivi per cui programmiamo o creiamo giochi, e proprio quello di divertirci prima ancora noi, per poi far divertire gli altri.

non penso sia un problema, ma cmq parte del codice è questo insomma almeno la parte piu importante BYTE r1 = (currentPixel >> 16) & 0xFF, g1 = (currentPixel >> 8) & 0xFF, b1 = currentPixel & 0xFF; BYTE r2 = (rightPixel >> 16) & 0xFF, g2 = (rightPixel >> 8) & 0xFF, b2 = rightPixel & 0xFF; BYTE r3 = (bottomPixel >> 16) & 0xFF, g3 = (bottomPixel >> 8) & 0xFF, b3 = bottomPixel & 0xFF; BYTE r4 = (bottomRightPixel >> 16) & 0xFF, g4 = (bottomRightPixel >> 8) & 0xFF, b4 = bottomRightPixel & 0xFF; int red = (1 - fx) * (1 - fy) * r1 + fx * (1 - fy) * r2 + (1 - fx) * fy * r3 + fx * fy * r4; int green = (1 - fx) * (1 - fy) * g1 + fx * (1 - fy) * g2 + (1 - fx) * fy * g3 + fx * fy * g4; int blue = (1 - fx) * (1 - fy) * b1 + fx * (1 - fy) * b2 + (1 - fx) * fy * b3 + fx * fy * b4; //uscitga UINT newPixel = (255 << 24) | (red << 16) | (green << 8) | blue; outputPixels[(y * scaleFactor + dy) * outputStride + (x * scaleFactor + dx)] = newPixel; inputImage->UnlockBits(&inputData); outputImage->UnlockBits(&outputData); Almeno per quello che riguarda lo smoothing. Magari, dovrei provare ad alleggerire la parte del nero. perché sembra troppo netto.

Si ovviamente essendo una sfumatura, se si sovrappone ad un colore esempio verde, avendo le trasparenze logicamente rimane verde. Anche se prima di fare ciò, elimino prima il colore di fondo e poi applico le modifiche. Ma questo non è problema. Magari ho proposto io un esempio sbagliato usando un charaset. Perché rpgmaker 2k3 accetta solo charaset piccoli mentre io li ho ingranditi nell'esempio. Fatto sta, che durante l'esportazione, il background viene eliminato. Di conseguenza lo sfondo rimane trasparente. Quindi avremo il charaset del 2k3 ingrandito, ma senza background. In modo che gli altri tool della serie li accettano senza problemi. evitando per l'appunto di intravedere un colore per un'altro nelle trasparenze. Ottenendo alla fine un risultato del genere usando uno scaling * 2 Ovviamente questo è solo un esempio. Il sistema dovrà essere ulteriormente affinato.

Uhm ho notato ora. Eppure ero sicuro di aver seguito i vari template di MZ. Mi era sfuggita la parte per quel che riguarda la possibilità di scegliere da MZ i tiles. Non sapevo di questa opzione. Ma a tal proposito prima di questa discussione stavo lavorando ad un eventuale filtro proprio per l'upscaling. Per evitare l'impatto visivo dei pixel (Se noti i dettagli, nella screen "DOPO" i vari colori sono sfumati e non netti e precisi) Ero impegnato proprio per lavorare a questo problema. Perché eseguendo un upscaling, si ingrandisce solo l'immagine ma non i dettagli. Anzi, alcuni vengono pure persi, quindi questo filtro risolveva il problema dell'upscaling. Non è un semplice, "Prendi l'immagine e ingrandiscila". Ma c'è tutto un processo dietro, simile al precedente pixelizer. Ma in questo caso fa l'opposto. Anziché pixellare, ne aumenta i dettagli.

Buongiorno ragazzi. Prima di natale, ho voluto affrettare lo sviluppo per rilasciare almeno l'editor completo di chipset. Chi non ha seguito gli sviluppi, è stato introdotto un filtro molto particolare. Possiamo definirlo unico nel suo genere. Cosa fa? Potremmo definirlo un interpolazione lineare invertita. Anche se c'è molto di più dietro le quinte. Trasforma un'immagine di alta qualità in una pixellata. Ad esempio: oppure un intero tileset Il filtro ovviamente ha piu effetto su immagini di alta qualità. I passaggi, servono ad indicare quanto preciso deve essere il filtro. Meno passaggi farà, più pixel saranno visibili. C'è appunto il preview per capire quale risultato vogliamo ottenere. Attualmente ho impostato un limite di 15 passaggi. Anche se non sembra è un calcolo enorme. Prendiamo come esempio questo tile. che mi sura 768 x 576 sono un totale di 442.368 pixel * Passaggi Presumiamo 15 ( 442.368 * 15 ) = 6.635.520 Quindi l'algoritmo eseguirà un controllo di 6.635.520 pixel in meno di 5 secondi. 😅 Oltre ovviamente a quello che deve fare per renderli pixellosi. Quindi c'è un bel lavorone dietro. Oltre a questo, la vera chicca e l'editor. Un convertitore di risorse in tempo reale da piazzare direttamente sul template. Senza fare molte chiacchiere vi mostro direttamente il video di presentazione spero che vi piaccia.

sera riprendo il topic per ancora qualche problema di posizionamento. Ho fatto diversi tentativi anche allungando l'acqua più del dovuto ma ancora ci sono dei strani problemi. Magari sono piazziati male. posiziono esempio i due elementi di MZ. Ma al caricamento del chipset: Entrambi allungati seguendo il template ma il risultato non è quello che volevo il primo lo taglia bene, il secondo ha qualcosa che non và. sbaglio a posizionare gli elementi nel template?

in che senso? XD Cmq ho fatto dei tentativi, ampliando l'algoritmo con qualche parametro in più. Avevo stabilito dei passaggi fissi da fare invece ho aggiunto un ulteriore processo per livelli di profondità e passaggi sui colori. Piu il numero è alto piu tempo impiega per il calcolo ma ovviamente maggiore sarà la qualità. Alcuni test Mostro i più significanti Questa è quella che preferisco di più. 8^255 passaggi. Anche se è codice nativo, impiega qualche secondo. Mentre per gli altri e quasi istantaneo. Da notare l'armatura sulla spalla. Effetto veramente molto carino e pixelloso.

In teoria e nato per quello, ma ovviamente si. Si può adattare anziché esportare solo una semplice risorsa, adattare ad una più grande. Ma più colori ha, più ne perdi giustamente. Su quei asset gira bene perché non ci sono sfumature molto elaborate. O Meglio, le risorse tendono ad avere una certa affinità ma non molto distanti tra loro. Un esempio è: Convertire una foto. Si avrebbe un output orrendo. Non perché l'algoritmo non funzioni. Ma vista la foto che ha un infinità di sfumature e colori. La tavolozza è solo di 256 colori, puoi immaginare da solo cosa ne uscirebbe fuori. Certo, il mio metodo usa un'attenzione maggiore ai colori, al passaggio tra un colore ed un altro seguendo un preciso schema. Ma ad esempio convertire una foto di una persone in stile retro pixel penso sia molto più complicato di quando sembri. Impossibile no. Ma servirebbero ulteriori passaggi ed algoritmi. Ad esempio: 1° Filtro Pop Art 2° Pixelizer 3° Conversione Giusto un ipotesi. Poi sarebbe da vedere il risultato e migliorare le varie parti. Perché ogni algoritmo è a sè, andrebbe ritoccato per ciò che serve.

Ecco qui Rpgmaker Asset Converter & UI Tool by Making Italia Attualmente è ancora in fase di sviluppo. Ma ci sono aggiornamenti costanti e regolari