hi dgler,

da ich ein einsteiger in opengl programmierung bin, versuche ich mich gerade durch die ganzen tutorials zu schlagen, die ihr zusammengestellt habt. finde es klasse, das ihr euch soviel mühe gegeben habt aber teilweise gehen die tutorials nicht so tief in die materie, das alle meine fragen damit beantwortet werden..deswegen hoffe ich nun etwas klarheit zu bekommen.

also, mein plan ist es, ein spiel namens "push over" (wer es nicht kennt, kann es sich auf unserer abandonseite runterladen *schleichwerbungmach* *G* http://www.tfr.de.tp) neu aufzusetzen (mit neuen steinen, leveln etc.) und das ganze in opengl zu gestalten.
damit ihr wisst worum es geht : auf einem spielfeld stehen viele dominosteine, die alle verschiedene funktionen haben (teiler, explodierer, brückenbauer etc.). zeil ist es, eben diese steine im level so umzustellen, das eine kettenreaktion in gang gesetzt wird, welche den speziellen endstein als letzten umfallen lässt. dann ist das level geschafft und man kommt ins nächste (klingt von meiner beschreibung her sehr langweilig, aber das game war früher der HAMMER!).

so weit so gut. habe natürlich erstmal nachgegrübelt ob ich mich nun wirklich mit der api rumschlagen soll, oder direkt die vcl variante nehme - bin aber zu dem schluss gekommen, das api wahrscheinlich besser wäre, da ich das vom studium her ein bissel auf die reihe kriegen muss *G*.
naja, habe mir zumindest sowohl das api als auch das vcl template von eurer seite gezogen und erstmal den ganzen unnützen kram da raus geworfen. dann ging es los mit den tutorials und schon fingen die probleme an:

1.) ich weiss mittlerweile, wie man einfache objekte mit opengl auf den bildschirm zaubert, diese einfärbt, verschiebt und drehen kann. selbst die rotation per tastendruck um die jeweiligen achsen stellen nicht sooo die grossen probleme dar. ich habe nun testweise einmal zwei dominosteine hintereinander in meine worldmatrix gerendert und so si gedreht, das man sie von der seite sieht. allerdings verstehe ich nun folgendes nicht:
ich sehe doch richtig, das man nicht die objekte selbst dreht, sondern einfach die komplette worldmatrix an sich und dann die objekte in diese matrix neu zeichnet. doch wie kann man nun bewerkstelligen, das ich z.b. per tastendruck nur EINEN stein umfallen lasse, dieser dann den nächsten den er trifft anstösst und dieser mit umfällt? wie kann man objekte (meine dominosteine bestehen übrigens aus insgesamt 6 einzelnen glQuads - geht das nicht auch einfacher?) einzeln komplett rotieren und verschieben lassen? (ich weiss nicht ob ich da einen denkfehler habe, aber aufgrund den tutorials habe ich es jetzt so verstanden das ich die beiden objekte zeichnen lasse, die matrix pushe, meinen blickwinkel ändere, nur den stein der umfallen soll in ner schleife ständig neu zeichne, die matrix poppe und damit den zweiten stein wieder so erscheinen lasse usw.) das prinzip was ich mir da denke is doch SEHR aufwendig - das muss doch auch einfacher gehen. nur wie?

2.) diese "einheitenrechnung" von den euch bennanten "weltkoordinaten" verstehe ich nicht. wenn ich ein fenster von der grösse 800x600 habe...wieviele WK's muss ich ein Objekt dann verschieben, damit es z.B. genau am rande des bildschrims steht. und wenn ich objekte über den screen sausen lasse - wie kann ich abfragen, das sie an den bildschirmrand stossen und dann wieder umdrehen? so wie ich es jetzt habe fliegen sie immer weiter und weiter nach links oder rechts. und wie lassen sich diese "WK"'s z.b. in pixeleinheiten transformieren?

