Implementazione di una telecamera / viewport in un gioco 2D

Qual è il modo più pratico per implementare la telecamera / viewport in un gioco 2D?

Ho letto che dovrei memorizzare la posizione del mondo dell'oggetto anziché la posizione relativa allo schermo?

Situazione attuale:

Ho implementato un semplice gioco 2D in cui carico oggetti e livelli da file XML. Attualmente il file XML di livello è simile al seguente:

<map>
   <tile obj="ground" x="0" y="555" />
   <tile obj="ground" x="16" y="555" />
   <tile obj="ground" x="32" y="555" />
   ...
</map>

Tutti gli oggetti hanno una "posizione" di vettore 2D che memorizza la loro posizione corrente sullo schermo.

Quello che voglio che sia:

Illustrazione di viewport / gameworld

Nella foto:

La fotocamera è 800x600 o 640x480
I blocchi e gli sprite sono 16x16 pixel.
Le dimensioni del mondo possono variare
Le coordinate probabilmente dovrebbero essere normalizzate rispetto al mondo, non allo schermo?
Posizione della finestra relativa alla x, y del giocatore e si sposta quando il giocatore raggiunge la zona morta della telecamera (simile a questo video ).

Sto chiedendo pseudo esempi / articoli, ma se hai bisogno di sapere cosa sto usando per lo sviluppo: SDL e C / C ++.

c++ 2d architecture camera

— bluekirai
fonte

Aggiungi il tuo terzo link nei commenti qui e posso aggiungerlo alla tua domanda.

— MichaelHouse

Ecco cosa intendevo con la zona morta della fotocamera: youtube.com/watch?v=89TRXUm8jMI

— bluekirai

possibile duplicato di gamedev.stackexchange.com/questions/38672/…

— wolfdawn,

Ciao @Arthur Wulf White, ti interessa elaborare? Grazie.

— bluekirai,

La fotocamera che citi è una versione specifica di una fotocamera 2d generale che viene utilizzata solo per compensare la vista (nessuna rotazione e zoom). Il comportamento di tracciamento può essere implementato controllando la distanza tra il personaggio del giocatore e la telecamera, spostando la telecamera se la distanza è troppo grande.

— Wolfdawn,

Risposte:

È necessario disporre di ogni oggetto posizionato rispetto al mondo anziché allo schermo. La tua fotocamera dovrebbe anche avere le sue coordinate del mondo in modo da poter essere disegnata in una posizione relativa nel mondo. Può anche essere conveniente far seguire alla videocamera un oggetto, quindi ovunque si trovi, la videocamera utilizza solo le sue coordinate. In genere le coordinate della telecamera la posizioneranno dall'angolo in alto a sinistra. Ciò significa che la fotocamera avrebbe una posizione mondiale di circa (0,24) nella foto .

Per quanto riguarda effettivamente il disegno degli oggetti che la telecamera può "vedere", è necessario disegnare tutti gli oggetti relativi alle coordinate del mondo della telecamera. Per calcolare la posizione dello schermo di un oggetto rispetto alla telecamera, è sufficiente:

int screenX, screenY; //screen position of the object being drawn

screenX = object.x-camera.x;
screenY = object.y-camera.y;

Ovviamente alcuni oggetti non sono effettivamente visibili alla telecamera, quindi potresti voler implementare un sistema di abbattimento della vista.

— Dan Watkins
fonte

È meglio fare tutto questo nella GPU usando le matrici World e View, non modificando il punto in cui si disegnano gli oggetti sulla CPU.

In questo modo, puoi cambiare la fotocamera arbitrariamente (anche ingrandirla e rimpicciolirla!) E funzionerà magicamente. Puoi comunque visualizzare anche l'abbattimento per risparmiare tempo di disegno. E nessuno del tuo codice per disegnare il mondo dovrà cambiare dopo aver impostato correttamente la vista e le matrici del mondo.

In SDL, probabilmente puoi semplicemente incorporare chiamate OpenGL come glOrthoe glTranslate.

Vedi questa discussione .

— mklingen
fonte

Qualcuno può spiegare il downvote? Questo ha senso.

— Ciao World

Non ho votato in negativo, ma penso che sia perché questo non risponde nemmeno alla domanda. La domanda è su come calcolare qualcosa, non se è più efficiente o più facile da fare su una GPU vs CPU. L'OP ha anche detto che sta cercando esempi pseudo. Non c'è dubbio che l'uso di una combinazione di matrici fotocamera / mondo / modello sarebbe più efficiente, quindi mklingen ha almeno un punto.

— Dan Watkins,

Questa risposta non è affatto male! È più specifico per lo sviluppo OpenGL / DX, ma è l'approccio giusto in quanto puoi semplicemente calcolare una matrice di traduzione basata sui colori della telecamera e spostare gli oggetti tramite la matrice della camma, senza modificarne la posizione effettiva.

— nenchev,