OpenGL zu wenig Frames

[roboter202]

Hallo,

eigentlich seid ihr ja nicht dafür verantwortlich aber da ich auf dem Forum von http://www.delphigl.com/ noch nicht freigeschaltet wurde :evil: frag ich hier mal nach.

Ich hab mal das 1. Beispiel ausprobiert was es da als Tutorial gab. Ein Viereck auf schwarzen Hintergrund. Der Code ist 1:1 übernommen aber trotzdem habe ich nur 60 Frames. Die CPU ist kaum ausgelastet < 2%, wenn ich jedoch das Fenster in den Hintergrund schiebe geht die Auslastung hoch > 80%. Das sollte eig. anders sein :).
Vielleicht sollte ich sagen das ich bei wie ich denke ressourcenfressenderen Spielen (GTA SA, Minecraft, RSV2, ...) wesentlich mehr Frames (> 100) habe.

Die Grafikkarte (POV GeForce GT440) ist noch sehr neu und sollte bei so einem "Bildchen" nicht in die Knie gehen. Der Prozessor ist zwar nicht der neuste aber an der Auslastung sollte man erkennen das auch hier mehr drin ist.

Es kann natürlich auch sein das der Code selbst suboptimal ist.

CODE:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, DGLOpenGL;

type
  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormResize(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure IdleHandler(Sender: TObject; var Done: Boolean);
  private
    { Private-Deklarationen }
    StartTime, TimeCount, FrameCount  : Cardinal; //FrameCounter
    Frames, DrawTime                  : Cardinal; //& Timebased Movement
    procedure SetupGL;
    procedure Init;
    procedure Render;
    procedure ErrorHandler;
  public
    { Public-Deklarationen }
    DC                                : HDC;  //Handle auf Zeichenfläche
    RC                                : HGLRC;//Rendering Context
  end;

var
  Form1: TForm1;

const
  NearClipping = 1;
  FarClipping  = 1000;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  DC:= GetDC(Handle);
    if not InitOpenGL then Application.Terminate;
    RC:= CreateRenderingContext( DC,
                               [opDoubleBuffered],
                               32,
                               24,
                               0,0,0,
                               0);
    ActivateRenderingContext(DC, RC);
    SetupGL;
    Init; //Was man sonst so initialisieren will.
end;

procedure TForm1.SetupGL;
begin
  glClearColor(0.3, 0.4, 0.7, 0.0); //Hintergrundfarbe: Hier ein leichtes Blau
  glEnable(GL_DEPTH_TEST);          //Tiefentest aktivieren
  glEnable(GL_CULL_FACE);           //Backface Culling aktivieren
end;

procedure TForm1.Init;
begin
  Application.OnIdle := IdleHandler;
end;

procedure TForm1.Render;
begin
  glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
 
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity;
  gluPerspective(45.0, ClientWidth/ClientHeight, NearClipping, FarClipping);
 
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;
 
  glTranslatef(0, 0, -5);
 
  glBegin(GL_QUADS);
    glColor3f(1, 0, 0); glVertex3f(0, 0, 0);
    glColor3f(0, 1, 0); glVertex3f(1, 0, 0);
    glColor3f(0, 0, 1); glVertex3f(1, 1, 0);
    glColor3f(1, 1, 0); glVertex3f(0, 1, 0);
  glEnd;
 
  SwapBuffers(DC);
end;

procedure TForm1.IdleHandler(Sender: TObject; var Done: Boolean);
begin
  StartTime:= GetTickCount;
  Render;
  DrawTime:= GetTickCount - StartTime;
  Inc(TimeCount, DrawTime);
  Inc(FrameCount);
 
  if TimeCount >= 1000 then begin
    Frames:= FrameCount;
    TimeCount:= TimeCount - 1000;
    FrameCount:= 0;
    Caption:= InttoStr(Frames) + 'FPS';
    ErrorHandler;
  end;
 
  Done:= false;
end;

procedure TForm1.FormResize(Sender: TObject);
var tmpBool : Boolean;
begin
  glViewport(0, 0, ClientWidth, ClientHeight);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity;
  gluPerspective(45.0, ClientWidth/ClientHeight, NearClipping, FarClipping);    
 
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity;
  IdleHandler(Sender, tmpBool);
end;

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

procedure TForm1.ErrorHandler;
var s: String;
begin
  s := gluErrorString(glGetError);
  If s <> 'no error' then showmessage(s);
end;


end.

PS: Ich verwende die OnIdle Routine zum Aufruf des Renderns.

[mkinzler]

Es scheint VSync aktiv. Da ein digitaler Monitor aber nur 60 Bilder/Sekunde anzeigt, besteht auch keine Notwendigkeit mehr frames zu berechnen

[roboter202]

Na das mag sein,
Aber auf dem Screenshot von dem Tutorial hat der Typ > 400 Frames.
Und ich hab die Befürchtung das wenn ich jetzt was größeres mache meine Frames doch auch weiter nach unten gehen.
Bei guten Games hat man ja auch > 200 Frames mit High End karten und ist total stolz darauf.

[Uwe Raabe]

Wie schon gesagt wurde: wenn du die Frame-Rate nicht begrenzen willst, musst du in deinen OpenGL-Einstellungen der Grafikkarte das VSync abstellen bzw. auf "von der Anwendung gesteuert" einstellen.

[mkinzler]

Dann deaktiviere VSync. macht aber imho keinen Sinn, mehr Frames zu berechnen, als angezeigt werden können.

[Medium]

Da geht auch nix runter wenn du mehr machst, so lange das Mehr nicht an die Grenzen deines System stößt. Die Begrenzung auf 60 ist "künstlich", und hat nichts damit zu tun, dass hier was ausgelastet wäre. Nimms entweder erstmal so hin, oder deaktivier VSync ;)