3.) auf einzelne konstanten die ihr verwendet, geht ich gar nicht ein. was genau macht denn z.b. "SwapBuffers(h_DC)"? der kommentar daneben ist mir einfach zun wenig. swapbuffers kriegt das handle auf unsern device kontext übergeben richtig? und was macht diese funktion dann damit? wenn ich es nicht drinhabe oder per tastendrück woanders aufrufe passiert in dem fenster auch erstmal gar nichts. kann ich dieses "SwapBuffers" auch für OnIdle-Events benutzen? Wenn ja, wie kann ich mir das mit den "Double Buffer" vorstellen? Gibt es dann ein zweites Fenster im Hintergrund, welches die gleiche Szene nochmal zeigt? Und wo genau liegt der Unterschied zwischen dem h_DC (Device Kontext), h_RC (Rendering Context) und unserem Fenster (h_Wnd) ? Ist das alles nur für windows intern? was genau machen die einzelnen matrix modes (projection,modelview) und wofür ist der pixelformatdeskriptor?

4.) wenn ich die api vorlage benutze, seh ich in der main message loop immer folgendes:
glDraw();
SwapBuffers(h_DC);
ProcessKeys;
das windows ein event gesteuertes bs ist, is mir schon klar, aber ist es, gerade für spiele, wo sich einzelne objekte verschieden bewegen und reagieren sollen, überhaupt sinnvoll, das glDraw() in die main message loop zu packen? weil irgendwie rendert der die gleiche szene (was in gldraw steht) doch dann immer und immer wieder neu und man hat doch gar keine möglichkeit, da mal was geschehen(erscheinen) zu lassen (ausser ganz normalen rotationen und bewegungen) oder? muss das swapbuffers auch zwingend in die main message loop? oder muss man für spiele den ganzen kram sowieso woanders himpacken? wenn ja, wo am besten? wenn nein: wie kann man das denn alles am geschicktesten verarbeiten?

5.) auch ein sehr seltsames phänomen: sobald ich per opengl auch nur EIN simples objekt in mein fenster rendere, steigt die temperatur meiner graka soweit an, als wäre sie unter vollast wie bei NFSU2(ca. 53°C - idle is ca 32°C). ist das normal? denn sooo aufwendig ist das, was ich da rendere ja nun auch wieder nicht - oder liegt es eben daran, das der die gleiche szene immer und immer wieder rendert, da das gldraw ja in der main message loop steht? das führt ja dann wieder auf die frage von 4 zurück? wie und wo dann?

6.) was ist denn vorteilhafter und schneller? meine dominosteine per glquads und einer funktion direkt auf den screen zu rendern oder ein model zu entwerfen und da ne textur draufzupacken? wäre es damit auch einfacher die sachen einzeln auf dem bildschirm zu bewegen (da man ja nur das model irgendwie verschieben bzw. drehen muss, während man bei den glquads ja den ganzen mist ja immer und in jeder position neu zeichnen muss oder?)

ich glaube das war es erstmal, aber ich glaube das reicht auch erstmal für meinen ersten post
sorry, wenn ich soviele fragen auf einmal stelle, aber das ist halt alles so unklar und wo kann ich sonst fragen wenn nicht hier? ansonsten schonmal danke im vorraus und für die ganze arbeit mit den tutorials. weiter so

p.s. die fragen stelle ich übrigens an die ganze community - auch wenn es so klingt das ich nur die "tutorialschreiber" meine

Wow, das sind ja eine Menge Fragen, aber das werden wir schon alles klären.

zu 1.) Um Objekte zu verschieben/rotieren/skalieren, fallen mit spontan nur zwei Möglichkeiten ein. Entweder jedes Quad weis genau, wo es hinsoll, als so, wie es zum Beispiel von einem 3D-Modeller exportiert wird, oder du zeichnest immer das gleiche Quad, nur hald versetzt/verschoben/skaliert. Ersteres würde ich speziell für deine Anforderungen nicht empfehlen, da deine Dominos natürlich dynamisch sind, und sich fest zum Level gehören. Für einen Würfel sind 6 Quads schon fast optimal, einfacher lässt sich ja ein Würfel nicht beschreiben. Ich würde aber stattdessen 12 Triangles verwenden, da die GPU zwei Tris schneller berechnet als ein Quad.

zu 2.) Die Weltkoordinaten in Pixeleinheiten zu konvertieren dürfte schwierig werden, da sich natürlich mit wechselnder Entfernung zum Betrachter auch die Einheiten verändern. Es sei denn du arbeitest nur auf einer Ebene.

