OpenGL Einsteiger Frage

[ferby]

Hallo,

Ich bin gerade dabei OpenGL zu lernen, und zu verstehen.

Heute habe ich damit angefangen und habe ein Problem.

Ich lasse ein viereck um die y-Achse rotieren:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows,Forms,dglOpenGL, ExtCtrls, Classes;

type
  TForm1 = class(TForm)
    Timer1: TTimer;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure Render;
    procedure Timer1Timer(Sender: TObject);
 end;

var
  Form1: TForm1;
    DC : HDC;  //Handle auf Zeichenfläche
    RC : HGLRC;//Rendering Context

    test: extended;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  // Erstellen
  DC:= GetDC(Handle);
  RC:= CreateRenderingContext( DC,[opDoubleBuffered],32,24,0,0,0,0);
  ActivateRenderingContext(DC, RC);
  glClearColor(0.3, 0.4, 0.7, 0.0); // Hintegrund
  glEnable(GL_DEPTH_TEST);
  glEnable(GL_CULL_FACE);
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  // Vernichten
  DeactivateRenderingContext;
  DestroyRenderingContext(RC);
  ReleaseDC(Handle, DC);
end;

// Render = Zeichnen
procedure TForm1.Render;
begin
  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
 
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity;
  gluPerspective(100, ClientWidth/ClientHeight, 1, 1000);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;

  glTranslatef(0, 0, -10);

  glRotatef(test,0,1,0);

  glBegin(GL_QUADS);
    glColor3f(0, 0, 0); glVertex3f(-5, -9, 1);
    glColor3f(0, 0, 1); glVertex3f(9, -9, 1);
    glColor3f(0, 0, 1); glVertex3f(9, 6, 1);
    glColor3f(0, 0, 1); glVertex3f(-5, 6, 1);
  glEnd;

  SwapBuffers(DC);
end;


procedure TForm1.Timer1Timer(Sender: TObject);
begin
  Render;
  test:=test+4;
end;

end.

Im Anhang die Exe mit dem Viereck das Rotiert.

Was ich jetzt nicht verstehe:
Warum verschwindet das Viereck für eine kurze Zeit?
Ich müsste es doch die ganze Zeit sehen...
Ich habe schon ein Blatt papier vor mir Rotieren lassen um es mir vor zustellen,
aber ich kapier es nicht.
Es müsste doch nur einen MOment nicht zu sehen sein, bei genau 90°...

Kann mir wer das Erklären, so das ich mir das Räumlich vorstellen kann?

Oder vielleicht bin ich auch schon zu müde...... gähn

[DennisHB]

Das Stichwort ist BackFace Culling was du mit der Zeile

glEnable(GL_CULL_FACE);

eingeschaltet hast...

http://delphigl.com
http://wiki.delphigl.com/index.php/Hauptseite

[ferby]

Hallo,

danke ohne den glEnable(GL_CULL_FACE); geht es,
muss mir mal raussuchen was das bewirkt.......

Nach den Links die du mir geschickt hast lerne ich das ganze schon^^


ED: Habs gefunden Backface Culling :-D

[ferby]

Hallo,

Jetzt habe ich ein neues Problem, eigentlich eher eine Frage.

Zitat:

Timebased Movement

Wer bereits versucht hat eines der ersten selbst geschriebenen OpenGL-Programme voller Stolz seinem Kumpel vorzuführen wird festgestellt haben, dass die Bewegungen auf dem anderen Rechner schneller oder langsamer abgelaufen sind als es auf dem eigenen Rechner der Fall war.

Dieses Phänomen lässt sich sehr einfach erklären. Nehmen wir an wir bewegen ein Dreieck von links nach rechts um den Wert 1 über den Bildschirm. Eine alte Krücke wie mein PC schafft vielleicht 50 FPS. Das bedeutet das Objekt wird in einer Sekunde genau 50mal um eine Einheit nach rechts verschoben. Das bedeutet insgesamt also um 50 Einheiten in einer Sekunde. Wenn das Programm nun aber auf einem High-End-System läuft werden wir die Szene... sagen wir... 500mal aktualisieren können. Folglich bewegt sich auf diesem Rechner das Dreieck in einer Sekunde um 500 Einheiten.

Das einzige was wir von unserem Dreieck erhaschen können ist ein blitzartiges Zucken auf dem Bildschirm, welches wir schnell als optische Täuschung abtun würden. Wie kann man diesem Problem nun aber entgegen wirken?

Nehmen wir an wir kennen die Zeit, die wir zum Zeichnen eines Frames benötigen und ermitteln anhand dieses Wertes einen Zeitfaktor, den wir in die Bewegung mit einfließen lassen.

