OpenGL in QT

[QT'er]

Ich habe ein einfaches Fenster mit QT:

#include <qapplication.h>  // QApplication
  #include <qmainwindow.h>   // QMainWindow

  using namespace std;

  int main(int argc, char **argv)
  {
    // Create a QApplication object (required)
    QApplication app(argc, argv);

    // Create a QMainWindow object
    QMainWindow *window = new QMainWindow();

    // Move and resize the QMainWindow object
    // left=200, top=200, width=400, height=300
    window->setGeometry(200, 200, 400, 300);

    // Main window = QMainWindow object
    app.setMainWidget(window);

    // set Window Title
    window->setCaption("My QMainWindow example");

    // Show the window
    window->show();

    // Go to the main loop (required)
    return app.exec();
  }

Wie kann ich da jetzt ein OpenGL Fenster "einfügen"? Es soll auch auf eine Headerdatei verwiesen werden. Also das ich die sachen, die im OPGL angezeigt werden sollen, im header programmiert wird (damit das übersichtlich bleibt).
Ausserdem will ich das OGL-Fenster in der art formatieren, wie ich das schon beim fenster überhaupt gemacht habe:

window->setGeometry(200, 200, 400, 300);

<- so in der art ^^

[QT'er]

Weiß es niemand?

[Headhunter]

[] Du hast dir die Examples angeschaut?

[QT'er]

[] Du hast dir die Examples angeschaut?

[aMan]

aber nur, weil ich es vor kurzem auch gebraucht hab:

blub.cpp

#include <QtGui>
#include "glwidget.h"

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

int main(int argc, char *argv[])
{
	QApplication app(argc, argv);

	GLWidget w;
	w.resize(800, 600);
	w.show();

	return app.exec();
}

glwidget.h

#ifndef GLWIDGET_H
#define GLWIDGET_H

#include <QGLWidget>

/**
	@author Adam Celarek <adam@damdam-schleppi>
*/
class GLWidget : public QGLWidget
{
public:
    GLWidget();

    ~GLWidget();
    void initializeGL();
    void paintGL();
    void resizeGL();
};

#endif

glwidget.cpp

#include "glwidget.h"

GLWidget::GLWidget()
 : QGLWidget()
{}

GLWidget::~GLWidget()
{}

/*!
    \fn GLWidget::initializeGL()
 */
void GLWidget::initializeGL()
{
    /// @todo implement me
}

/*!
    \fn GLWidget::paintGL()
 */
void GLWidget::paintGL()
{
	glClearColor(0.0, 0.0, 0.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT);

	glColor3f(1.0, 1.0, 1.0);

	glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0); 

	glEnable(GL_LINE_SMOOTH);
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
	glLineWidth(30.0);
	glLineStipple(1, 0xAAAA);
	glEnable(GL_LINE_STIPPLE);

	glBegin(GL_LINE_STRIP);
		glColor3f(0.80, 0.0, 0.0);
		glVertex2f(-0.4, -0.5);
		glColor3f(0.0, 0.80, 0.0);
		glVertex2f(-0.5, 0.5);
		glColor3f(0.0, 0.0, 0.80);
		glVertex2f(0.45, 0.5);
		glColor3f(0.80, 0.80, 0.0);
		glVertex2f(0.5, -0.5);
		glColor3f(0.80, 0.0, 0.0);
		glVertex2f(1.0, -0.5);
	glEnd();

	glFlush();
}

/*!
    \fn GLWidget::resizeGL()
 */
void GLWidget::resizeGL()
{
	paintGL();
}

die initialisierung sollte natuerlich richtig drinn sein und resizeGL sollte auch man auch richtig machen. ich wollte das damals nur schnell probieren..

mfg aman..

[QT'er]

Dankeschön

[_michael_]

warum seh ich hier nur einen schwarzen bildschirm? den sample code hab ich von hier: http://www.gamedev.de/index.php?name=News&file=article&sid=12 müsste eigentlich laufen? cu

void GLWidget::paintGL()
{
        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// framebuffer & z-buffer werden gelöscht
	glLoadIdentity();		// identity-matrix laden d.h. 'ursprungskoordinaten laden'

	// Im ersten Tutorial haben wir bereits gesehen das es sowas wie ein Dreieck gibt
	// der Code sah folgendermaßen aus
	// glColor3f (1, 1, 1);		
	// glBegin (GL_TRIANGLES);			
	//	glVertex3f (-1, -1, -10);	
	//	glVertex3f ( 1, -1, -10);	
	//	glVertex3f ( 1,  1, -10);	
	// glEnd();						
	// dabei fällt auf das immer zu Begin eines Zeichevorganges eine funktion namens glBegin();
	// aufgerufen wird. Gefolgt von Koordinaten, die mittels glVertex3f(); übergeben werden,
	// wird der Zeichenvorgang mit einem glEnd(); wieder beendet.
	// Dieses Spiel mit glBegin() und glEnd() kann beliebig oft und an (natürlich von der Logik abhängig)
	// beliebiger stelle fortgesetzt werden, es wird, in unserem Fall, erst dann wieder was davon auf
	// dem Bildschirm zu sehen sein wenn wir SwapBuffers(); ausführen

	// außer Dreiecken gibt es noch Punkte, Linien und alles das was man aus diesen drei Elementen
	// zusammen bauen kann. Z.B. ein Viereck besteht aus zwei Dreiecken, auch wenn es explizit möglich ist unter
	// openGL Vierecke zu zeichnen. Kommen wir nun zum Code.

	// Zeichnet zwei Dreiecke
	glColor3f (1, 1, 1);		
	glBegin(GL_TRIANGLES);
		glVertex3f(-5,3.5f,-10);
		glVertex3f(-5,2.5f,-10);
		glVertex3f(-4,2.5f,-10);
		glColor3f (1, 1, 0);		// die Farbe, und später andere Atribute, kann an beliebiger Stelle und belibig oft
							        // geändert werden. Man kann sich vorstellen das openGL sich immer die letzte Farbe so
									// lange merkt und anwendet bis man eine neue einstellt. Es gibt noch eine ganze Reihe 
									// anderer Attribute (z.B. Textur Koordinaten) die aber erst in einem Späteren Tutorial
								    // durchgenommen werden
		glVertex3f(-3.5f,3.5f,-10);
		glVertex3f(-3.5f,2.5f,-10);
		glColor3f (1, 0, 1);		
		glVertex3f(-2.5f,2.5f,-10);
	glEnd();

	// An dieser Stelle ist zu bemerken das die Primitiven (im Normal Fall) nur einseitig gezeichnet werden.
	// Es also eine Vor- und Rückseite gibt. Dies wird durch eine Normale bestimmt die abhängig von der Reihenfolge der
	// reinkommenden Vertex Punke ausgerichtet wird und, ausgehend von einer Fläche, eben in die eine oder andere
	// Richtung zeigt. Was dazu fürt das folgendes Dreieck eben nicht zu sehen sein wird.

	glBegin(GL_TRIANGLES);
		glVertex3f(-5,1,-10);
		glVertex3f(-5,2,-10);
		glVertex3f(-4,2,-10);     // wenn man hier die Reihenfolge einfach umkehren würde könnte man es wieder sehen
	glEnd();

	// Da es aber vorkommen kann das man ein z.B. Dreieck von beiden Seiten sehen will ist das alles natürlich Einstellungs Sache
	// siehe dazu glCullFace();

	// Zeichnet ein Viereck
	glBegin(GL_QUADS);				
		glColor3f(1,0,0);
		glVertex3f(-1,3.5f,-10);
		glColor3f(0,1,0);
		glVertex3f(-1,2.5f,-10);
		glColor3f(0,0,1);
		glVertex3f(0,2.5f,-10);
		glColor3f(1,1,1);
		glVertex3f(0,3.5f,-10);
	glEnd();

	// Zeichnet eine Art Fecher z.B. für Kreise (war mir per Hand aber zu viel Arbeit ;-))
	glBegin(GL_TRIANGLE_FAN);
		glColor3f(1,1,1);
		glVertex3f(3,2.5f,-10);
		glColor3f(1,0,0);
		glVertex3f(2,1.5f,-10);	
		glColor3f(0,1,0);
		glVertex3f(4,1.5f,-10);
		glColor3f(0,0,1);
		glVertex3f(4,3.5f,-10);
		glColor3f(1,1,0);
		glVertex3f(2,3.5f,-10);
	glEnd();

	// Zeichnet eine Reihe von Dreiecken (seiht ein wenig wie ein Schal auß, das Ding für den Hals im Winter lol)
	glBegin(GL_TRIANGLE_STRIP);
		glColor3f(1,0,0);
		glVertex3f(0,0,-10);
		glColor3f(0,1,0);
		glVertex3f(0,-1,-10);
		for(int x=1;x<6;x++)
		{
			glColor3f(1,0,0);
			glVertex3f(x,0,-10);
			glColor3f(0,1,0);
			glVertex3f(x,-1,-10);
		}
	glEnd();

	// Zeichnet nicht miteinander verbundene Linien
	glLineWidth(2); //is klar denke ich
	glBegin(GL_LINES);
		glVertex3f(-3,1,-10);
		glVertex3f(-2,-1,-10);

		glVertex3f(-4.5f,0,-10);
		glVertex3f(-3,-2,-10);

		glVertex3f(-1,1,-10);
		glVertex3f(-3,-1,-10);
	glEnd();

	// Zeichnet Punkte
	glColor3f(1,0,0);
	glPointSize(4); //is klar
	glBegin(GL_POINTS);
		glVertex3f(-1,-2,-10);
		glVertex3f(-0.5f,-2.4,-10);
		glVertex3f(-1.5,-1.9,-10);
		glVertex3f(-1,-2.5,-10);
		glVertex3f(-1.2,-3,-10);
		glVertex3f(0,-3.25,-10);
		glVertex3f(1,-2.45,-10);
		glVertex3f(0.8f,-2.1,-10);
	glEnd();
}