zu 3.) Da hab ich ned so richtig Ahnung

zu 4.) Also im glDraw(); wird hald einfach alles gezeichnet, was gezeichnet werden soll. Du schreibst hier alles Matrixtransformationen (zB glTranslatef(...)), Polygone (glBegin(...)) und halt alles, was mit gl... beginnt, rein, was halt in jedem Frame auch wieder neu gesetzt werden muss.

zu 5.) Das ist ja der optimale Zeichen dafür, dass der Computer zeigt, was er kann. Natürlich würden bei einem simplen Quad ein Bild pro Sekunden reichen, aber bei mehr Objekten wirst du für jedes Quäntchen investierter Leistung froh sein. Und OpenGL kennt hald (bildlich gesprochen) nicht, wieviel sich in der Szene befindet, also fordert es einfach alle Power, die es kriegen kann. Es fragen oft Leute, ob es normal ist, dass die CPU-Auslastung bei OpenGL-Anwendungen immer bei 100 % liegt, das ist genau das gleiche. Es würde mich eher stören/wundern, wenn es anders wäre.

zu 6.) Ob Model oder in OpenGL berechnen, kommt eigentlich aufs selbe raus, das Model würde ja auch mit den gleichen Funktionen gerendert werden, mit denen es du per Hand machen würdest. Models setzt man hald generell bei komplexeren Objekten ein, eine Dominostein ist da ja noch ned das Maximum

_________________
"Du musst ein Schwein sein in dieser Welt, sangen die Prinzen, das ist so 1.0. Du musst auf YouTube zeigen, dass dir dein Schweinsein gefällt, das ist leuchtendes, echtes Web 2.0."
- Hal Faber
Meine Homepage: http://laboda.delphigl.com

danke für die schnelle antwort!

liegt wahrscheinlich an mir,aber wiklich schlauer bin ich jetzt leider immer noch nicht

also, das ganze sieht in meinem testprog so aus: (drehen und wenden kann man die per tastendruck - is ja aber auch egal)



der relevante code dafür is folgender:



gerade, um diese frames und animation bzw. kollision usw. geht es mir! wie kann ich nun porgrammieren, das, wenn ich z.b. die space taste drücke der gelbe stein in einer FLÜSSIGEN bewegung umfällt, dabei den anderen stein anstösst (wenn sie kollidieren) dieser dann mit umfällt und beide dann liegen bleiben?
das kann doch gar nicht gehen, wenn der in der main message loop immer nur das selbe rendert oder? und wie kann man festlegen, das erst ein objekt umfällt, dann beide und das dann später auf ganz viele steine erweitern? das ist quasi mit mein hauptproblem

hallo und guten morgen *g*

das klingt ja schon verdammt nach einem einsatz für newton !!!

doch noch kurz zum swapbuffers ... also das ganze macht im endeffekt nichts weiter als die virtuellen bildschirmseiten (es gibt 2 buffer, den angezeigten und den in dem du zeichnest) zu vertauschen, so das die dinge, die du gezeichnest hast auf dem bildschirm erscheinen ...



nun zu den dominos ... das ganze wäre ein wirklich wunderbares spiel für die newton game physics engine (schau mal dazu bissl hier im forum rum, gibts schon einiges zu und sascha hat einiges auf seiner eigenen seite). dabei bräuchtest du halt nur deine dominos als Körper an newton übergeben und wenn du die leertaste drückst lässt du einfach ne kraft auf den anfangsstein wirken und schon fällt der um und die anderen danach auch. um das fallen die kollision und so brauchst du dich selbst nicht kümmern, da newton dir nur eine matrix zurückgibt, mit der du dann dein objekt positionieren kannst. also alles viel einfacher als das was ich so von dir gelesen hab

_________________
Aktuelles Projekt :
www.PicPlace.de

Was die Einsteigertutorials angeht so gebe ich dir Recht, denn sie lassen einige Fragen offen. Deshalb werden diese Tutorials derzeit überarbeitet.

Wie wäre es, wenn du eine Prozedur erstellst in der du deinen Stein zeichnest. Am besten gleich eine ganze Klassefür die Steine. Für jeden Stein speicherst du eine Position, Ausrichtung, Funktion usw.

