Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Salve a tutti e scusatemi per il disturbo... io avrei un problema con la renderizzazione di alcuni oggetti in 2D per poter creare una mappa....
In pratica io leggo da un file di testo dove dentro ci sono solo numeri.... ogni numero corrisponde a un MapObject che ha un ID....
Quindi se nel file di testo ad esempio scrivo
1 e l'id del MapObject allora renderizza questo oggetto.... non so se riesco a farmi capire bene cmq il problema è che quando mi renderizza gli oggetti la seconda linea è uguale alla prima....cmq provo a postarvi il codice per farvi capire meglio....
Ho allegato un'immagine per farvi vedere come me lo renderizza
in pratica la seconda linea è uguale alla prima... credo che sia un problema di posizione perchè ho provato a mostrare a video ogni posizione degli oggetti e si trova...però con capisco perchè mi da questo problema...
spero qualcuno possa aiutarmi
Non so dirti, ma vedo tutto completamente senza senso.
Ti spiego.
Ho fatto diversi progetti del genere molto elaborati quindi ho una certa esperienza e posso consigliarti come muoverti.
Parto dal principio,
1°
Il metodo che hai usato è il peggiore che si possa usare.
Non perché scredito quello che hai fatto attenzione!
Ma penso che recuperare una mappa da un file salvato in questo modo, sia completamente sbagliato.
Una mappa andrebbe serializzata in una lista correlata di una struttura, e successivamente implementata.
Così con un semplice ciclo for, stampi a video tutte le texture2d.
Ovviamente non parlo di risorsa completa, ma del sourceRect che prende inizio X,Y e Fine X,Y della porzione dello sprite da renderizzare.
Viene proprio illustrato l'utilizzo di Liste e Strutture serializzate su file e poi re-implementate a runtime.
Ho usato Qt, ma non dovrebbe essere un problema riscriverle tanto stai usando opengl da quel che vedo.
2°
Se proprio vuoi usare questo metodo, ho cercato di trovare nel tuo sorgente postato, la dimensione della mappa
ma non ho trovato nulla di utile. solo un metodo OnInit
Fatto sta, che per disegnare correttamente i pezzi di tiles, devi sapere esattamente ogni blocco quanto misura così come la dimensione della mappa.
Se ho dei blocchi di 32x32 pixel esempio, e ho una mappa larga 640,
automaticamente so che ho 20 blocchi per riga. ( 32 * 20 = 640 ) Larghezza della mappa
Codice sorgente - presumibilmente Plain Text
for(int y = 0; y < map_height; y+=32)
{
for(int x = 0; x < map_width; x+=32)
{
//Aggiungo il pezzo a posizione X e Y al vettore
}
}
Ma come detto, è sempre un metodo molto brutto sia da comprendere che da utilizzare.
Anche perché andrai ad incasinarti con gli ID del tipo di blocco da visualizzare.
Quindi e meglio usare una struttura.
Per concludere la risposta la tuo problema succede questo perché probabilmente non esegui correttamente il ciclo
per andare a posizionare i blocchi con le giuste posizioni dal file, proprio perché non utilizzando una struttura devi andare un pò a caso sperando che non sbagli a scrivere un numero o a dividerli correttamente per la dimensione della mappa.
ciao Thejuster e grazie per la risposta... in effetti come metodo e un pò un casino anche per me che ho scritto la funzione avvolte fado in chaos...comunque proverò a studiare un pò come hai detto tu di usare una struttura...darò un'occhiata al tuo progetto e cercherò di implementarlo nel mio.... ah un'altra cosa non so se sto sbagliando a scriverlo in questo topic o devo aprirne un'altro...
in pratica ho anche un'altro problemino... sto facendo un'animazione di un player che cammina quindi passo i primi vertici delle coordinate delle texute e poi le modifico con Uniform dello shader passandogli le coordinate della texture proprio come hai detto tu.... riesco a renderizzarle correttamente quando ad esempio imposto x_image 32 y_image 0 (quindi sarebbe la prima immagine di 32x32 che ho nel mio atlas...ora il problema è che quando provo a fare un animazione e creo un ciclo for e su una linea ho 3 immagini di un player che cammina verso il basso faccio un for in questo modo
for(int a = 0; a < 2; a++){
playerObj.GetShader().Use();
playerObj.GetShader().setFloat("x_dir", (0.32 * a) * time ); //0.50
playerObj.GetShader().setFloat("y_dir", 0.0);
}
ma mi mostra le immagini in sequenza cioè non mi fa la moltiplicazione di 32*0 - 32*1 ecc e renderizza ogni blocco di texture ma me le mostra lineari... provo a allegare una gif per far capire meglio...mi credi? sulle stupidaggini xke sicuramente sarà una stupidaggine.... mi perdo.... poi vedo se x favore puoi dirmi se sto sbagliando io in qualcosa nel ciclo o boh... cmq scusami per le domande niubbe xD ma studio opengl da pochi mesi...e ancora devo conoscerlo bene bene
ho fatto un piccolissimo video per mostrarvi quello che sto dicendo xke un'altra mia pecca è nel sapermi spiegare XD
https://files.fm/u/89ssvawnh
Ultima modifica effettuata da Gemini il 10/01/2023 alle 19:39
x = posizione X del blocco
y = posozione Y
w = larghezza blocco (32px)
h = altezza blocco (32px);
Tx = Tile Source X
Ty = Tile Source Y
Tw = Larghezza del tile (32px)
Th = Altezza del Tile (32px)
in seguito aggiungo gli elementi alla lista
Dopo vado a serializzare su file usando l'override degli operatori
Riguardo al personaggio, succede anche qui uguale perché hai confuso i parametri.
o semplicemente esegue l'incremento di X molto lentamente rispetto al frame che richiede un 32 per cambiare.
Personalmente, ho usato il resto di una divisione di 16
provo a scriverti qualcosa di comprensibile
Per far muovere il personaggio, premi ovviamente Su,Giu,Destra,Sinitra.
In questo caso aumenterà la variabile del movimento.
Ma ti insegno un bel trick.
Non andare ad aumentare direttamente la posizione del persionaggio.
Ma usa una variabile che permette man mano di far arrivare il personaggio alla destizione.
ad esempio
Premo Destra
Codice sorgente - presumibilmente C/C++
int x =0;
int destinazione = 0;
//Premo Destra
if(destinazione == 0)
destinazione += 32;
//Premo Sinistra
if(destinazione == 0)
destinazione -= 32
//Loop
if(destinazione > 0 && Direzione == Destra )
{
destinazione -=2;
x += 2;
}
if(destinazione < 0 && Direzione == Sinistra)
{
destinazione +=2;
x -= 2;
}
in modo da simulare uno spostamento graduale fino a che la destinazione non si azzeri.
Una volta arrivato a 0 ovviamente il loop del movimento si ferma.
Per il frame come detto prima, io uso il resto di una divisione per il totale dei frame
Se ho uno sprite di cui un personaggio ha 16 frame.
La variabile Frame è relativa al SourceX dello sprite
mentre userai una variabile tipo Face per il sourceY ovvero dove il personaggio sta guardando o camminando.
Di conseguenza il frame anima verso destra, mentre il Face per le varie direzioni.
Elimina tutto il restante che hai fatto
Codice sorgente - presumibilmente Plain Text
playerObj.GetShader().setFloat("x_dir", (0.32 * a) * time ); //0.50
grazie mille thejuster ora sto andando a lavoro appena torno oggi nel pomeriggio proverò e ti farò sapere cmq grazie veramente anche solo con queste spiegazioni mi hai fatto capire gia tante cose....cmq oggi proverò a fare un metodo per le tile e l'animazioni e t farò sapere come andrà
cmq veramente figo il video che mi hai mostrato...io vorrei fare qualcosa proprio così...anche l'ombra dietro *_*....vabbè piano piano capirò come fare ....
Ultima modifica effettuata da Gemini il 11/01/2023 alle 6:34
Buongiorno e rieccomi con una domanda forse stupidissima... in pratica Thejuster per le tile ho risolto cioè quasi risolto ho fatto come mi hai suggerito tu però invece di usare una struttura ho fatto una classe dove dal costruttore prendo tutte le info dell'immagine che mi servono e le salvo nelle variabili... non ho usato una lista al momento......
Codice sorgente - presumibilmente C++
float x;
float y;
float image_width;
float image_height;
float sprite_width;
float sprite_height;
ok fin qui ci siamo poi ai vertici delle coordinate delle texture gli passo queste info in questo modo
ora quando voglio renderizzare ad esempio il player in alto cambio semplicemente x e y....
Però mi domando qui io vado a modificare i vertici direttamente nel codice c++ ma non conviene farlo dallo shader cioè come facevo prima? mandando un uniform float allo shader cosi da far lavorare la gpu....
non so forse sto sbagliando o sto dicendo una stupidaggine però volevo capire meglio questa cosa...cosa mi conviene cambiare i vertici da c++ e ogni volta fare il bind del vbo per i nuovi vertici nel buffer oppure meglio usare un uniform float da mandare allo shader?
Ultima modifica effettuata da Gemini il 13/01/2023 alle 9:09
Non sò dirti quale metodo sia più conviente usare. ( Non performante )
Personalmente avevo creato un void che durante il render andava a bindare delle texture.
Cambiavo le TexCoord prima del Draw subito dopo al GlBegin
Avevo un pò diviso il tutto in void separati che richiamavo dal render per risparmiare tempo.
Dovrebbe esistere anche un metodo chiamato BlitFrameBuffer e GenFrameBuffer era qualcosa che rigenerava la texture nel fbo.
Tornando al discorso, il mio draw era semplicemente composto da 4 chiamate
da li andavo a richiamare successivamente ogni funzione dove avevo già pre-elaborato l'inizializzazione dei vertici
chiamando un void e passando argomenti come posizione, source ecc. ecc.
alla fine un semplice void per disegnare
Ti mostro il mio esempio in C# preso direttamente dal mio Mire Engine
In questo esempio disegnavo tutti i vari tiles della mappa Id per ID
Ma penso basti solo ottimizzare il codice per adattarlo al personaggio.
Ciclo per Disegnare i vari Layer come id della texture passo l'intera immagine
che poi va a suddividere tramite la lista con le relative posizioni X ,Y , SourceX, SourceY
Ho tagliato un bel pò di codice che era relativo al mio motore.
Spero di non aver tagliato l'utile essenziale
Poi ho preferito passare a MonoGame per semplicità ed efficienza senza andarmi a complicare la vita.
Cmq penso che ottimizzando bene le funzioni in void separati che eseguono la medesima funzione puoi ottenere qualcosa di facile e veloce come nel mio esempio.
Evitando di andarti a riscrivere ogni volta riposizionamenti dei vertici e bind delle texture.
Ti consiglio di implementare prima le liste e strutture
Cosa fondamentale e necessaria per un progetto del genere.
ovviamente è da migliorare sicuramente però funziona... ed e piu pulita come funzione.... poi non so se è il metodo migliore....
Io credo... (questo è un mio pensiero) che sia meglio mandare i parametri allo shader in modo che il lavoro lo fa lui e quindi da come ho capito, (interrompetemi se sbaglio!) lo shader usa la gpu e quindi penso che si abbia prestazioni migliori visto che la cpu manda solo la prima volta i vertici allo shader per le coordinate della texture e i vertici per il quad.....
ripeto è un mio pensiero questo... sicuramente starò dicendo cavolate... o magari no.... mi devo informare meglio su sta cosa cmq
Ultima modifica effettuata da Gemini il 13/01/2023 alle 9:17
| 
Gemini ha allegato un file: Schermata del 2023-01-04 12-21-35.png (20541 bytes)
cmq grazie veramente anche solo con queste spiegazioni mi hai fatto capire gia tante cose....cmq oggi proverò a fare un metodo per le tile e l'animazioni e t farò sapere come andrà 
