Problem mit Opengl performance

hypersayyajin

Hallo,
ich habe das Problem, dass mein Opengl Programm sozusagen "mit dem Zeichnen nich hinterherkommt", ich sehe quasi die Animation ab einer bestimmten Geschwindigkeit doppelt.

Ich hoffe, dass Ihr mir sagen könnt, wie ich das ganze optimieren und wieder "sauberer" zum laufen bekommen kann.

Hier der Code:

#include <string.h>
#include <GL/glui.h>
#include <GL/glut.h>
#include <math.h>

int  main_window;
int winIdSub; 
float faktor = 0.0;
float faktor2 = 1.0;
const double pi2 = 6.28318530718;
float omega = 1.0;
static char label[100]; 
float laenge = 0.75;
float winkel = 1;
double tic = 0.025;
static double time = 0.0;
float alpha =1.0;
double xcenter , ycenter;

void myGlutIdle( void )
{

  if ( glutGetWindow() != main_window ) 
    glutSetWindow(main_window);  
    glutPostRedisplay();
   glutSetWindow (winIdSub);
  glutPostRedisplay ();
  time += tic; 

}

void winInit(void){

gluOrtho2D(-1.0, 1.0, -1.5, 0.5);

};

void stop(int)
{
  tic=0;
}
void start(int)
{
  tic=0.025;
}

void display( void )
{

static double radius = 0.03;

const double delta_theta = pi2/20;

double x, y;

double theta = 0.0;

double current_angle ;
/*
if (faktor==0)
{

current_angle = (cos(omega * (time*(faktor/5)))- alpha);
}
else
{*/

    current_angle = (cos(omega * (time*(faktor/5))- (alpha))+cos(time*(faktor/5)));
    /*
} 
*/

glColor3f(0.0, 0.0, 0.0);

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0, 1.0, 1.0);

glColor3f(1.0, 1.0, 1.0);

glBegin(GL_LINES);

glVertex2f(0.0, 0.0);

xcenter = (-1)*laenge * sin(current_angle);

ycenter = (-1)*laenge * cos(current_angle);

glVertex2f(xcenter,ycenter);

glEnd();

glColor3f(1.0, 0.0, 0.0);

glBegin(GL_POLYGON);

while (theta <= pi2) {

x = xcenter + radius * sin(theta);

y = ycenter + radius * cos(theta);

glVertex2f(x, y);

theta += delta_theta;

};

glEnd();

glutSwapBuffers();
}

void  
drawString (char *s) 
{ 
  unsigned int i; 
  for (i = 0; i < strlen (s); i++) 
    glutBitmapCharacter (GLUT_BITMAP_HELVETICA_10, s[i]); 
}; 

void  
subDisplay () 
{ 

  /* unterfenster löschen */ 
  glutSetWindow (winIdSub); 
  glClearColor (0.25, 0.25, 0.25, 0.0); 
  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

  /* zeichnen */ 
  glColor3f (255.0F, 255.0F, 255.0F); 
  glBegin (GL_LINE_LOOP); 
  glVertex2f (0.0F, 0.0F); 
  glVertex2f (0.0F, 0.99F); 
  glVertex2f (0.999F, 0.99F); 
  glVertex2f (0.999F, 0.0F); 
  glEnd (); 

  /* sub-fenster inhalt */ 
  glColor3f (1.0F, 1.0F, 1.0F); 
  sprintf (label, "v = %8.3f ", xcenter  ); 
  glRasterPos2f (0.05F, 0.75F); 
  drawString (label); 

  glColor3f (1.0F, 1.0F, 1.0F); 
  sprintf (label, "a = "); 
  glRasterPos2f (0.05F, 0.5F); 
  drawString (label); 

  glColor3f (1.0F, 1.0F, 1.0F); 
  sprintf (label, "E(kin) = "); 
  glRasterPos2f (0.05F, 0.25F); 
  drawString (label); 

    glColor3f (1.0F, 1.0F, 1.0F); 
  sprintf (label, "E(pot) = "); 
  glRasterPos2f (0.2F, 0.75F); 
  drawString (label); 

  glutSwapBuffers (); 
}; 
void  
subReshape (int w, int h) 
{ 
  glViewport (0, 0, w, h); 
  glMatrixMode (GL_PROJECTION); 
  glLoadIdentity (); 
  gluOrtho2D (0.0F, 1.0F, 0.0F, 1.0F); 
}; 

/**************************************** main() ********************/

int main(int argc, char* argv[])
{
  /*Fenster initialisieren und GLUT aufrufen*/
glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA);