Es gibt keine feste Umrechnung von Weltkoordinaten, denn du kannst deine Welt so groß bzw. so klein Zeichnen wie es dir beliebt. Schließlich kannst du dich einem Objekt unendlich annähern und dich wiederum von ihm unendlich weit entfernen. Die eigentliche Größe entsteht durch die Geschwindigkeit mit der du dich bewegst. Bewegst du dich verhältnismäßig langsam so erscheint dir alles riesig, bewegst du dich schnell so erscheint dir alles viel kleiner (die korrekte Entfernung deiner Nearclippingplane vorausgesetzt).
Welche Skalierung deiner Welt dir also zusagt ist ganz allein dir überlassen.

SwapBuffers gibt dein Bild aus indem es den Front- und den Backbuffer austauscht und somit das gezeichnete Bild auf den Bildschirm bringt. Am Besten du liest dich diesbezüglich mal in unserem OpenGL-Wiki zum Thema Framebuffer schlau.
Bezüglich der anderen Fragen solltest du google bitten oder stöberst mal im Wiki. Dinge wie Handles und ein Device Kontext haben nichts mit OpenGL zu tun.

Wenn ich mir deinen bisherigen Code so anschaue empfehle ich dir dringend dir weitere Tutorials durchzulesen (z.B. das Bombermantutorial). Mit deinem bisherigen Code wirst du nicht weit kommen, denn es ist nur eine Frage der Zeit bis du die Übersicht komplett verloren hast. Mit Klassen könntest du dir zudem viel Arbeit ersparen.

Wenn du weitere Tutorials gelesen hast werden sich die meisten Fragen von selbst beantworten.