NewPosition := OldPosition + Movement * TimeFactor;

Handelt es sich um einen schnellen Rechner so ist der Zeitfaktor entsprechend niedrig und die Bewegung pro Frame verringert sich. Ist der Rechner hingegen langsam so besitzen wir einen hohen Zeitfaktor. Folglich legt das Dreieck auf dem schnelleren Rechner pro Frame weniger Weg zurück als auf dem langsamen. Insgesamt jedoch legen die beiden Dreiecke im gleichen Zeitabstand (z. B. in einer Sekunde) denselben Weg zurück.

Um den Zeitfaktor zu ermitteln muss man lediglich die Zeit für einen Schleifendurchlauf ermitteln. Um eine möglichst hohe Genauigkeit zu erhalten sollte man die Zeit für den letzten Schleifendurchlauf ermitteln und im aktuellen Schleifendurchlauf verwenden.

Quelle: http://wiki.delphigl.com/index.php/Tutorial_Lektion_3



Das trifft doch nur zu wenn ich OnIdle verwende, oder?

Wenn ich, wie in meinen einen Timer verwende, und das Interval so ca. auf 100ms stelle,
dann sollte es auf jeden Rechner gleich laufen, oder?


Oder brauche ich beim Timer auch so was wie

Delphi-Quellcode:

NewPosition := OldPosition + Movement * TimeFactor;

[Corpsman]

Es ist immer Besser wenn du eine Zeitstakklierung machst.

Denn deine Timer Variante funktioniert nur dann wenn der Teil der Berechnet wird << Timer.interval dauert.
zudem hast du bei Timer.interval = 100 ms ja nur 10 fps was ein wenig Arg wenig wäre.

[ferby]

Hallo,

daweil brauche ich nicht mehr als 10FPS,
ich lerne OpenGL ja erst gerade...

Und ich denke das jeder halbwegs normale Prozessor alles mit 10FPS verarbeiten kann und möchte deshalb daweil auf eine Zeitstakklierung.


Mit 10 FPS wird die Anwendung doch auf jeden PC gleich laufen, oder?

[OregonGhost]

Ja, außer der Rechner ist nicht in der Lage, die 10fps einzuhalten, aus welchem Grund auch immer. Fang lieber direkt mit einer Zeitskalierung an, besonders aufwändig ist es nicht und früher oder später kommst du sowieso nicht drumherum. Das ist ein bisschen wie das typische "i don't expect this code to be used in 2 years from now" auf thedailywtf.com. Wohlgemerkt wurde dieser Kommentar mehr als 10 Jahre danach in Produktionscode gefunden. Im Endeffekt brauchst du sowas wie die Zeitskalierung sowieso, wenn du nicht überall Literale in den Code hämmern willst. Also ob du nun

Code:

pos := pos + movementPerFrame;

oder

Code:

pos := pos + movementPerSecond * elapsedTime;

schreibst, ist nun wirklich kein großer Unterschied, das zweite läuft aber auf sehr langsamen Maschinen immer noch und schnelle Maschinen haben mehr als deine 10FPS, ohne dass die Bewegung schneller läuft.

[Corpsman]

Die Frage ist ob du überhaupt nen Timer Brauchst.

Wenn du nur Änderungen hast wenn der User Was Klickt dann kannst du deine Render Function auch immer nur dann aufrufen, und sparst dir den Timer Komplett.

Wenn du mal wissen willst was mit Delphi und OpenGL alles möglich ist hier ein kleines
Game das ich zur Zeit entwickle.

[ferby]

Hallo,

das Game is super, nur ein wenig sehr schwer, schon das 1 Level braucht ne weile......

Ich hoffe sowas bekomme ich in der Zukunft auch zusammen. Bin ja fleißig am lernen :thumb:



Kannst du mir bei einen weitern Problemm helfen?
Ich versuche eine Textur auf ein Viereck zuladen,
aber die Textur erscheint nicht, und nur das Viereck ist zu sehen.

Ich habe keine Ahnung warum das nicht geht.....
Im Anhang das Projekt

[Corpsman]

Hi,

Es ist immer wieder Faszinierend wie viele Verschiedene versionen es Gibt OpenGL in ein Programm ein zu binden.

Der Grund warum du nichts siehst ist weil dein JPG nicht geladen wird.

Der Pointer ist = nil.

ich mache das aber Komplett anders daher kann ich dir nicht sagen wie du SDL da Parametrieren must.

Da ich dich nu aber nicht so im Regen stehn lassen will, habe ich mal meine Art und weise die Bilder zu laden eingebaut. Und diese tut wunderbar. ( und toller weise ohne weitere DLL )