glutInitWindowPosition(5,5);

glutInitWindowSize(640,640);
main_window = glutCreateWindow( "Pendel" );
winInit();
/*antialiasing
glEnable(GL_LINE_SMOOTH);
*/
glutDisplayFunc(display);
glutIdleFunc(myGlutIdle);
GLUI * glui_window;

    winIdSub = glutCreateSubWindow (main_window, 5, 5,  630,  70); 
     glutDisplayFunc (subDisplay); 
     glutReshapeFunc (subReshape); 

GLUI *glui = GLUI_Master.create_glui( "Menü" );

GLUI_Spinner *segment_spinner = glui->add_spinner( "v:", GLUI_SPINNER_FLOAT, &faktor );
GLUI_Spinner *segment_spinner2 = glui->add_spinner( "l:", GLUI_SPINNER_FLOAT, &laenge );
GLUI_Spinner *segment_spinner3 = glui->add_spinner( "alpha:", GLUI_SPINNER_FLOAT, &alpha);
glui->add_button("Stop", 0, stop);
glui->add_button("Start", 0, start);
segment_spinner->set_int_limits( 0, 100 ); 
segment_spinner2->set_int_limits( 0, 100 ); 
 segment_spinner3->set_int_limits( 0, 180 );  
  glui->set_main_gfx_window( main_window );
  /* IDLE mit glui aufrufen*/
  GLUI_Master.set_glutIdleFunc( myGlutIdle ); 

  glutMainLoop();

  return 0;
}

Vielen Dank schonmal im Vorraus!

Pellaeon

hast du irgendwo glFlush oder glFinish eingebaut

glColor3f(0.0, 0.0, 0.0);

glClear(GL_COLOR_BUFFER_BIT);

glColor3f(1.0, 1.0, 1.0);

glColor3f(1.0, 1.0, 1.0);

Das ist zwar kein Performance-Killer, aber dreimal hintereinander die Farbe setzen, ohne dass sie genutzt wird, muss nicht wirklich sein. Der letzte Aufruf reicht also.

hypersayyajin

neon glflush hab ich nich eingebaut...weshalb?

Pellaeon

glFinish sorgt dafür, dass alle abgeschickten Daten gerendert werden und kehrt erst danach wieder zurück.
glFlush sorgt dafür, dass das Render von Daten, welche im "Wartepuffer" stehen, ausgelöst wird.
Mach mal einfach am Ende deiner Szene ein glFinish() rein. Oder hast das schon?

TomasRiker

Pellaeon schrieb:

Mach mal einfach am Ende deiner Szene ein glFinish() rein. Oder hast das schon?

Warum sollte er das tun?
Dann wird die Performance höchstens schlechter.

Pellaeon

TomasRiker schrieb:

Pellaeon schrieb:

Mach mal einfach am Ende deiner Szene ein glFinish() rein. Oder hast das schon?

Warum sollte er das tun?
Dann wird die Performance höchstens schlechter.

Evtl sollte er das tun, damit auch alle Daten gerendert sind, bevor er den Framebuffer swapped?
Oder was sollte sonst für den komischen Effekt verantwortlich sein?
Den Framebuffer tut er ja löschen, wie man im Quellcode sieht.

TomasRiker

Nein, denn das geschieht automatisch.
glFinish ist so ziemlich das schlimmste, was du machen kannst.
Du zwingst damit die CPU auf die GPU zu warten, die optimalerweise parallel arbeiten.

rapso

vielleicht ist vsync aus und sollte eingeschaltet werden.

hypersayyajin

als das problem ist erst aufgetreten, als ich die idle von:

void myGlutIdle( void )
{

  if ( glutGetWindow() != main_window ) 
    glutSetWindow(main_window);  
    glutPostRedisplay();
  time += tic; 

}

nach
[cpp]
void myGlutIdle( void )
{

if ( glutGetWindow() != main_window )
glutSetWindow(main_window);
glutPostRedisplay();
glutSetWindow (winIdSub);
glutPostRedisplay ();
time += tic;

}
[/cpp]
geändert habe. Vllt hilft das Euch weiter?

Pellaeon

TomasRiker schrieb:

Nein, denn das geschieht automatisch.
glFinish ist so ziemlich das schlimmste, was du machen kannst.
Du zwingst damit die CPU auf die GPU zu warten, die optimalerweise parallel arbeiten.

Oha das ist mir neu. Danke für den Hinweis.
Warum steht sowas nicht mit im Red Book drinne oO