Zitat:

> 200 Frames mit High End karten und ist total stolz darauf.

Das trifft nur auf Proleten zu. Ich bin glücklicher, wenn meine Games auf 60FPS meinen PC langweilen, weil dann weiss ich dass noch Luft nach oben ist, und die Kiste grad schön wenig Strom verballert - für einen Effekt, den man nichtmals sieht. Große Zahlen kann ich auch im Notepad schreiben.

[roboter202]

Ok dann hab ich > 1200 Frames. Jetzt weiß ich wenigstens das mein Grafik genug kann und ich anfangen kann etwas bessere Dinge mit OpenGL zu machen.

Thx. :-D

[blackfin]

VSync zu deaktivieren macht manchmal schon Sinn und ist nicht nur ein "virtueller Schwanzvergleich".
Sicher, der Monitor kann meist nur 60fps anzeigen, aber VSync wirkt sich bei Hardware-Cursors auch negativ auf die Eingabegeschwindigkeit aus und bewirkt eine Latenz.
Einfach mal nach "VSync Input latency" oder "VSyng Eingabeverzögerung" googeln :-)

Allerdings ist es immer System- und Szenario-abhängig, ob VSync gut oder schlecht ist.

P.S.:

Zitat:

Jetzt weiß ich wenigstens das mein Grafik genug kann und ich anfangen kann etwas bessere Dinge mit OpenGL zu machen

Ja, allerdings..."etwas" mehr....mit der Grafikkarte kannst du ein Crisis 2 nachbauen, ohne dass die in die Knie geht :-D

[Medium]

Okay, so hardcoremäßig bin ich dann nicht unterwegs, dass Verzögerungen von 1/60 Sekunde meine Performance merklich beeinflussen würden. (Wobei man dieses "Problem" eher mangelhaftem Desing des Spiels zuschreiben müsste, wenn es Eingaben und Spiellogik im selben Thread wie das Rendern erledigt, aaaaber das ist eine andere Diskussion 8))

Während der Entwicklung ist es aber durchaus sinnvoll ohne VSync zu fahren, und sei es um bloß abschätzen zu können, wie viel noch so geht. Beim laufenden Programm stört mich da eher das (auch bei TFTs auftretende) Tearing - grad bei Shootern.

[Memnarch]

@Medium: Und genau gegen das Tearing ist VSync gut. Das tearing entsteht durch desynchronisation. Mit VSync darf das nicht passieren, sonst hat da wer was kaputt gemacht :D