Wo Aufsetzen bei Grafikprogrammierung

Balu Jr.

Vorgeschichte:
Also ich habe angefangen mich für Grafikprogrammierung zu interressieren, da ich vor habe nochmal ein kleines Spiel zu programmieren.
Früher hatte ich das immer ganz einfach mit den Methoden der Schule machen können: Ganz am Anfang bei "MSLogo" ist die Grafikschnittstelle quasi fest integriert gewesen. Beim Delphi, wie wir es in der Oberstufe gelernt haben, hatten wir die typische Lehrbibliothek. Die hatte die Grafik stark abstrahiert fest mit integriert. (Ich sage nur "hatstift.zeichneKreis(x)").
Abgesehen davon ,das jene Grafikschnittstellen viel zu "primitiv" für ein spielbares gutes Spiel waren und z.B. nichteinmal Double Buffer kannten. (*Flimmer*)
Nun möchte ich von soetwas unabhängig loslegen.
Ich werde nur immer verwirrter, je länger ich mich mit dem Thema auseinander setze. Totaler "Information Overflow"!.

Problem:
[url]Wo soll ich aufsetzen und was für einzelne Libs brauche ich wiederum.[/url]
Zunächst hab ich Allegro, SML und ähnliches ins Auge gefasst.
Die bauen aber ja auch schon auf etwas (OpenGL) auf.
Und was hat die WindowsAPI damit zu tuen?
Dann entschied ich mich doch für DirectX bzw. jetzt aktuell OpenGL. (das Spiel hat ja auch Lehrzwecke.)
Doch im bekannten NeHe-OpenGL-Tutorial wird neben der GL-Bibliothek auch noch eine Glu- und Glaux-bibliothek verwendet, wovon ich die letztere noch nicht standardmäßig aufdem Rechner habe. Erstere aber schon. Beim Texturen-Tutorial fehlen mir da erst jetzt Funktionen.
Und was ist dann GLUT .

Eine kleine Richtungsangabe würde ja schon helfen.

Gruß Balu.

Kóyaánasqatsi

Balu Jr. schrieb:

Doch im bekannten NeHe-OpenGL-Tutorial wird neben der GL-Bibliothek auch noch eine Glu- und Glaux-bibliothek verwendet, wovon ich die letztere noch nicht standardmäßig aufdem Rechner habe. Erstere aber schon. Beim Texturen-Tutorial fehlen mir da erst jetzt Funktionen.
Und was ist dann GLUT .

Mit der GLUT kannst du beispielsweise Kugeln in OpenGL zeichnen. Die GLAUX beinhaltet auxDIBImageLoad(), womit man die Bitmaps laden kann. Die ist aber schon ziemlich alt und wird nicht mehr empfohlen, ich persönlich lade sie immer selber.

Balu Jr.

Danke schonmal.
Also kann ich mir die Bibliothek schonmal sparen!?
Dis ist dann nur noch ein Zusatz zur Vereinfachung!?

socco

scheinbar haben alle Anfänger so ziehmlich das gleiche Problem
Hallo erstmal,
erstmal solltest du dich entscheiden ob du nur Programme für Windows oder Systemunabhängig schreiben willst.
Das sollte nähmlich entscheiden ob du die DirectX Bibliothek oder die OpenGL Bibliothek nimmst.
Windows -> DirectX (meine Empfehlung - kein muss)
Systemunabhängig -> (OpenGL - ein muss da DirectX nur Windows unterstützt)

Die Windows Api verwendet man bei Graphikanwendungen nur um ein Fenster zu erzeugen indas du dann mithilfe der oben gennanten APIs reinzeichnest.

Falls du mit OpenGL weitermachen willst empfehle ich dir die Offizielle Seite zu besuchen da dort viele aktuelle Informationen zu finden sind. (Besonders weil sich dort in letzter Zeit (angeblich) viel getan hat.)

Versuch erstal mit beiden APIs ein Dreieck darzustellen und schau dann welche der APIs dir von der Struktur her mehr zusagt.

Oh das wichtigste hab ich ja glatt vergessen: meiner Meinung ist es sehr zu empfehlen die ganze Sache mit C++ im Hinterkopf anzugehen da sowohl DirictX als auch OpenGL und die WinApi und ich glaube auch die anderen Apis in den C Sprachen gehalten wurden.

Gruß.

Kóyaánasqatsi

Balu Jr. schrieb:

Danke schonmal.
Also kann ich mir die Bibliothek schonmal sparen!?
Dis ist dann nur noch ein Zusatz zur Vereinfachung!?

Welche meinst du denn? Wenn du deine Primitiven selber zeichnest und deine Texturen selber decodierst, brauchst du gar keine von beiden. Und ja, beide sind zur Vereinfachung.

Xebov

Du solltest dir überlegen was du machen willst. Die WinAPI ist Grundsätzlich erstmal nur fürs Fenster da ind em gezeichnet wird, bringt abe rnoch einige nette Funktionen mit (zB INIs auslesen).

Und hier stellst sich die Frage was es sein soll, willst du Plattformunabhängig sein oder an Windows gebunden. Willst du eine Engine selbst machen, oder willst du nur Spiele machen, darüber musst du dir erstmal im Klaren sein.

Plattformunabhängigkeit bedeutet OpenGL, wenn du eh nur für Windows entwickeln willst kannst du auch DirectX nehmen (wobei du dich heir entscheiden musst welche Version, da 9 und 19/11 sich unterscheiden vom Aufbau). Für beide Varianten gibt es gute Büche rund genug Infos im Netz.

