Leider hab ich in letzter Zeit nicht mehr ganz so viel zeit gehabt, wie ich es mir wünsche, aber für ein bisschen Theorie zwischendurch reichts allemal.
Nachdem ich jetzt Punkte, Linien und Kreise zeichnen kann, gehts an die Strukturen der 3D-Grafik. Klar, neben Punkten, Linien und Kreisen ist hier das Polygon das wichtigste Element. Jedes moderne Computerspiel basiert auf Polygonen.
Es ist (mal ganz nebenbei gesagt) erstaunlich, wie viel moderne Computer leisten können. Während man am Anfang der 3D-Grafik grade mal zehn bis hundert Polygone gleichzeitig und in echtzeit darstellen konnte, ist es heutzutage möglich mehrere Millionen Polygone darzustellen und überdies noch komplex auszuleuchten. Echtzeitschatten, Bumpmapping (bzw. Normalmapping) und realistische Physikinteraktionen natürlich eingeschlossen.
O.K., ich schweife ein wenig ab.
Polygone zu organisieren ist weitaus komplizierter, als man denkt. Gucken wir uns zunächst mal an, was Polygone sind, und was es für Polygone gibt:
Polygonarten
So weit, so gut…
Und jetzt gucken wir noch, woraus so ein Polygon besteht:
Bestandteile eines Polygons
Nachdem wir jetzt wissen, was ein Polygon ist, und woraus es besteht, können wir uns Gedanken darüber machen, in welche Datenstruktur wir Polygone quetschen und wie wir damit umgehen.
Aber das ist Schnee von morgen.
Also bleibt am Ball! Demnächst zeig ich dann, wie man Polygone am besten speichert.
Ist jetzt schon ein wenig länger her, das ich was gepostet habe, dafür gibts jetzt aber auch wieder ein saftiges Videotutorial über das Darstellen von Kreisen:
(Am besten wieder auf Youtube gehen und das Video in hoher Qualität angucken)
Den Quellcode poste ich ab jetzt immer bei http://pastebin.ca
Den aktuellen gibt’s also jetzt hier.
So weit, so gut. Jetzt gehts aber ganz sicher an Polygone. Versprochen.
Auch wenn ich in nächster Zeit aufgrund der Prüfungen, die noch ausstehen ein wenig weniger posten werden. Aber dann geht’s wieder rund. Versprochen.
Kleines Problem am Rande: Wenn man eine Weile im OpenGL-Fenster nichts macht, reagiert es nicht mehr. Wer weiß, woran das liegt, dem wäre ich dankbar, wenn er einen Kommentar mit Lösung hinterlassen könnte.
Sorry, dass ich an dieser Stelle nicht mehr schreibe, aber demnächst gibt’s mehr zu Vertices und Polygonen.
Sooooo, weiter gehts mit dem zweiten Teil von Bresenham.
Hier gehe ich (wie schon gesagt) darauf ein, wie man den Algorithmus für die langsam steigenden Linien so umsetzt, dass man alle Typen von Linien zeichnen kann.
Morgen gibt es dann den passenden Quelltext dazu und ein kleines Programm zum Download, das – und jetzt kommts – Linien zeichnen kann.
Vielleicht noch ein kleiner Hinweis an alle, die auch ganz am Anfang der Spieleprogrammierung stehen:
Das, was ich hier mache braucht man nicht wirklich, um Spiele zu programmieren. Das ist tiefes Hintergrundwissen. Heutzutage braucht niemand mehr einen Algorithmus zu schreiben, der eine Linie zeichnet. Das erledigt die Hardware (bzw. OpenGL oder DirectX) von sich aus. Ich mache das nur, damit ich auch verstehe, was genau da gemacht wird. Wer einfach nur ein Spiel programmieren möchte, sollte vielleicht nicht gerade damit anfangen seinen eigenen Linienalgorithmus zu schreiben.
O.K. Wie gehts denn dann hier weiter? Linien habe ich ja jetzt. Dann ist der nächste Schritt ein Kreis zu zeichnen, dann Polygone, dann gefüllte Polygone (eventuell mit Texturen) und dann endlich das große Thema 3D…
MfG, der Dac, der das mit diesem dämlichen entfesselten Blitz nicht hinkriegt…
Nachdem ich nun Punkte in allen nur denklichen 16-Bit Farben an jeder x/y-beliebigen Stelle zeichnen kann, wird es Zeit, diese Punkte zu Linien aufzureihen.
Hierfür nehme ich den gebräuchlichsten Algorithmus, der ohne Fließkommaberechnungen und Multiplikationen auskommt. Der Bresenham’sche Linienalgorithmus ist deswegen auch super schnell und vermeidet Rundungsfehler.
Wie der Algorithmus funktioniert fasse ich in zwei, drei kleinen Videos zusammen. Im ersten Teil erkläre ich die Gundlegende Funktionsweise anhand langsam steigender Linien. Im zweiten teil folgt dann die Verallgemeinerung der Funktionsweise für alle Linientypen (dazu mehr im Video). Im dritten Teil (sofern ich den noch mache) erkläre ich dann, wie man Kreise mit Bresenham zeichnet.
Hier aber zunächst der erste Teil:
Wer ein wenig mehr erkennen möchte, kann sich das Video auf Youtube auch als High-Quality-Video angucken.
Heute gibts wieder nur ein wenig Planung. Ich bin in den letzten Tagen echt ein wenig programmierfaul geworden. Und das, obwohl ich mich eigentlich auch noch um mein CMS kümmern müsste. Ich hoffe, dass ich mich in den nächsten Tagen zu mehr aufraffen kann.
Jetzt aber zu der Spielerklasse.
Da die Spielfeldklasse für die Ausgabe sorgt, muss ich diese Klasse um ein Spielerarray und einige Funktionen erweitern. Die Spielerklasse an sich stellt einerseits die Superklasse für menschliche Spieler dar und andererseits für computergesteuerte Spieler.
Die Spielerklasse
MfG, der Dac, der hoffentlich bald wieder aus der Flaute rauskommt…
Nach einem schön entspannten Wochenende hab ich mich dranngesetzt und meine Spielfeldklasse fertiggeschrieben.
Naja, wirklich fertig nicht, aber immerhin die notwendigsten Funktionen habe ich implementiert. Ich möchte ja nicht zu viel Zeit in dieses Konsolenprojekt stecken. Schließlich ist mein eigentliches Ziel die Grafikprogrammierung unter OpenGL oder DirectX. Aber bis dahin wirds wohl noch ein langer Weg.
Heute gibts leider wieder keinen Bahnbrechenden Fortschritt.
Das Wetter ist einfach zu gut, die Lust meine Zeit vor dem Rechner zu hocken dementsprechend gering.
Um nicht völlig still zu stehen gibts heute ein kleine Einführung (aber wirklich nur ganz oberflächlich und kurz) in die „STL“ und das Thema „generische Datentypen“.
was damals, als ich noch unsauber und ohne Rücksicht auf Verluste drauflosprogrammiert habe so einfach war gestaltet sich heute ein wenig schwieriger.
Es ist zum Beispiel ein immenser Aufwand die Anzahl der Elemente eines dynamisch erzeugten Arrays das auf Objektinstanzen referenziert, welche wiederrum primitive Datentypen und Zeiger enthalten zu zählen.
In Java gibt es dafür die schöne Instanzvariable „array.length“. In C++ gibt es eine etwas kompliziertere Methode, um die Anzahl eines Arrays mit primitiven Datentypen zu bekommen:
int anzahlElemente = sizeof(array) / sizeof(array[0]);
Aber dämlicherweise funktioniert das nicht mit meinem Objektarray (warum auch immer…). Es gäbe noch die Möglichkeit das Array Element für Element durchzugehen, bis das Arrayende erreicht wurde, aber das ist mir
a) zu aufwändig und
b) zu langsam.
Also werde ich mich mit der STL (Standard Template Library) auseinandersetzen. Und zwar im speziellen mit Vektorobjekten, die eine Methode „vektor.size()“ mit sich bringen. Das funktioniert dann hoffentlich. Außerdem sind Vektoren schon von sich aus dynamisch.
Leider gibt es heute deswegen auch nichts neues zum Programm (außer der obigen Erkentniss).
Zum Schluss noch ein schönes Zitat:
Für das große Chaos haben wir Computer. Die übrigen Fehler machen wir von Hand.
(Quelle: unbekannt)
MfG, der Dac, der ganz bestimmt nicht verzweifeln wird…
Ich betreibe diesen Blog, um meine Erfahrungen auf dem Weg zur Spieleprogrammierung (womit ich hauptsächlich Grafik-programmierung meine) zu dokumentieren. Alle Stolpersteine, Eventualitäten und Erkenntnisse sowie alle Ergebnisse schreibe ich hier nieder.
Verfasst von dac-xp 
Verfasst von dac-xp 
Verfasst von dac-xp 
