Hallo, ich bin neu hier, habe vor ca einem Jahr mit dem Prgrammieren angefangen und vor einem halben OpenGL entdeckt.
Bin grade dabei, ein 3d-Spiel in C++ unter Verwendung von glut (auf Ubuntu Linux) zu schreiben und ich habe 2 Probleme mit Schleifen.

1. Problem: Wenn ich in dem Programmteil, der angibt, was gezeichnet werden soll (void Drawscene...) eine Verschachtelung von mehr als als 3 Schleifen verwende
(z.b. for(i.. for(j... for(k... for(l... ) dann stürzt die Anwedung immer zu Beginn ab (ohne Fehlermeldung). Und zwar ist das unabhängig von der Größe der Schleifen.
Sagen wir mal in der innersten Schleife stünde eine Anweisung: Dann stürtzt eine vierfach verschachtelte Schleife mit 4 hoch 4=256 Anweisung ab, obwohl eine 2 fach verschachtelte Schleife, die das selbe tut nicht abstürtzt, selbst wenn es dort mehrere Millionen Anweisungen wären.
Ich vermute, dass es an OpenGl liegt, weil ich mich an ein Konsolenspiel erinnern kann, dass ich geschrieben hab, wo solche Verschachtelungen vorkamen.

Als Lösung hab ich mir gedacht eine 2 fach verschachtelte Schleife zu nehmen und durch Verzweigungen alle Indizes so lange zurückzusetzen bis sie ihren Zielwert erreicht haben. Aber zehrt das nicht an der Leistung? (Wieviel kostst eig. ein if?)

2.Problem:
Ich wollte mir recht große Oberflächen(ca 1 Mio Polygone) in eine Displayliste laden, aber wenn ich mittels Schleife die Vertices an die Liste übergeben möchte, klappt es nicht.

Geht das mit Vertexarrays? Oder gleich VBOs verwenden? Mit beidem kenne ich mich nicht aus, ich befürchte auch, dass mir für VBOs noch die Programmierkenntnisse fehlen. Ich verwende eig nur Arrays, Variable, typ def stuct und Mathematik.
Ich hab z.B immer noch nicht so recht verstanden, wozu ich den Sternoperator brauche, wenn ich einfach den Index eines Arrays verwenden kann...
Waäre auch Dankbar, wenn mir jemand sagen könnte, was genau ich mir programmiertechnisch anschauen sollte, um für erweiterte OpenGL-Anwendungen gewappnet zu sein.

schönen Gruß

Vinz

_________________
"Pixel, ich bin dein Vater."
-Darf Shader

Für das 1. Problem am besten mal etwas Code zeigen.

Das mit der Displaylist und 1. Mio Polygone muss eig. gehen (falls du es richtig machst) - habs auch schon mit 10 Mio. gemacht und es lief.
Du könntest natürlich mit einem VBO arbeiten aber für statische Geometrie ist eine Displaylist mehr als ausreichend und sehr einfach zu nutzen. Also vllt. machst du auch dort was falsch? Am besten auch da mal Code posten.

Erst einmal, Willkommen im DGL-Forum!

Zu deinen Problemen: Wir brauchen Code, sonst kann man nur raten. Für deine Frage mit dem "Sternchenoperator", mach mal einen neuen Thread auf (im Forum Allgemein). Mehrere Themen im selben Thread zu diskutieren ist nicht schön.

Ja, ich denke auch das du in den Fällen 1 und 2 irgendwas falsch machst. Ohne Code können wir nur rumraten.


Der Stern-Operator in C++ ist äquivalent zu einem Zugriff auf Index 0, also [0]. Diesen verwendet man üblicherweise dann wenn es sich nicht um ein Array handelt, sondern nur um ein einzelnes Element. In manchen Fällen macht es auch Sinn den Pointer direkt zu inkrementieren statt einen Array-Index zu verwenden. Letztlich ist das nur eine andere Schreibweise, genau wie der "pointer->element" Operator im wesentlichen "(*pointer).element" entspricht. Wichtig wird die ganze Sache wenn man anfängt Operatoren zu überladen, gerade den Index-Operator überschreibt man gerne.


Objekt-Orientierung ist das Kernfeature von C++, was es auch von purem C abgrenzt. Insbesondere bei größeren Projekten macht dir das die Sache deutlich einfacher. Natürlich solltest du dir auch die STL anschauen, die Standard-Bibliothek von C++. Insbesondere die Container-Datentypen und Algorithmen machen dir das Leben leichter. Gilt übrigens nicht nur für OpenGL, sondern allgemein.

Für OpenGL im speziellen: Schau dir VBOs und Shader an.

_________________
Yeah!

Hi Leute,
Danke für die raschen Antworten, tolles Forum!

Das mit der Displayliste (2.) war falscher Alarm, hab jetzt mein Terrain in ne Liste geladen, und kann jetzt ca 10 mal so viele Polygone ruckelfrei verwenden

Zu 1.: Ich weiss jetzt woran es liegt, und zwar: Die Initialisierung und die Schrittweite der inneren Schleifen hängen vom Index der äusseren Schleifen ab, was auch so gewollt ist, aber das mag er nicht. Warum?

also z.B for(i=1;i<10;i++;) {for( j=-X0+i*X0;j<X0+i*X0;j+=i){...stürtzt ab.

Hab rumprobiert, und es reicht, wenn die Schrittlänge oder Startwert oder Endwert von einem übergeordneten Schleifenindex abhängen, um ihn zum Absturtz zu bringen, auch mit while-Schleifen das selbe.

Ist jetzt eig nicht OpenGL-spezifisch, wusst ich aber vorher nicht, also sorry.

Gibts da ne Standardlösung für das Problem, bevor ich jetzt ein Verzweigungsviech bau, dass die Indizes zurückschraubt, was dann auch abstürtzt...

Was ich noch fragen wollte:
Kann ich mit VBO auch das Terrain während dem Spiel verändern (was ja mit D-Listen nicht geht, oder?)? Und was ist schneller: VBO oder D-Liste? (im Statischen Fall)

schönen Gruß

Vinz

_________________
"Pixel, ich bin dein Vater."
-Darf Shader

Die Schleife selber ist harmlos und wird auch nicht abstürzen, es wird der code in der for Schleife sein.
In der Schleife kann nicht viel schief gehen, sie kann nur gefühlt unendlich lange laufen.
Overflow und underflow sorgen dafür, dass die schleife sofort abbricht oder extrem lange braucht.

Theoretisch ist VBO schneller, praktisch ist das von einigen Faktoren abhängig.
Displaylisten werden im Hintergrund zu VBO umgewandelt, sobald aber sich eine Liste ändert muss natürlich das vbo zerstört und ein neues erstellt werden, was lange dauert.

Die Anzahl der Vertices zu verändern, ohne über Geometryshader zu gehen, endet in Daumenkino.
Die teuersten Operationen sind Speicherzugriffe und Bus synchronisierung und genau diese dinge werden bei dem ändern der Verticecount, in einem VBO/DL, zu haufe getan.
Daher greift man da zu Geometryshadern, welche GPUseitig sind und nicht im VRAM gelagert werden, sondern temporär in Registern.

Ein weiteres Problem ist die Komplexität der calls, wenn er nicht mehr mit den vbo Formaten abbildbar ist, dann wird auch kein vbo verwendet.

Als letztes Problem von DL zu VBO kommt hinzu, dass es ein hack von den Treiberherstellern ist und nicht zwingend alle Kombinationen überall funktionieren bzw. es überhaupt passiert.

Zum Coding, pointer sind essentiell in c und opengl ist eine c api. Es ist also eine gute Idee sich mit pointern intensive auseinander zu setzen.
In C++ triffst du eher selten auf pointer, OOP und Referenz Operator ersetzen meistens Pointer.

Die Zeit, die man in das lernen von OpenGL 1.2-4 steckt ist sehr groß, da OpenGL 1.2-2 logisch völlig gegen 3-4 laufen. Verwirrung ist da 100% vorprogrammiert. Ich würde eher empfehlen auf OpenGL4 direkt zu gehen, damit man sich die Zeit spart und die meisten Karten, im Spielesektor, sind schon OpenGL4 fähig und eh man so weit ist, was raus geben zu können hat es auch der letzte Gamer.

_________________
"Wer die Freiheit aufgibt um Sicherheit zu gewinnen, der wird am Ende beides verlieren"
Benjamin Franklin

Projekte: https://github.com/tak2004

Hey TAK2004,

woher weisst Du welche Version von OpenGL ich verwende? Gibts bei OpenGL 3, 4 keine Displaylisten?
Ich weiss es nicht. Habe freelut 3 installiert, ist das dann nicht OpenGL 3?

Wie sind denn die Unterschiede zwischen den alten und neuen OpenGL Versionen?

Also die Befehle, die ich hauptsächlich verwende sind:

glPushMatrix, glPopMatrix, glRotatef, glTranslatef, glScalef, glVertex, glTexCoord,glNormals, ...TriangleStrip, Quads, Lines...

Ändert sich bei diesen elementaren Befehlen in den neuen Versionen auch was?

_________________
"Pixel, ich bin dein Vater."
-Darf Shader

Ab OpenGL 3.0 wurden Dinge wie Displaylisten, glPushMatrix, glBegin, usw. deprecated - das heißt Sie werden als veraltet makiert und demnächst entfernt.
Ab Core 3.2 waren die dann auch weg. Da werden Operation wie die Matritzen usw. über Shader geregelt.

Freelut? Du meinst wohl Freeglut.
Zum einen gibt es kein Freeglut 3 sondern höchstens 2.8.0 und Freeglut != OpenGL.
Freeglut nimmt dir Arbeit ab, um z.B. ein Fenster zu erstellen wo du rendern kannst. Man kann sich also unter Windows das ganze WinAPI Zeugs sparen.

Um z.B. "reines" OpenGL 4.0 zu nehmen, müsstest du beim Init von Freeglut folgendes nutzen:
glutInitContextVersion(4, 0);
glutInitContextProfile(GLUT_CORE_PROFILE);


Deine Befehle sind also schon veraltet und nicht mehr im neuen Standart drin aber du kannst Sie trotzdem noch nutzen. Entweder eine frühere OpenGL Version nutzen (was für Hobbyanwender eig. reichen sollte) oder eben die neue Version und Abwärtskompatible.
Klar könnte man auch alles selber machen aber für den Einstieg ist das in der Regel etwas zu viel (meine Meinung).

Oha,
ich hab leider keine Ahnung von Shadern.
Du meintest, dass auch glBegin rausgenommen wurde...Kann man dann auch nicht mehr bestimmen, ob trianglestrips, quads oder was auch immer erzeugt werden, bestimmt das dann auch der shader? kann ich mir grad schwer vorstellen.
Gibt es wenigstens noch rotate, translate und scale?

_________________
"Pixel, ich bin dein Vater."
-Darf Shader

Und wieso keine Displaylisten mehr, nur noch VBOs?

_________________
"Pixel, ich bin dein Vater."
-Darf Shader

Ich kenn leider nicht jeden Befehl, welcher entfernt wurde aber im Internet gibts eine pdf, wo eine Befehlsübersicht steht. Wier auch immer...

Also gl_Triangles, gL_Quad usw. gibt es trotzdem noch - man muss ja schon irgendwie festlegen, wie man rendert (Hoffe du verstehst).
Displaylisten sind halt nicht mehr Zeitgemäß. Du hast halt nur statische Geometrie in einer Displaylist. Ist zwar praktisch für statische Geometrie aber bei Animierten Objekten z.B. nicht wirklich zu gebrauchen. Das geht mit VBO's wesentlich besser, von daher nimmt man es gleich für allen.
Wobei es ja bei VBO's auch static_draw, dynamic_draw usw. gibt...


glTranslate, glRotate, glScale dürfte es eig. nicht mehr geben. Diese Funktionen ändern ja die Modelview Matrix, da es diese aber schlichtweg nicht mehr in der Form gibt wie im "alten" OpenGL, fallen die Befehle weg => Machs mit einem Shader


Ich würde mich deswegen nicht verrücktmachen lassen.
Ich nehme zwar in vielen Fällen Shader, aber genau so gut auch ab und an die älteren Befehle. In manchen Dingen macht es OpenGL einfach handlicher und gerade als Hobbyentwickler ist es doch egal (Außer man hat jetzt echt konkrete Ziele für eine spezielle Plattform usw. aber davon gehe ich mal nicht aus?!)

In der Quick Reference Card zu OpenGL4.1 sind alle Funktionen die rausgeflogen sind blau markiert. Wobei einige z.B. gl_ModelViewProjectionMatrix schon garnicht mehr aufgeführt werden.

_________________
Es werde Licht.
glEnable(GL_LIGHTING);
Und es ward Licht.

Zitat aus einem Java Buch: "C makes it easy to shoot yourself in the foot; C++ makes it harder, but when you do it blows your whole leg off"

on error goto next

Du kannst auch einfach keinen "speziellen" Context erstellen, hier kannste die "alten" Sachen ohne Prob nutzen und es sollte für den Einstieg einfacher sein.
Solche Sachen wie Shader und BO's, sollte man erst lernen wenn man kapiert hat wie OGL (und 3D überhaupt) so im Grunde arbeitet. Ein Beispiel:


Ist einfach Falsch....

_________________
Meine Homepage

Stimmt...

Meinst Du man sollte wissen, wie OpenGL aus den Vertices und den Matrizen die man ihm gibt, die einzelnen Pixel schafft.
Da hab ich nämlich noch nicht so den Durchblick.
Wie man die Polygone irgendwo hinkrigt ist mir aber klar, und dass die Normalen die Farbwerte entsprechen verändern usw.

Aber um seine Vektoren zu verschieben,rotieren etc muss man doch nach wie vor irgendwie mit Matrizen arbeiten, oder?
Gibts da dann vorgefertigte Funktionen oder muss man die 4x4 Matrizen jedes mal selber schreiben.
Kleines Bsp für einen GLTranslate-Ersatz wäre hilfreich.

Wofür brauche ich eig Shader zwingend? Oder ist es für komplexe Projekte bloß handlicher.
Soweit ich mitbekommen hab, ist es damit leicht, mehr Detail reinzubringen (Tesslation), was gibt es sonst noch?

_________________
"Pixel, ich bin dein Vater."
-Darf Shader