Möchtest du selbst eine Engine bauen, dann geht deine Reise dort los, willst du aber nur ein Spiel amchen dann kanst du auch ein Framework oder eine bestehende Engine benutzen auf die du dann Aufbaust, auch heir gibts genug Material im Netz.

Wenn du dir darüber im Klaren bist kann man dir denke ich auch besser weiterhelfen.

Balu Jr.

1. Ich möchte Plattformunabhängig programmieren.
2. Bei allem was ich die letzten Wochen gelesen habe ist eine eigene Engine für den Hobbieprogrammierer der Supergau und ncht geeignet. Der Aufwand steht in keiner Relation zu irgendeinem privaten Ziel.
3. Ich möchte so tief wie möglich ansetzen um alles was darüber ist (z.B. SDL über OpenGL) grundlegend zu verstehen. Also auch wie z.B. die Funktionen von SDL herkommen.

Ich arbeite gerade die NeHe-Tutorials durch und stelle fest,dass die Funktionen von OpenGL eigentlich auch schon ganz komfortabel sind. Da ist ja schon vieles grundlegend mit drin!!! (Lichtberechnung, Blending und und und )
Danke schonmal für die Hilfen,

der jungfräuliche Balu

mad_martin

2D oder 3D?
Wenn 2D (meine Empfehlung am Anfang!), dann hängt die Bibliothek von der gewünschten Sprache ab.
Sollte es C sein: SDL
Sollte es C++ sein: SFML

Bei beiden kannst du dir den Quellcode ansehen, um rauszufinden, wie es funktioniert. Dabei helfen bei SFML leichte OpenGL-Kenntnisse, da intern damit gearbeitet wird. Was SDL nutzt, weiß ich grad nicht.

Wenn es 3D sein soll: Die NeHe-Tutorials hast du ja schon gefunden. Wenn es dir eher auf das Verständnis ankommt, bleib dabei. Wenn du schnell was auf den Bildschirm bekommen willst, hilft eine Engine. So z.B. Ogre3D oder IrrLicht. Beide abstrahieren den OpenGL-Kram und helfen dir, deine Models schnell auf den Bildschirm zu bringen.

Kommt halt alles darauf an, wie du weiter vorgehen möchtest.

TGGC

Ich wuerde fuer einen Anfaenger im HGE empfehlen. Habe auch irgendwo mal einen Vergleich von ein paar Sachen geschrieben. Aber durch deine (IMHO unnoetigen) Einschraenkungen faellt das wohl ehh weg fuer dich. f'`8k

Autocogito

Gruß, TGGC (Was Gamestar sagt...)

Balu Jr.

Danke,

eigentlich hatte ich fürs erste ein interressantes 2D-Spiel gedacht.
Doch wenn ich nun allein mit openGL arbeite merke ich so langsam,dann ist 2D fast nicht einfacher als 3D, da mann dann in einem 3D-Raum einfach nur die zKoordinatenachse konstant hällt.(Im Grunde bleibt es aber eh 3D) Vereinfachungen gibt es keine.

Balu Jr. schrieb:

Danke,

eigentlich hatte ich fürs erste ein interressantes 2D-Spiel gedacht.
Doch wenn ich nun allein mit openGL arbeite merke ich so langsam,dann ist 2D fast nicht einfacher als 3D, da mann dann in einem 3D-Raum einfach nur die zKoordinatenachse konstant hällt.(Im Grunde bleibt es aber eh 3D) Vereinfachungen gibt es keine.

Das stimmt nicht. Vllt solltest Du einfach eine Orthographisce Ansicht erstellen anstelle einer perspektivischen mittel gluOrtho().
Und ich empfehle Dir für OpenGL SDL zu verwenden fürs Fenstermanagement. Deutlich angenehmer. SFML ist ganz nett, ich benutz es aber nicht weil das anscheinend ein Memory Leak hat.. zumindest hat das blosse erstellen eines Fensters (Nein, kein Zeiger) bei Visual Studio viele Alarmglocken nach dem beenden geläutet.

Markante Stelle zu gluOrtho aus meinem Code:

void NLWindowGL::initGL2D(int w, int h)
{
    // Set Viewport
    glViewport(0, 0, w, h);

    // Set OpenGL-Options
    glClearDepth(1.0f);
    glDepthFunc(GL_LESS);
    glEnable(GL_DEPTH_TEST);
    glDepthMask(TRUE);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);

    // Reset Projection-Matrix
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    // Set Viewmode
    // OpenGL-Specific: glOrtho(0, w, 0, h, -100.0f, 100.0f);
    /*Windows-Mode: */ glOrtho(0, w, h, 0, -100.0f, 100.0f);

    // Reset Modelview-Matrix and leave it.
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

}

rya.

TGGC

Scorcher24 schrieb:

Balu Jr. schrieb:

Danke,

eigentlich hatte ich fürs erste ein interressantes 2D-Spiel gedacht.
Doch wenn ich nun allein mit openGL arbeite merke ich so langsam,dann ist 2D fast nicht einfacher als 3D, da mann dann in einem 3D-Raum einfach nur die zKoordinatenachse konstant hällt.(Im Grunde bleibt es aber eh 3D) Vereinfachungen gibt es keine.

Das stimmt nicht. Vllt solltest Du einfach eine Orthographisce Ansicht erstellen anstelle einer perspektivischen mittel gluOrtho().

Deswegen verhaelt sich der Rest immer noch genauso wie OpenGL bei 3D Anwendungen. f'`8k

Autocogito

Gruß, TGGC (Was Gamestar sagt...)