OpenGL-Fensterinitialisierung

Ich habe ein Problem mit dem Initialisieren eines Fensters in OpenGL.
Es wird immer der Fehler zuürckgegeben, dass das Fenster nicht erstellt worden konnte.

Das gesamte Projekt findet ihr unter: http://www.djs4life.de/HelloOGL.zip

Edit:
Bitte aussagekräftige Überschriften wählen. Danke!

[ Dieser Beitrag wurde am 04.07.2003 um 05:45 Uhr von Jansen editiert. ]

TFX

Servus,

hier mal mal ein Grundgerüst für eine OpenGl Anwendung mit dem C++ Builder

nimm ein neues Projekt und baue es folgendermaßen auf.

in die *.h Datei

#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include <ExtCtrls.hpp>
#include <gl/gl.h>
#include <gl/glu.h>
class TForm1 : public TForm
{
__published:    // Von der IDE verwaltete Komponenten
        void __fastcall FormCreate(TObject *Sender);
        void __fastcall FormDestroy(TObject *Sender);
        void __fastcall FormResize(TObject *Sender);
        void __fastcall FormKeyPress(TObject *Sender, char &Key);

private:    // Anwender-Deklarationen

public:     // Anwender-Deklarationen
        __fastcall TForm1(TComponent* Owner);

        void __fastcall IdleLoop(TObject*, bool&);
        void __fastcall RenderGLScene();
        void __fastcall SetPixelFormatDescriptor();
        void __fastcall SetupRC();
};
extern PACKAGE TForm1 *Form1;

in die *.cpp Datei

////////////////////////////////////////////////////////////////////////////////
//       Dies ist ein Grundgerüst für eine OpenGL Anwendung mit dem           //
//                         Borland C++ Builder                                //
////////////////////////////////////////////////////////////////////////////////
#include <vcl.h>
#pragma hdrstop
#include "main.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
 Application->OnIdle = IdleLoop;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::IdleLoop(TObject*, bool& done)
{
 done = false;
 RenderGLScene();
 SwapBuffers(hdc);
}
//---------------------------------------------------------------------------
void __fastcall TForm1::RenderGLScene()
{

  //Hier die OpenGL einfügen

}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
  // Application->MessageBox("Tasten 1 - 5 und +/- zum steuern","Wichtig");
    hdc = GetDC(Handle);
    SetPixelFormatDescriptor();
    hrc = wglCreateContext(hdc);
    wglMakeCurrent(hdc, hrc);
    SetupRC();
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SetupRC()
{
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);                          //Farbe des Fenters  letzter Wert ist ALPHA-Faktor(Blendung)
    glClear(GL_COLOR_BUFFER_BIT);                                  //OpenGl Oberfläche löschen
    glFlush();                                                     
}
//--------------------------------------------------------------------------
void __fastcall TForm1::FormDestroy(TObject *Sender)              //alles von OpenGl wieder freigeben
{
    ReleaseDC(hdc,hrc);
    wglMakeCurrent(hdc, NULL);
    wglDeleteContext(hrc);
}
//--------------------------------------------------------------------------- //
void __fastcall TForm1::SetPixelFormatDescriptor()                            // Standard -->muss immer da sein
{                                                                             //
    PIXELFORMATDESCRIPTOR pfd = {                                             //
        sizeof(PIXELFORMATDESCRIPTOR),                                        //
        1,                                                                    //
        PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,           //
        PFD_TYPE_RGBA,                                                        //
        24,              //24/16/8/4 Bit                                      //
        0,0,0,0,0,0,                                                          //
        0,0,                                                                  //
        0,0,0,0,0,                                                            //--> muss alles so sein (Standard in OpenGl)
        32,     //32bit Farbtiefe                                             //
        0,                                                                    //
        0,                                                                    //
        PFD_MAIN_PLANE,                                                       //
        0,                                                                    //
        0,0,0                                                                 //
        };                                                                    //
    PixelFormat = ChoosePixelFormat(hdc, &pfd);                               //
    SetPixelFormat(hdc, PixelFormat, &pfd);                                   //
}                                                                             //
//--------------------------------------------------------------------------- //
void __fastcall TForm1::FormResize(TObject *Sender)
{
    GLfloat nRange = 200.0f;
    glViewport(0, 0, ClientWidth, ClientHeight); 
    glMatrixMode(GL_PROJECTION); 
    glLoadIdentity();
    if (ClientWidth <= ClientHeight)
       glOrtho(-nRange, nRange, -nRange*ClientHeight/ClientWidth, 
                nRange*ClientHeight/ClientWidth, -nRange, nRange); 
    else 
       glOrtho(-nRange*ClientWidth/ClientHeight, nRange*ClientWidth/ClientHeight, 
                -nRange, nRange, -nRange, nRange);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}
//---------------------------------------------------------------------------

Jansen

Ein Verweis auf die beim BCB mitgelieferten OpenGL-Beispiele hätte es nicht getan? Denn offensichtlich stammt dein Code doch aus genau diesen Beispielen!?

Hoeen

ich starte mal einfach keinen neuen thread sondern stell meine frage in diesen thread

