spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Zitat von »Architekt«

Mein Abitur liegt gerade hinter mir, Vektoren sind mir schon noch ein guter Begriff und sofern man die ganze Kamera - Engine schlank hält wäre ich gar nicht so abgeneigt es erklärt zu bekommen.
Ansonsten würde ich das ganze nämlich wirklich in simpler 2D Programmierung lösen müssen.

Nun gut, dann werde ich dir mal nen groben überblick über die Thematik verschaffen.
Alles bis ins detail kann ich dir aber nicht erklären. Aber mit ein bischen eigeninitiative schafft man das.

Es gibt 3 verschiedene Formen von Matrix, wie du weißt:
Translation, Skalierung, Rotation.
Aber ich bleibe im moment erstmal nur bei der Position.

In der 3D-Programmierung hat quasi jedes Objekt seine eigene Matrix, denn es wird beim erstellen an den Punkt (0|0|0) gesetzt, genau wie alles andere. Die Kamera auch.

In wirklichkeit gibt es aber keine Kamera. Die Kamera ist nämlich immer fix und wird nicht bewegt. Statdessen wird alles um die Kamera herumbewegt, wenn man den Blickwinkel drehen will.

Deshalb musst du, um die Kamera zu bewegen nur alle anderen Objekte auf dem Schirm in genau die entgegengesetzte Richtung bewegen.

Im Grunde ist das nicht schwer: Du hast z.B. für jedes Objekt im Spiel einen Vektor, in der die Position gespeichert ist.
Nehmen wir also an, du willst ein Objekt auf der Position (5|10) darstellen.
Dafür hast du einfach einen Vektor definiert.

nun bewegnst du das Objekt bei jedem zeichnen auf diese Position.
Wenn du jetzt aber die Kamera simulieren willst, dann brauchst du auch für sie einen Vektor.
Sagen wir mal, die Kamera hat eine Position von (10|10).

Aber da du nun die Kamera selbst nicht bewegen kannst erstellst du mit der Position eine 3x3 Matrix und invertierst sie.
Mit dieser inversen 3x3 Matrix kannst du alle anderen Objekte auf der Karte so transformieren, dass es so aussieht, als würdest du eine Kamera bewegen, wenn du die position der Kamera änderst.

Die Inverse Matrix verschiebt demnach alle objekte in Richtung -10|-10.
Wenn du nun das Objekt, das an der Position 5|10 durch diese inverse Matrix schickst, dann befindet es sich nach der verschiebung an der Position -5|0.
Je nachdem wie du nun deine Welt definiert hast ist das Objekt dann auserhalb des Sichbereiches.

Zusätzlich könnte man auch einen Mittelpunkt für jedes Objekt definieren und dann mit dem Mittelpunkt der Objekte arbeiten. Aber das bleibt alles dir überlassen.
In diese Matrizen kann man dan auch noch die Skalierung mit reinnehmen. Durch diese skalierung kann man ein Zoomen der Kamera simulieren, wenn du es geschickt anstellst und auch eine Rotation kann sich damit realisieren lassen.

Aber wenn du nur die Verschiebung im Auge hast, dann brauchst du nichtmal Matrizen zu benutzen, sondern arbeitest ganz einfach mit den Positionsvektoren und veränderst sie so, wie ich es ebend erklärt habe.

Auf jeden fall musst du dann vor jedem Rendern die Position neu bestimmen indem du es durch die Kameramatrix veränderst oder ihn genau um die entgegengesetzte Kameraposition verschiebst und dann auf den Backbuffer zeichnest.

Ob du das nun so machen willst oder nicht bleibt dann dir überlassen.
Ich persönlich finde es nicht so schwer die objekte in die entgegengesetzte Kameraposition zu verschieben.
Wenn du nun genau wissen willst, welchen ausschnitt der Landkarte du zeichnen musst ist das auch ganz einfach geregelt.

Du hast einfach eine Kameraposition und die ecke oben links.
Wenn du nun die kamera nach rechts bewegst, dann bewegst du den Eckpunkt um die inverse Kameraposition und errechnest den Punkt, der neu an der Stelle 0|0 ist.
Aber du musst nicht rechnen, denn die neue stelle 0|0 auf der Karte ist gleichzeitig die Position der Kamera.

Um es genauer zu erklären: Du willst wissen, welchen ausschnitt der BMP datei du auf den Bildschirm zeichnen willst.
Dafür hast du ja das Rechteck definiert, wie groß der Ausschnitt ist.
Am anfang ist das Rechteck z.B. so:

Rechteck.links = 0;
Rechteck.oben = 0;
Rechteck.rechts = 800;
Rechteck.unten = 600;

Das werweiterst du ganz einfach um die Kameraposition:

Rechteck.links = 0+KameraPosition.x;
Rechteck.oben = 0+KameraPosition.y;
Rechteck.rechts = 800+KameraPosition.x;
Rechteck.unten = 600+KameraPosition.y;

Damit hast du dann quasi die Ganze welt um die inverse Kameraposition verschoben.

Falls ich einen fehler gemacht habe, korrigiert mich
Es ist spät und fehler sind erlaubt

Zu so später Stunde noch so - mehr oder weniger - komplizierten Stoff ... Matrizen... Vektoren... in der 2D Programmierung kannst du meistens in Koordinaten denken (einfach 2-dimensionale Vektoren... aber Koordinaten klingt doch gleich schon viel anschaulicher, oder nicht?!).

So einen Ansatz hat Herror ja zum Ende seins Posts hin auch gebracht. Nur eine kleine Schönheitskorrektur bzw. -anmerkung: Es ist vielleicht besser verständlich, wenn du nicht zum Bildausschnitt die Kameraposition addierst, sondern umgekehrt. Natürlich ändert das gar nichts am Ergebnis, denn das Kommutativgesetz gilt ja bei der Addition zweier reelen Zahlen, aber meines Erachtens ist das fürs Verständnis ein klein wenig einfacher.

Bei Herrors Beispiel ist die Kameraposition immer in einer Ecke des Bildausschnitts, je nach dem wo der Koordinatenursprung definiert ist. Da du allerdings deine Spielfigur anscheinend in der Mitte des Bildschirms behalten willst bietet es sich an, die Kameraposition (zumindest standardmäßig) mit der Spielerposition gleichzusetzen.

Beispiel:

Spielfigur und somit auch Kameraposition im Koordinatenurpsrung: (0|0)
Größe des Bildausschnitts: 800x600

Dann liegt in folgendem Rechteck der von der Kamera sichtbare Bereich: a(-400|-300) b(-400|300) c(400|300) d(400|-300)

Zur besseren Anschaulichkeit kann man's sich auch einfach mal flott auf ein Blatt Papier aufzeichnen. Das hilft!

Verschiebt sich der Spieler vom Ursprung weg, so verschiebt sich mit ihm die Kamera.

Dann berechnest du also die neuen Koordinaten für deinen Bildausschnitt wie folgt:

a(Spieler.x - Bild.Breite / 2 | Spieler.y - Bild.Höhe / 2)
b(Spieler.x - Bild.Breite / 2 | Spieler.y + Bild.Höhe / 2)
c(Spieler.x + Bild.Breite / 2 | Spieler.y + Bild.Höhe / 2)
d(Spieler.x + Bild.Breite / 2 | Spieler.y - Bild.Höhe / 2)

Beispiel: Spieler bewegt sich zur Position (100|100), dann lautet der neue Bildausschnitt...

a(-300|-200) b(-300|500) c(500|500) d(500|-200)


So, vielleicht konnt ich's ja noch mal ein klein wenig verdeutlichen / ergänzen.

Gruß
SaRu_