Einstieg in die Grafikprogrammierung

[neustadt]

hallo,

ich bin jemand der vor seiner bachelorarbeit in medieninformatik (FH) steht. mein erster anlauf ein thema zu finden war nicht wirklich erfolgreich. hatte mit deduplikation zu tun und ich habe recht schnell gemerkt, dass es schwierig für mich werden wird motiviert zu bleiben.
ich bin jetzt auf der suche nach einem neuen thema und ich würde gern etwas im 3d grafikbereich machen. leider fehlen mir hier recht stark die grundlagen. gleichzeitig werde ich die nächsten 4 monate auf einem kreuzfahrtschiff arbeiten wo ich nach der arbeit recht viel zeit für mich haben werde. deshalb will ich die zeit zu nutzen und mich mit grafikprogrammierung auseinandersetzten. im optimalfall werde ich in dieser zeit ein passendes thema finden und anfangen an der ba zu schreiben.
als einstiegsprojekt, dass evt. potential zu einer ba hätte, dachte ich daran einen simplen 3d renderer (ohne belichtung/physik/shader) zu bauen.
jetzt bin ich auf der suche nach passender literatur zur grafikprogrammierung. einmal bräuchte ich wohl etwas für die theorie/mathematik, das mir den hintergrund zu dingen wie verschiedenen AA/AF methoden, sampling varianten und anderen grafik(shading)algorithmen erklärt. und dann bräuchte ich etwas, dass mir parktisches programmieren beibringt. dabei habe ich mich noch nicht festgelegt ob ich openGL, oder eine der openGL varianten wie ES oder web, verwenden will, oder directx.
es gibt zwar viele onlinetutorials zu diesem thema und ich arbeite mich gerade durch http://www.opengl-tutorial.org/ durch, aber ich finde bücher im allgemeinen ausführlicher und praktischer (im sinne von drin rumblättern). dann wäre ein c++ sicher auch förderlich, da ich bis jetzt hauptsächlich in java geschrieben habe. ich habe ein wenig recherchiert (auch hier im forum) und habe folgendes gefunden:

grafik: Introduction to 3D Game Programming with DirectX 10 (http://www.amazon.de/Introduction-Programming-DirectX-Wordware-Graphics/dp/1598220535/ref=sr_1_1?ie=UTF8&qid=1310125645&sr=8-1), Game Engine Architecture (http://www.amazon.co.uk/Game-Engine-Architecture-Jason-Gregory/dp/1568814135/ref=pd_cp_b_2/277-9799808-4296651) und Real-time Rendering (http://www.amazon.de/Real-time-Rendering-Tomas-Akenine-M%C3%B6ller/dp/1568814240/ref=sr_1_1?ie=UTF8&qid=1352297415&sr=8-1). das Game Engine buch ist aber glaube ich etwas zu fortschrittlich für mich.
c++: alles aus diesem thread (http://www.forum-3dcenter.org/vbulletin/showthread.php?t=534941) und C++ for Game Programmers (http://www.amazon.co.uk/Programmers-Charles-River-Media-Development/dp/1584504528/ref=cm_cr_pr_product_top), C++ for Java Programmers (http://www.amazon.de/Java-Programmers-Mark-Allen-Weiss/dp/013919424X) und The C++ Programming Language (http://www.amazon.de/The-Programming-Language-Library-Tutorial/dp/0201889544). hier tendiere ich zu accelerated c++.

und nun die fragen:
was könnt ihr mir noch empfehlen, gerade in bezug auf openGL programmierung? macht es sinn wert auf openGL 3.3 zu legen um aktuelle techniken zu lernen oder sind die unterschiede nicht so groß? (müsste mir dann neuen laptop zulegen)
was haltet ihr von den openGL diveraten? wie steht ihr zu openGL vs directX?
was haltet ihr vom renderer projekt - zu aufwendig als einstieg? (wie lange würde jemand wie ich ohne grafikerfahrung brauchen um einen solchen renderer zu schreiben?) ist ein renderer ohne beleuchtung langweilig? d.h. lieber renderer weglassen und gleich mit beleuchtung/shadern befassen?

jeglicher input ist willkommen, schreibt was euch in den kopf kommt.
thx

[Coda]

C++ und 3D-Programmierung in 4 Monaten? Unmöglich.

[neustadt]

ist das auf meinen renderer oder die ba bezogen? mir ist natürlich klar, dass meine ba keine technologischen bäume ausreißen wird. da mein mich begleitender prof, aber selbst auch keine tiefen kenntnisse von 3d programmierung hat sollte das zumindest notentechnisch keine großen auswirkungen haben. auf der anderen seite ist es natürlich ungünstig bei fragen. das problem ist dass wir halt keinen prof in diesem bereich haben.

ich wollte das ganze in c++ angehen, da es ja der standard ist. aber ich würde es mir damit natürlich nicht leicht machen. das stimmt schon.

was ist denn davon zu halten das ganze in JOGL (http://de.wikipedia.org/wiki/JOGL) oder LWJGL (http://de.wikipedia.org/wiki/Lightweight_Java_Game_Library) anzugehen?

[Coda]

Ich würde dann wirklich JOGL und Immediate Mode empfehlen (glBegin()/glVertex()/glEnd() etc.). Ist zwar absolut nicht der effizienteste Weg, aber es ist viel verständlicher als die modernen High-Performance-APIs.

Bis du mit Direct3D 10/11 überhaupt was rendern kannst brauchst du einen Berg an Wissen.

[PatkIllA]

Ich hab für meine Diplomarbeit in C# und XNA programmiert und hatte in wenigen Wochen schon was auf dem Schirm und meine ersten PixelShader programmiert.
Ich hatte ganz früher mal ein paar minimale Dinge in OpenGL und Jave fürs Studium, aber das wars schon.
Ein wesentlicher Grund für C# war aber, dass das auf dem System einer Firma aufsetzte, dass ebenfalls in C# programmiert war.

[minos5000]

ich habe vor einiger Zeit mal dieses Tutorial durchgemacht

http://www.directxtutorial.com/default.aspx

Vermittel IMO in sehr kurzer Zeit einen ganz guten Überblick.

[Monger]

In meinem Studium war eine Studienarbeit, einen kleinen Renderer zu basteln und das Modell unserer Hochschule zu basteln. Das Modell war unfertig, das Beleuchtungsmodell ziemlich simpel, und es waren daran glaub vier Leute beteiligt, aber das waren auch nur vier Monate.

Du solltest dir natürlich bewusst sein, was du in so einer Zeit tun kannst und was nicht. Auf jeden Fall nicht alles. Je mehr du auf bereits existierendem Wissen aufbaust, desto tiefer kannst du dich an anderer Stelle reinknien.
Wenn es dir z.B. um die Content Pipeline geht, dann besorg dir irgendeine kleine Engine in die du das Zeug reinwuchten und darstellen kannst, und kümmer dich nur um den Weg dorthin. Wenn du selbst eine kleine Render Engine schreiben willst, klau dir irgendwoher ein paar Dummy Objekte, und komm bloß nicht auf die Idee die selber bauen zu wollen.

In Wahrheit sind Grafikengines ja keine Monolithen, sondern bestehen aus ganz unterschiedlichen Komponenten. Konzentrier dich auf ein oder zwei davon, und verzettel dich nicht in Kleinigkeiten. Gilt übrigens für alle Software jenseits von "Hallo Welt".

[neustadt]

Mein problem ist, dass ich noch nicht genau weiß was ich machen will. Der renderer war eine erste Idee, aber soetwas scheint ja doch aufwändiger als gedacht. Objekte wollte ich selbst nicht erstellen. Auch den .obj fileloader wollte ich wenn möglich nicht selbst schreiben. Ich wollte mich hier auf die Darstellung und Orientierung im raum beschränken.

Aber gut ich werde erstmal einige jogl tutorials durchgehen und schauen ob das ein paar neue Anregungen gibt.

@ PatkIllA kannst du mir sagen woran du gearbeitet hast? Wird wohl etwas spezifisches gewesen sein, wenn du deine Diplomarbeit extern verfasst hast. Aber vltt ist es ja doch für eine Inspiration gut.

Vllt nochmal zum Thema Bücher. Ich denke ob nun direkt opengl oder jogl sollte für die Algorithmen keine Rolle spielen. Dann sollte das realtime rendering Buch doch etwas für mich sein oder? Das ist vom Inhalt ja eher breit gefächert.
Das Thema opengl 2.1 Vs 3.3 hat sich mit jogl dann auch erledigt. Ich denke alles was ich angehen werde ist mit 2.1 zu schaffen. Oder beschränke ich mich da zu sehr was shader angeht.
Wenn jemand eine Empfehlung zu einem jogl Buch hat, wäre das natürlich auch schön die zu hören.

Ich bin übers Wochenende nicht zu Hause, werde mich als nicht viel weiterbilden können, aber ich melde mich dann wenn ich wieder zurück bin.

[Gast]

Wenn du es mit JOGL angehst, dann wirf einen Blick auf die jMonkeyEngine (http://jmonkeyengine.com/), darin dürfest du nützliche Tools finden.

[PatkIllA]

@ PatkIllA kannst du mir sagen woran du gearbeitet hast? Wird wohl etwas spezifisches gewesen sein, wenn du deine Diplomarbeit extern verfasst hast. Aber vltt ist es ja doch für eine Inspiration gut.Ich hab damit Pläne von Gas/Strom/Wassernetzen visualisiert.

[neustadt]

@Gast Ja das scheint mächtig zu sein. Ist aber wohl eher was für später wenn ich mit den Basics weiter bin.

@PatkIllA Hm vllt etwas für einen komplexen Simcity-Clone :)

Ich habe mich inzwischen etwas weiter durch opengl-tutorial.org gearbeitet (mittels JOGL) und habe auch einen kleinen Fehler in einem Beispiel entdeckt und berichtet. (Die Korrektur war schon vorhanden, aber noch nicht gepostet.) Jedenfalls komme ich bis jetzt recht gut mit openGL3.3 / VAO / Matrizen /etc zurecht. Jetzt stehe ich aber vor dem Dilemma, dass ich mich in den 2,3 Tagen für ein Buch entscheiden muss, das ich an Bord nehme. Und so wie ich das mitbekomme gibt es kein gescheites >=openGL3.1 Buch, das für einen Anfänger geeignet ist. Was wohl auch daran liegt, dass durch die freiere Programmierung von >=openGL3.1 die vorhanden Hilfsmittel wegfallen und die Programmierung deutlich komplexer wird. Coda meinte ja schon ich soll das am besten gleich lassen und mich auf Immediate-Mode beschränken. Aber irgendwie fällt mir diese Entscheidung nicht leicht, eine veraltete Technik zu lernen. Klar gehen online Tutorials nicht zu sehr in die Tiefe (bzw. bin ich nicht so weit gekommen), so dass ich noch nicht mit diesen komplexen Techniken zu tun hatte. Von daher kann ich nicht abschätzen was noch auf mich zukommen wird. Aber würde ich dadurch nicht eine Menge Zeit verschwenden? Ist das Wissen was ich mir durch fixed function Programmierung beibringe noch für modernes openGL zu gebrauchen? Viele Dinge müssen da ja von Hand selbst geschrieben werden, die vorher per API-Aufruf zur Verfügung standen. Außerdem braucht man deutlich mehr Shader Wissen. Oder lohnt es sich, weil die alten Bücher wie OpenGL SuperBible 4th Ed die Grundlagen deutlich besser vermitteln und weil modernes openGL einfach zu Komplex ist um da direkt einzusteigen? Wie steht ihr dazu? Habt ihr vllt die neuen Editionen der openGL Standardwerke gelesen und könnt hierzu eure Meinung äußern?
Ich poste hier mal zwei interessante, gegensätzliche Meinungen von amazon.com zur SuperBible.

The 4th edition is better, this one will soon be forgotten. February 26, 2011 By Zenja Solaja

I've learned OpenGL thanks to Richards books (the 2nd and 4th editions of the SuperBible), and today work as a professional 3D game engine programmer. Those books are very educational, and allow a newcomer to learn OpenGL faster than any other OpenGL programming book I've found. The 5th edition focuses on the new "core" OpenGL profile, which has deprecated the legacy "fixed function" API. The authors admit that they had a difficult task when rewriting the SuperBible - how do they lower the barrier of entry to a new API which is not beginner friendly? Their solution was to create a new OpenGL toolkit which simplifies access to core OpenGL. And this is the biggest issue with the 5th edition of the SuperBible - the book explains their custom toolkit, and not OpenGL itself. What a disappointment for someone wanting to learn modern OpenGL.

My recommendation for new comers to OpenGL and 3D programming: get the 4th edition of the SuperBible, and then grab the OpenGL ES 2.0 Programming Guide to learn about the "core" OpenGL profile. With OpenGL ES 2.0 (embedded systems), the Khronnos group have removed all the legacy accessors from OpenGL, and left only the bare minimal needed to create 3D applications using programmable shaders. The Khronnos group did such a good job with ES 2.0, that they decided to remove all legacy code from core OpenGL as well, and today (with the exception of geometry shaders), OpenGL ES2.0 and OpenGL 4.1 are essentially the same API. The ES2.0 programming guide also explains modern 3D graphics hardware design better than any other book I've discovered, and more importantly, it not only explains how to access the hardware using the new API, it explains WHY the API evolved to what it is today. Why is there a limit to number of attributes? What are the benefits of packing attributes? How to pack them? etc. All of this is covered in the ES 2.0 book. Richard Wright's SuperBible ignores them. The WHY is more important than the HOW.

Hopefully, Richard will correct his mistake with the 5th edition, and a rewritten 6th edition will be something magnificant.


Excellent tutorial and reference, September 7, 2010 By Firas Assaad

This review is from: OpenGL SuperBible: Comprehensive Tutorial and Reference (5th Edition) (Paperback)
For years, books in the OpenGL SuperBible series were recommended for anyone looking for an excellent tutorial and thorough coverage of OpenGL features. But up to OpenGL 2.0, programming in OpenGL was done through the fixed function pipeline, and the OpenGL SuperBible books were the best place to start learning that. With GLSL introduced in OpenGL 2.0, OpenGL supported both the traditional fixed function pipeline and a new programmable pipeline where you can write your own shader programs and have much more control over the graphic card. OpenGL 2.0 tried to have the best of both worlds: if you liked the old OpenGL then you can use it, and if you wanted to experiment with modern OpenGL you can use that as well. That resulted in a huge API with conflicting design goals. This conflict can be seen in the OpenGL(R) SuperBible: Comprehensive Tutorial and Reference (4th Edition), reflecting the version of OpenGL it covered. The tutorial part focused exclusively on fixed-function OpenGL. That part was excellent and I still use it as a reference when I'm programming for old mobile devices that supported only OpenGL ES 1.0. The book also introduced shaders among other advanced topics in the second part. This introduction didn't really follow from what you learned in the tutorial part. It was a group of separate articles that were written in a different style and tone. I don't doubt you can easily pick it up and learn writing shaders from these chapters, but they didn't really go about teaching you how to write shaders, instead focusing more on showing you cool examples of stuff you can do with shaders. Given that a lot of what you do with shaders requires a mathematical background -- which the 4th edition got around by introducing only what's necessary, someone learning OpenGL without such a background would get confused when suddenly the later chapters are talking about cosines and other concepts.

Eventually, the OpenGL API evolved and the fixed function commands were all deprecated and later moved to a different profile. The new OpenGL was much leaner and only revolves about creating shaders and writing to buffers. The problem is that it's easy to teach the old OpenGL, you don't need to know the underlying details of how light is calculated or how transformations are performed to write a program in fixed function OpenGL. You can get away without teaching anything but basic mathematics, and you could still come up with strong examples. With modern OpenGL, things are different. There is no built in lighting equation, no matrix stack, no functions to rotate an object or set a camera. You have to write all of that yourself. A book teaching modern OpenGL, or the core profile of OpenGL 3.3, needs to teach you not only OpenGL, but also the fundamentals of 3D graphics. Such a book would be quite big, advanced for many users, and wouldn't be able to cover all the features of OpenGL. How can you create a simple and thorough book about modern OpenGL? If you can assume that the reader knows the fixed function pipeline, then it's easier to teach them the new features. But what if you can't assume that?

The authors of OpenGL SuperBible 5 found a way around, and it works quite well. The authors built a library that allows people to start writing impressive programs right away. They don't have to worry about setting up vertex buffer objects, writing shaders, or any of that. This way you can start teaching by giving practical examples, and you slowly teach OpenGL by introducing the concepts behind that library. Make no mistake, this book doesn't teach you to use that specific library, it teaches you OpenGL. Anything you do with the library you will learn to do yourself in OpenGL in later chapters. Shaders are introduced early and follow wonderfully from previous discussion. Many advanced features are covered in detail and you learn how to write shaders, and not just how to copy and paste example code. The result is fantastic; the tutorial part is by far the best introduction to modern OpenGL you'll find. You still don't need a mathematical background, and the 3D math chapter does a good job of introducing all the ingredients you will need to write programs.

The book is divided into 3 parts. The first part is an introduction and tutorial, the second part is about advanced topics such as buffers and dealing with geometry, and the final part is about platform specific issues including a coverage of OpenGL ES for mobile devices. The tutorial part is great and if the book constituted only of this part, it'd definitely be worth buying. The advanced topic coverage is really variable. Some topics are covered in great detail and with useful examples (I really liked the introduction to the geometry shader for example), other topics are introduced in a hurry and just throw examples at you without even explaining what the example is supposed to do or teach. I'm not sure if this is really a bad thing. You need to realize that some of these advanced topics are actually quite advanced, and the book doesn't assume much from the reader. Including them in the book is a benefit because once you've learned more from other sources or from your own experiments you can go back to these chapters and understand them better. None of these chapters is bad, they just don't follow from what you learned from the tutorial part. For example, the basic idea of multisampling is introduced early, which is good for an example where you just enable multisampling and see the result. Later chapters go into the fine details of how multisampling is implemented, based on the basic introduction. If you already understand multisampling then it'd all make sense, but if your only source is the book then it can be hard to follow. Another example is the chapter which introduces buffers, the sample program tries to 'look cool' where a simpler (and uglier) sample would have been more appropriate.

Speaking of the sample programs, the code is generally well written and properly commented. Going through the source code for the book library is a great way to learn. Most of the samples compiled fine on Linux (using the binary Nvidia driver), but some gave me black screens or wrong results. I also had to make some changes to the code to make certain samples work. A few samples don't even come with makefiles for Linux. I sent an email about it to the author and it'll hopefully get fixed eventually. The google code repository where the samples are hosted does get updated so I wouldn't worry much about that.

Summary: if you want to learn modern OpenGL (post 3.0), then get the book. Even if you already have the 4th edition and know a bit about shaders and buffers, you will still benefit from the book because it covers many more advanced topics and I'm sure there will be a thing or two you didn't know about. While I spent some time talking about perceived problems like complex advanced chapters or few samples that don't work, I assure you that it's not as bad as I make it sound. I just thought it was fair to note these minor issues in case there was a 6th edition for OpenGL 5.0! I was worried about two things when I considered getting the 5th edition: (1) I already have the 4th edition so is this an incremental update or something completely new? And (2) if the book uses a library to hide some of the advanced features then does it spend a lot of time on that as opposed to teaching real OpenGL? The answer to the first question is that it's a completely new book that is exclusively about OpenGL 3.3. The answer to the second question is, like I said earlier, that the book library is there for a purpose, which is ultimately teaching you how to do things with nothing but OpenGL. I apologize for writing so much, I never wrote a book review before. :)

Shorter summary: buy the book!

[neustadt]

Keine Meinungen?

[Elemental]

Sehr schnell zu relativ guten Ergebnissen kommt man auch mit WPF3D. Ist allerdings wohl ein "totes Pferd"...

[moBi]

http://www.rastertek.com/tutindex.html

IMHO auch nicht schlecht, falls man sich gern durch CODE durchwühlt.

[neustadt]

@Elemental: Danke für den Hinweis, aber ich denke ich habe mich inzwischen auf openGL eingeschossen.

@moBi: Gute Beispiele sind manchmal Gold wert. Nehme ich gerne in meine Bookmarkliste auf.

[Nasenbaer]

Also ich habe OpenGL 3.1 mit dem Buch "Beginning OpenGL Game Programming Second Edition" gelernt (Amazon Link unten). Das ist sehr gut geschrieben und hatte überhaupt erst gelernt mit Vertex Buffern, Shadern usw. umzugehen (davor kann ich auch nur den Immediate Mode). Mit Game Programming ist in dem Buch fast gar nichts, weswegen man da keine Angst haben sollte, dass ale Themen nur angeschnitten werden. Das Buch ist zu über 90% eine Einführung in OpenGL bis 3.1 (mit einem kurzen Einstieg über den OpenGL Immediate Mode).
Ich hoffe der Tipp kommt nicht zu spät. Als allgemeiner Tipp für die Arbeit: Keinesfalls den schriftlichen Teil unterschätzen, das Schreiben nimmt einiges an Zeit in Anspruch.

http://www.amazon.de/Beginning-Opengl-Game-Programming-Benstead/dp/159863528X/ref=sr_1_2?ie=UTF8&qid=1354826519&sr=8-2