ich frage mich, ob man die initialisierung noch etwas optimieren kann (ich nutze die obere initialisierung fast 1 zu 1)! ich habe nämlich das problem, dass mein programm etwas zuckelt und ich nicht weiß, wie ich es weiter optimieren kann! die berechnungen laufen schon optimal (also meiner meinung nach)!

leider kenn ich mich halt nicht so gut mit opengl aus! also meine frage: kann ich den code noch etwas optimieren? und wie?

1ntrud0r

source

Hoeen

Hier kann man sich das programm mit einer beispieldatei und einem code-auszug (die opengl-initialisierung) ziehen! ist ca. 900 kb groß!

1ntrud0r

ich schaus mir mal an

1ntrud0r

bitte so compilieren das man es auf kriegt ..
sourcen wären besser da .. ich nicht sehr viel vertrauen in tüftler hab ..

Hoeen

1ntrud0r schrieb:

bitte so compilieren das man es auf kriegt ..
sourcen wären besser da .. ich nicht sehr viel vertrauen in tüftler hab ..

ich verstehe jetzt leider nicht so recht, was du von mir möchtest also du kannst die datei so entpacken und die exe-datei so starten! du brauchst keine zusätzlichen dlls oder sonstiges...

den code zur initialisierung von opengl poste ich hier einfach mal rein:

__fastcall TFrMain::TFrMain(TComponent* Owner)
        : TForm(Owner)
{
  GetOpenGLRC();                    // passende Eigenschaften suchen
   if(OpenGLCap)
     readyToDraw = true;
   else {
     readyToDraw = false;
		  MessageBox(NULL, "Exit program !"
                      "No OpenGL capabilities found.",
                      "Error", MB_OK);
   }
   bv.MBL = false;
   bv.MBM = false;
   bv.MBR = false;
   bv.BreFileLoaded = false;
   bv.CadFileLoaded = false;
   bv.FirstStart = true;
   bv.firstload = true;
   bv.zminmax = false;
}
//---------------------------------------------------------------------
// OpenGL mit Fenster verbinden
//---------------------------------------------------------------------
void  __fastcall TFrMain::GetOpenGLRC()
{
  OpenGLCap = false;                 // OpenGL-Faehigkeit wird nicht erwartet

  PIXELFORMATDESCRIPTOR pixelFormat =
  {
			sizeof(PIXELFORMATDESCRIPTOR),  // Size of this structure
   	1,                              // Version of this structure
     PFD_SUPPORT_OPENGL |            // Support OpenGL calls in window
     PFD_DRAW_TO_WINDOW |            // Draw to Window (not to bitmap)
     PFD_DOUBLEBUFFER,               // Double buffered mode
     PFD_TYPE_RGBA,                  // RGBA Color mode
     16,                             // prefered color depth
     0, 0, 0, 0, 0, 0,               // color bits (ignored)
     0,                              // no alpha buffer
     0,                              // alpha bits (ignored)
     0,                              // no accumulation buffer
     0, 0, 0, 0,                     // accum bits (ignored)
     16,                             // Size of depth buffer
     0,                              // no stencil buffer
     0,                              // no auxiliary buffers
     PFD_MAIN_PLANE,                 // Draw in main plane (main layer)
     0,                              // reserved (fuer schlechte Zeiten ;-))
     0, 0, 0  };                     // no layer, visible, damage masks

  // Handle ist vom Eltern-Widget
  winDeviceContext = GetDC( Handle );

  // Schau'n, ob man die gewuenschten Eigenschaften bekommt
  int pixelFormatNr = ChoosePixelFormat( winDeviceContext,
  																		   &pixelFormat);
  if( pixelFormatNr == 0 )  {
  		MessageBox(NULL, "ChoosePixelFormat() failed:  "
               	     "Cannot find a suitable pixel format.",
                 	   "Error", MB_OK);
  }
  // ansonsten versuchen, das Ding zu setzen
  else if( SetPixelFormat( winDeviceContext,
  													pixelFormatNr,
                           &pixelFormat      ) == FALSE )  {
		 MessageBox(NULL, "SetPixelFormat() failed:  "
                     "Cannot set format specified.",
                     "Error", MB_OK);
  }
	 else {                               // wir haben was passendes gefunden
  	 // endgueltig verbinden
    glRenderingContext = wglCreateContext( winDeviceContext );
    wglMakeCurrent( winDeviceContext, glRenderingContext );

    // die Faehigkeit festhalten und auf DoubleBuffer checken
    OpenGLCap = true;
		 doubleBuffer = true; // pauschale Annahme
	 }
  //glDepthFunc(GL_LESS);
  glEnable(GL_DEPTH_TEST);
  CBRotFac->ItemIndex = 0;
}
//---------------------------------------------------------------------------

1ntrud0r

Hoeen schrieb:

ich verstehe jetzt leider nicht so recht, was du von mir möchtest also du kannst die datei so entpacken und die exe-datei so starten! du brauchst keine zusätzlichen dlls oder sonstiges...

nein ich leider nicht ... da du die runtime library vermutlich nicht statisch gelinkt hast.

Hoeen

1ntrud0r schrieb:

nein ich leider nicht ... da du die runtime library vermutlich nicht statisch gelinkt hast.

jo, hattest recht! inzwischen liegt ne neue datei auf dem webspace! kannst ja nochmal versuchen...