4. OpenGl Fenster umgeben von MFC Elementen

OpenGl Fenster umgeben von MFC Elementen

  • M

    Ich versuche zur Zeit ein Programm zu schreiben, dass bestimmte mathematische Probleme 3D darstellt. Da ich ein Neuling in C++ und OpenGl bin, glaube ich dass ich einfach irgendwo etwas vergessen habe.

    Meine Vorgehensweise:
    -Normale WINAPI WinMain Funktion, die erst eine WNDCLASSEX anlegt, die registriert und dann mit CreateWindow ein HauptFenster erstellt. (Ich selbst vermute den Fehler schon hier bei den style (wincl.style = CS_DBLCLKS;), vielleicht fehlt da noch irgendwas???)
    -Dann habe ich eine Klasse geschrieben, die dann die GUI für mich regelt (Bis jetzt: Ein Testbutton mit CreateWindow anlegen). Ebenso habe ich alle WS_.... Befehle von der Callback Funktion hierher durch Aufrufen einer anderen Funktion umgeleitet (auch später WS_PAINT um das OpenGl-Fenster immer neu zu zeichnen).
    ----------------------------bis hierher geht alles prima---------------------
    -Eine nächste Klasse sollte dann gewisse Kontroll Funktionen für OpenGl bereitstellen:
    Ich konstruiere wieder ein HWND mit CreateWindow, womit diesmal aber ein
    STATIC Element auf dem HauptFenster platziert wurde. Dann habe ich versucht
    ganz normal, wie bei fast jedem Code, OpenGl dem DeviceContext dieses
    Elements zu übergeben.
    Um die Sache zu testen habe ich dann einfach mal versucht ein Triangle zu
    zeichen, was überhaupt nicht mehr funktionierte. Es wurde noch nicht einmal
    der Hintergrund des ehemaligen STATIC auf Schwarz gewechselt was durch die
    entsprechenden Funktionen doch geschehen sollte.

    PS: Ich benutze Dev-Cpp
    PPS: Reine OpenGL Anwendungen ohne diese MFC Sachen funktionieren.
    PPPS: Vieleicht war das auch der falsche Ansatz, könnte man da was mit GLUT tricksen?

    0
  • S

    Es sind WM_ nicht WS_ Nachrichten. 🤡 ➡ 💡

    Ansonsten natürlich viel zu ungenau. So kann man Dir nicht helfen.

    ➡ Bitte den örtlichen Wahrsager besuchen.

    0
  • M

    ok - hier kommt der (angepasste) Quelltext:

    #include <windows.h>
#include "OpenGLDevice.h"  //Hilfsklasse zum erstellen, suche bei google

LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
void drawGl();

char szClassName[ ] = "WindowsApp";

HWND hwnd;
OpenGLDevice open;

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)