Zum Mitreißen der Steine:
Es gibt im Internet Unmengen an Tutorials zum Thema OBB (Oriented Bounding Boxes)-Kollision. Da deine Steine vermutlich immer Boxen sein werden könnten dir diese Artikel weiterhelfen. Um die Physik musst du ich jedoch selbst kümmern (wenn du weißt, wann eine Kollision statt findet ist es auch nicht mehr schwer den Stein umzustoßen, denn du kennst dann auch den Kollisionsstein (und somit die Informationen des anstoßenden Steines).

In letzter Zeit wird für solche Probleme auch immer öfter Newton empfohlen. Mit Newton kannst du ein komplexes Physikmodell in dein Programm einfach integrieren. Da es sich hier um kein besonders komplexes Thema handelt wird es sicher auch einige Tutorials/Beispielprogramme zu diesem Gebiet geben.

_________________
Nichts auf der Welt ist so gerecht verteilt wie der Verstand. Denn jederman ist überzeugt, dass er genug davon habe.
Rene Descartes, frz. Mathematiker u. Philosoph, 1596-1650

Nun ja... ich glaube dir fehlen noch logische Denkweisen eines OpenGL- bzw. 3D-Programmierer:
Es wird nicht immer die selbe Szene gezeichnet sondern nur das was du geschrieben hast, dein Probelm ist denke ich mal folgendes: Du kannst ja die Positionen und den neigungs-Winkel deiner Dominos in sogennate VARIABLEN speichern und diese dann zum Beispiel per Tasten Druck ändern zB: folgender Maßen:

Wenn die Leertaste gedrückt wird, setzt du die Variable eines Dominos( D1_faellt_um:Boolean) = TRUE;
dann überprüfst du in deiner Main Loop ob D1_faellt_um TRUE ist und ziehst der Variable D1_Winkel:GLfloat; etwas ab z.B: so:

D1_Winkel:=D1_Winkel-0.01;

Vor dem Zeichnen deines Dominos speicherst du dann die Matrix(glPushMatrix), drehst ihn um seine z-Achse(oder x,y je nachdem von wo wir drauf schaune) via glRotate(D1_WInkel,0,0,1) zeichenst ihn lädst wieder die Matirx in den zustand vorher(glPopMatrix) und zeichnes den anderen Domino, mit Kollision und allem, das muss auch alles in der Main Loop stehen.
Dadurch eintsteh dann eine Animation, da bei jedem Frame der Domino sich mehr und mehr neigt, je nachdem wie hoch deine FramesPerSecond Rate ist, ALSO NICHT IMMER DAS GLEICHE BILD

Ich hoffe ich konnte es einigermaßen erklären...


Peace

[EDIT] Ach ja zu deiner Frage mit den Koordinaten. Du benutzt die Projektions Matirx, da ändert sich dein Frustum mit der Tiefe(z-Koordiante) deines Objekts, für Pixel Korrdinaten brauchst du den Ortho-Modus, nähers dazu findest du sicherlich in SoS 2D-Tutorial.

vielen dank für die vielen tipps - ich werd ma schauen was ich draus mache und dann nochmal das ergebnis posten

aber sehe ich richtig, das ich die main messageloop so lasse wie sie ist ja? also das müsste schon so gehen wie es da steht?

schau dir mal auf Newton Game Dynamics den Neton Stress Test an(ziemlich weit unten auf der seite). du wirst newton dann bestimmt für dein thema interessant finden!

PS: wenn ichs noch drauf hab, kriegst nen schnellen screen.

_________________


"User Error. Replace User and hit Continue."

die newton engine is zwar cool aber leider komplett in vcpp

und ich habe keine lust das alles nach deplhi zu portieren....

also das mit dem einzelnen objektbewegen hab ich jetzt gerafft, aber wie kann man schwerpunkte von bestimmten objekten festlegen um die dann rotiert werden. eine fallbewegung mit dem ganz normalen glrotatef sieht nicht so prickelnd aus

und wie bestimmte ich kollisionen? gibt es irgendeine opengl funktion die mir die koordinaten von bestimmten punkten, linien, polygonen o.ä. zurückliefert?

überrraschung!

http://newton.delphigl.de

netterweise hat Sascha Willems einen Header für Delphi geschrieben.

Kollisionen usw. musst du normalerweise alles selbst machen.

opengl macht NUR die grafik, d.h. es nimmt von dir daten und zeichnet. zumindest prinzipiell.

EDIT: Öha! war doch .de! link korrigiert.

_________________


"User Error. Replace User and hit Continue."

das mit der kollision war auch eher ne allgemeine frage

aber wenns das auch für delphi gibt, das is ja schomal was...thx für den link

edit: ööhmmm...der link funzt aber ned

sry, link korrigiert.

EDIT: bei euch auf der seite steht übrigens, dass "PushOver" noch nicht bei euch auf dem mirror ist.

_________________


"User Error. Replace User and hit Continue."

Sascha hat den Newton Header bereits nach Delphi portiert. Es gibt hier ja schon einige die das mit Delphi nutzen. Du musst das also net selber amchen .

Das mit dem Mainloop is so ne Sache. Schönender in Sachen CPU Last und wie du schon gesagt hast auch GRAKA, wäre es, wenn der Mainloop nicht ganz so oft ausgeführt wird. z.B. könntest du mit einem Timer das Zeichnen auslösen. Dann könnte auch jeder Nutzer einstellen wieviel Frames er haben möchte. Bei vielen Programmen wird hier auf dem Board im OnIdle gerendert. Dadurch kommt natürlich die höchste Framerate aber auch die höchste CPU last zu stande (was vorallem bei Laptops negativ ist). Du solltest aber daran Denken, dass bei einer Variablen Framerate auch die Dominostein bewegung Timbased(und nicht Framebased) sein muss.
Das sind alles Sachen die dir wahrscheinlich noch nichts sagen aber es gibt hilfe im Wiki:

http://wiki.delphigl.com/index.php/Timebased_Movement
http://wiki.delphigl.com/index.php/Doppelpufferung
http://wiki.delphigl.com/index.php/SwapBuffers

_________________
Blog: kevin-fleischer.de und fbaingermany.com

hoppla..das kann sein. meld dich einfach per pm oder so - dann schick ichs dir per mail. is ja ned so riesig. aber vorsicht - du brauchst entweder dos oder n bs mit dos kernel (z.b. win 95/98).
oder halt n tux system mit dem dosemu

ja hab ich, ist aber net in benutzung - wart ich lieber auf deine opengl-umsetzung.

PS: wann immer du fragen hast, ich helf dir gerne.

_________________


"User Error. Replace User and hit Continue."