{

    MSG messages;           
    WNDCLASSEX wincl;        

    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;     
    wincl.style = CS_DBLCLKS;
    wincl.cbSize = sizeof (WNDCLASSEX);
    wincl.hIcon = LoadIcon (NULL, IDI_WINLOGO);
    wincl.hIconSm = LoadIcon (NULL, IDI_WINLOGO);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                     
    wincl.cbClsExtra = 0;                      
    wincl.cbWndExtra = 0;                      
    wincl.hbrBackground = (HBRUSH) COLOR_MENU;

    if (!RegisterClassEx (&wincl))
        return 0;

    hwnd = CreateWindow(szClassName, "HELLO",
                        WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
                        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
                        NULL, NULL, hThisInstance, NULL);

     //hier wird ein Element auf dem Fenster platziert und an OpenGl übergeben      

      HWND w = CreateWindow("STATIC",NULL,WS_CHILD | WS_VISIBLE, 100,100,200,200,hwnd,NULL,hinst,NULL); 

      open.create(w,0);

      drawGl();

      ShowWindow (hwnd, nFunsterStil);
       while (GetMessage (&messages, NULL, 0, 0))
    {

        TranslateMessage(&messages);
        DispatchMessage(&messages);
    }

        return messages.wParam;
}

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message) {
        case WM_DESTROY:
            PostQuitMessage (0);   
            break;
        case WM_PAINT:
            drawGl();
        default:       
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

void drawGl()
{
   glShadeModel(GL_SMOOTH);
   glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
   glClearDepth(1.0f); 
   glEnable(GL_DEPTH_TEST); 
   glDepthFunc(GL_LEQUAL); 
   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glLoadIdentity();

   glBegin(GL_TRIANGLES);
      glColor3f(1.0f,0.0f,0.0f);
      glVertex3f(1.0f,-1.0f,0.0f);
      glColor3f(0.0f,1.0f,0.0f);
      glVertex3f(-1.0f,-1.0f,0.0f);
      glColor3f(0.0f,0.0f,1.0f);
      glVertex3f(0.0f,1.0f,0.0f);
   glEnd();
}
    0
  • M

    natürlich kommen da noch die includes für opengl und die anweisungen zum linken dazu - aber sonst sollte es doch funktionieren 😕

    0
  • B

    nicht, dass es mich was angeht, aber MFC kannst du mit Dev-C++ nicht verwenden. Und der Quellcode, den du gepostet hast, ist WinAPI, kein MFC... du solltest die beiden nicht verwechseln! MFC ist der Microsoft-Eigene C++ Wrapper fuer die WinAPI, der dem Visual Studio beiliegt.

    0
  • *

    und wenn du kein MFC verwendest aber auf standart ctrl zurückgreifst musst du die comctrl32.lib linken und die comctrl32.h includieren und InitCommonCtrl()

    0
  • *

    lol. Der hat Standart zensiert 🤡

    0
  • S

    (D)Evil schrieb:

    lol. Der hat stan**** zensiert 🤡

    Weil's falsch ist.

    0

  • (D)Evil schrieb:

    lol. Der hat stan**** zensiert 🤡

    ROFL

    Bye, TGGC (Wähle deine Helden)

    0
  • M

    tja - ich war experimentierfreudig und habe das problem mal in delphi umgesetzt - funz auch nicht - ist mein computer schrott 😕
    hier der quelltext:

    unit Unit1;

    interface

    uses
    Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, dglOpenGl,
    ExtCtrls;

    type
    TForm1 = class(TForm)
    Panel1: TPanel;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);

    procedure initGl();
    procedure FormPaint(Sender: TObject);
    private
    { Private-Deklarationen }
    public
    { Public-Deklarationen }
    end;

    var
    Form1: TForm1;
    draw_context: HDC;
    render_context: HGLRC;

    implementation

    {$R *.DFM}

    procedure TForm1.FormCreate(Sender: TObject);
    var trc: TRCOptions;
    begin
    Set8087CW($133f); //Deaktivieren aller Gleitkommatafehler
    InitOpenGL;
    draw_context := GetDC(self.Panel1.Handle);
    trc:=[opDoubleBuffered];
    render_context := CreateRenderingContext(draw_context,trc,32,16,0,0,0,PFD_MAIN_PLANE);
    ActivateRenderingContext(draw_context, render_context);

    end;

    procedure TForm1.FormDestroy(Sender: TObject);
    begin
    DeactivateRenderingContext; // Deactivates the current context
    wglDeleteContext(render_context);
    ReleaseDC(self.Panel1.Handle, draw_context);
    end;

    procedure TForm1.initGl();
    var width,height:Integer;
    begin

    width:=300;
    height:=300;

    glLoadIdentity();
    glShadeModel(GL_SMOOTH);
    // Das Smooth Shading wird aktiviert, das
    // sehr schöne Farbübergänge auf Körpern ermöglicht.

    glClearColor(0.0, 0.0, 0.0, 0.0);
    // In diesem Falle ein schwarzer Hintergrund

    glClearDepth(1.0);
    // depht buffer zurückgesetzt

    glEnable(GL_DEPTH_TEST);
    // Aktivierung des depht Tests (dazu später mehr.)

    glDepthFunc(GL_LEQUAL);
    // Der Typ des Depht Tests wird festgelegt

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    // Perspektive wird festgelegt
    glEnable(GL_NORMALIZE);

    glPolygonMode( GL_BACK, GL_LINE );

    glPolygonMode( GL_FRONT, GL_FILL );

    if (height=0) then height:=1;

    glViewport(0, 0, width, height); // Hier wird der Mittelpunkt auf den die Perspektive zuläuft
    // zurückgesetzt.
    glMatrixMode(GL_PROJECTION);
    // Hier wird die Projektionsmatrix festgelegt

    glLoadIdentity();
    // und angepasst
    gluPerspective(45.0,width/height, 0.1,100.0);
    //glOrtho(-width/height, width/height, -1.0f, 1.0f, 100.0f, -100.0f);
    // Hier wird die das Verhältnis der Höhe zur Breite übergeben
    // und der Verzerrungswinkel von 45 Grad übergeben
    glMatrixMode(GL_MODELVIEW);
    // Hier wird die sogenannte modelview-Matrix festgelegt

    glLoadIdentity();
    // und angepasst.

    end;

    procedure TForm1.FormPaint(Sender: TObject);
    begin
    glBegin(GL_TRIANGLES);
    glColor3f(0.0,1.0,0.0);
    glVertex3f(0.0,0.0,-0.5);
    glVertex3f(-0.5,0.5,-0.5);
    glVertex3f(0.5,0.5,-0.5);
    glEnd();
    end;

    end.

    PS: Diesmal Delhpi 4 mit OpenGl ver1.5
    PPS: Das Formula besitzt wie erkennbar nur ein Panel mit 300px Breite und Höhe

    0
  • S

    Lad' Dir doch einfach mal die Projekte auf

    http://www.delphigl.com/

    http://www.codeproject.com/

    und schau' mal wie die das machen... 🙄

    0
  • M

    Yo, jetzt hab ne Funktion gefunden die ideal für mein Problem ist - hier ist der Qelltext für die, die es wirklich wissen wollen:

    void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC)
{
    PIXELFORMATDESCRIPTOR pfd;
    int iFormat;

    /* get the device context (DC) */
    *hDC = GetDC (hWnd);

    /* set the pixel format for the DC */
    ZeroMemory (&pfd, sizeof (pfd));
    pfd.nSize = sizeof (pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | 
      PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 32;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
    iFormat = ChoosePixelFormat (*hDC, &pfd);
    SetPixelFormat (*hDC, iFormat, &pfd);

    /* create and enable the render context (RC) */
    *hRC = wglCreateContext( *hDC );
    wglMakeCurrent( *hDC, *hRC );

}

    Anwendung: Einfach das Handle für das Fensterelement in das gezeichnet werden soll übergeben, mit zwei leeren Zeigern auf DC und RC - fertig

    [edit="rapso"]codetags[/edit]

    0
Anmelden zum Antworten