Fenstergröße fix



  • Tach,
    lese gerade das codeworx Tutorial und frage mich wie ich erzwingen kann dass im Fenstermoduss (F1) die größe nicht durch den User NICHT verändert werden kann??

    Besser währe aber noch das bei der veränderung der Größe zufort gezeichnet wird und nicht erst wenn ich die linke Maustaste loslassen wurde.

    Für alle die das Tut nicht kennen hier der Code. Sieht schwer aus ist aber denke ich für Leute die OpenGL beherschen klar.

    Bedanke mich schon mal recht herzlich für Antworten 🙂
    mfg
    CYA

    //OpenGL-API Code
    //Ich empfehle eine Auflösung von 1152*864 damit sie den Code komfortabel überblicken können
    //Code:
    
    //Binde Headerdateien in das Programm ein=========================================================================
    #include <windows.h>  //Bindet Windowsfunktionen ein
    #include <gl\glu.h>   //Bindet Glu32 ein
    #include <gl\gl.h>    //Bindet OpenGL32 ein
    #include <gl\glaux.h> //Bindet Glaux ein
    
    //Setze/Initialisiere/Definiere "Variablen"=======================================================================
    HGLRC hRC=NULL;         //Der OpenGL Rendering Context
    HDC hDC=NULL;           //Geschützter GDI Device Context
    HWND hWnd=NULL;         //Verweist später auf den Windows Handle
    HINSTANCE hInstance;	//Die Instanz der Anwendung
    
    bool keys[256]; //Array der den Status der Tastaturtasten in sich aufnimmt
    
    bool active=TRUE;  //Wenn active FALSE ist, wurde das Fenster vom Benutzer minimiert
    
    bool fullscreen=TRUE; //bool-Wert der Auskunft gibt, ob dass Programm im Vollbildmodus läuft oder nicht?
    
    LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); //WndProc wird deklariert
    
    //Funktionen======================================================================================================
    GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // Initialisierung des OpenGL-Fensters
    {
      if (height==0)
      {      
        height=1;    
      }  //height darf nicht 0 sein, damit es im späteren Programmablauf nicht zu einer Division durch 0 kommt.
    
      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.0f,(GLfloat)width/(GLfloat)height,0.1f,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.
    }
    
    int InitGL(GLvoid)
    {
      glShadeModel(GL_SMOOTH); 
      //Das Smooth Shading wird aktiviert, das sehr schöne Farbübergänge auf Körpern ermöglicht(zu empfehlen).
    
      glClearColor(0.0f, 0.0f, 0.0f, 0.0f); //Hintergrundfarbe(R,G,B,Alphafaktor)
    
      glClearDepth(1.0f); //depht buffer zurückgesetzt
    
      glEnable(GL_DEPTH_TEST); //Aktivierung des depht Tests
    
      glDepthFunc(GL_LEQUAL); //Der Typ des Depht Tests wird festgelegt
    
      glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); //GL_NICEST ist leider sehr rechenaufwendige 
    
      return TRUE; //Initialisierung scheint geklappt zu haben!
    }
    
    int DrawGLScene(GLvoid) 
    {
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //Die vorherige Szene wird vom Bildschirm gelöscht, damit 
                                                   //die neuen nicht einfach über die alten Objekte gezeichnet werden
    
      glLoadIdentity();   //modelview-Matrix wird wieder einmal zurückgesetzt
    
      return TRUE; //Alles hat geklappt
    }
    
    GLvoid KillGLWindow(GLvoid)
    {
      if (fullscreen) //Kontrolle auf Vollbildmodus
      {
        ChangeDisplaySettings(NULL,0); //Zurück zum Desktop
        ShowCursor(TRUE); //Der abgeschaltete Mauszeiger wird wieder angezeigt 
      }
    
      if (hRC) //Rendering Context (RC) vorhanden?
      {
        if (!wglMakeCurrent(NULL,NULL)) //Kann der DC und RC überhaupt gelöscht werden?
        {
          MessageBox(NULL,"Entfernen des DC und RC fehlgeschlagen.","Error",MB_OK | MB_ICONINFORMATION);
        }
    
        if (!wglDeleteContext(hRC)) //Kann der RC gelöscht werden?
        {
          MessageBox(NULL,"Entfernen des RC fehlgeschlagen.","Error",MB_OK | MB_ICONINFORMATION);
        }
          hRC=NULL; //Der RC wird NULL gesetzt, also entfernt
        }
    
       if (hDC && !ReleaseDC(hWnd,hDC)) 
       //Kann der Device Context (DC) freigegeben werden?
       {
         MessageBox(NULL,"Freigabe des Device Context fehlgeschlagen.","Error",MB_OK | MB_ICONINFORMATION);
    
         hDC=NULL; //Der DC wird entfernt
       }
    
       if (hWnd && !DestroyWindow(hWnd)) 
       //Kann das Programmfenster geschlossen werden?
       {
         MessageBox(NULL,"Konnte hWnd nicht löschen.","Error",MB_OK | MB_ICONINFORMATION);
    
         hWnd=NULL; //Setze den hWnd auf NULL
       }
    
       if (!UnregisterClass("OpenGL",hInstance)) 
       //Kann die Registrierung rückgängig gemacht werden?
    
       {
         MessageBox(NULL,"Konnte Klasse nicht entfernen.","Error",MB_OK | MB_ICONINFORMATION);
    
         hInstance=NULL; //Setze hInstance auf NULL
       }
    }
    
    BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
    {
    
      GLuint PixelFormat; //Speichert das Pixelformat
    
      WNDCLASS wc; //wc wird eine Instanz der Fensterklasse
    
      DWORD dwExStyle; //weitere Informationen
      DWORD dwStyle; //Fensterinformationen
    
      RECT WindowRect; //Speicher für aktuelle Auflösung
    
      WindowRect.left=(long)0; //Die linke Seite des Rechtecks wirtd auf 0 gesetzt
    
      WindowRect.right=(long)width; //Hier wird die gewünschte Breite des Fensters gespeichert
    
      WindowRect.top=(long)0; //Die obere Seite wird auch auf 0 gesetzt
    
      WindowRect.bottom=(long)height; //Und hier wird die Höhe abgelegt
    
      fullscreen=fullscreenflag; 
      //Hier wird fullscreen auf den Wert von fullscreenflag gesetzt, welches ja übergeben wurde
    
      hInstance = GetModuleHandle(NULL); //Die Instanz des Programmes bekommt ein Handle zugeordnet
    
      wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
      //Bei Veränderungen in der Höhe und/oder Breite, soll ne gezeichnet werden
    
      wc.lpfnWndProc = (WNDPROC) WndProc; 
      //WndProc behandelt die auftretenden Nachrichten
    
      wc.cbClsExtra = 0; //Wird nicht benötigt
      wc.cbWndExtra = 0; //und das auch nicht
      wc.hInstance = hInstance; //Die Instanz wird festgelegt
      wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); //Lädt das Standardsymbol
      wc.hCursor = LoadCursor(NULL, IDC_ARROW); //Lädt einen Cursor
      wc.hbrBackground = NULL; //Es soll kein bestimmter Hintergrund angezeigt werden
      wc.lpszMenuName = NULL; //Auch ein Menü wird nicht benötigt
      wc.lpszClassName = "OpenGL"; //OpenGL wird der Name der Klasse
    
      if (!RegisterClass(&wc)) //Versuch die Klasse zu registrieren
      {
        MessageBox(NULL,"Konnte die Fensterklasse nicht registrieren.","Error",MB_OK|MB_ICONEXCLAMATION);
        return FALSE; //FALSE zurückgeben und beenden
      }
    
      if (fullscreen) //Soll im Vollbildmodus gestartet werden
      {
    
        DEVMODE dmScreenSettings; //Instanz von DEVMODE wird erzeugt
    
        memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); //Diese wird geleert
    
        dmScreenSettings.dmSize=sizeof(dmScreenSettings); //dmsize soll genauso groß wie die dmScreenSettings sein
    
        dmScreenSettings.dmPelsWidth = width; //Die drei Werte (height, width und bits) wurden der Prozedur übergeben
    	                                      //und werden nun in dmScreenSettings gespeichert
    
        dmScreenSettings.dmPelsHeight = height;
        dmScreenSettings.dmBitsPerPel = bits; 
        dmScreenSettings.dmFields=DM_BITSPERPEL|
        DM_PELSWIDTH|DM_PELSHEIGHT; //Hier werden die drei Werte in einem Ausdruck gespeichert
    
        if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)
            !=DISP_CHANGE_SUCCESSFUL)    
        {
    
        //CDS_FULLSCREEN blendet zusätzlich die Startleiste aus
          MessageBox(NULL,"Der gewünschte Vollbildmodus wird nicht unterstützt. Das Programm wird beendet","Error",MB_OK|MB_ICONEXCLAMATION);
          return FALSE; //Beende
    
        }
      }
    
      if (fullscreen) 
      //Konnte in den Vollbildmodus geschaltet werden? 
      //(Wenn nicht, wird ja im Fenster weitergemacht!)
      {
        dwExStyle=WS_EX_APPWINDOW; //Fenstereigenschaften
        dwStyle=WS_POPUP;
        ShowCursor(FALSE); //Der Mauszeiger wird nicht angezeigt
      }
    
      else
      {
    
        dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; 
        //Das Fenster soll zusätzlich einen 3D Rahmen bekommen
    
        dwStyle=WS_OVERLAPPEDWINDOW; 
        //Ein typisches Windowsfenster mit Minimieren, Maximieren, etc
      }
    
      AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); 
      //Fenster wird angepasst
    
      if (!(hWnd=CreateWindowEx( dwExStyle, //Die erweiterten Eigenschaften des Fensters
      "OpenGL", //Der Name der Klasse
      title, //Der Titel des Fensters
      WS_CLIPSIBLINGS | //Wird von OpenGL benötigt
      WS_CLIPCHILDREN | //Wird auch von OpenGL benötigt
      dwStyle, //auch Eigenschaften des Fensters
      0, 0, //Die Position des zu erstellenden Fensters
      WindowRect.right-WindowRect.left, 
      //Hier werden die ermittelten Werte für die Breite eingesetzt
      WindowRect.bottom-WindowRect.top, //und hier für die Länge
      NULL, //Es soll kein übergordnetes Fendster erstellt werden
      NULL, //kein Menü
      hInstance, //Die Instanz wird übergeben
      NULL))) //Wird nicht benötigt
    
      {
        KillGLWindow(); //Grafikeinstellungen zurücksetzen
        MessageBox(NULL,"Fenster konnte nicht erstellt werden.","Error",MB_OK|MB_ICONEXCLAMATION);
        return FALSE; 
      }
    
      static PIXELFORMATDESCRIPTOR pfd= 
      //pdf ist jetzt ein PIXELFORMATDESCRIPTOR
      {
        sizeof(PIXELFORMATDESCRIPTOR), 
        //Die größe muss natürlich stimmen
        1, //Versionsnummer
        PFD_DRAW_TO_WINDOW | 
        //Das Format muss in Fenster sichtbar sein können
        PFD_SUPPORT_OPENGL | 
        //OpenGL muss unterstützt werden
        PFD_DOUBLEBUFFER, 
        //Double Buffering muss unterstützt werden
        PFD_TYPE_RGBA, 
        //Das RGBA (Rot,Grün,Blau,Alpha(Transparenz)) muss unterstützt werden
        bits, //Die Farbtiefe, die schon übergeben wurde, wird hier benötigt
        0, 0, 0, 0, 0, 0, // wird nicht benötigt
        0, //kein Alpha Buffer
        0, //Shift Bit ignoriert
        0, //kein Accumulation Buffer
        0, 0, 0, 0, // nicht benötigt
        16, //16Bit Z-Buffer (Depth Buffer)
        0, //kein Stencil Buffer
        0, //kein Auxiliary Buffer
        PFD_MAIN_PLANE, //Die Hauptebene auf die später gezeichnet wird
        0, //unwichtig
        0, 0, 0 //keine Ebenenmasken benötigt
      };
    
     if (!(hDC=GetDC(hWnd))) //Versuch, den DC zu bekommen
       {
         KillGLWindow(); //Alles rückgängig machen
         MessageBox(NULL,"Konnte keinen DC erstellen.","Error",MB_OK|MB_ICONEXCLAMATION);
         return FALSE; //FALSE zurückgeben, beenden
       }
    
      if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd))) 
      // Kann Windows ein passendes finden? 
      { 
    	//Falls keins gefunden werden kann:
        KillGLWindow(); //Alles zurücksetzen
        MessageBox(NULL,"Konnte kein passendes Pixelformat finden.","Error",MB_OK|MB_ICONEXCLAMATION);
        return FALSE; //FALSE zurück und Ende
      }
    
      if(!SetPixelFormat(hDC,PixelFormat,&pfd))
      //Kann das Pixelformat gesetzt werden?
        {
          KillGLWindow(); //Leider nicht, Fehlerpopup und raus
          MessageBox(NULL,"Konnte Pixelformat nicht setzen.","ERROR",MB_OK|MB_ICONEXCLAMATION);
          return FALSE; //FALSE zurück und raus
       }
    
      if (!(hRC=wglCreateContext(hDC))) //Versuch den RC zu bekommen
        {
          KillGLWindow(); //Alles rückgängig machen
          MessageBox(NULL,"Konnte keinen Rendering Context bekommen.","Fehler",MB_OK|MB_ICONEXCLAMATION);
          return FALSE;
        }
    
      if(!wglMakeCurrent(hDC,hRC)) //Versuch den RC zu aktivieren
      {
        KillGLWindow(); //hat nicht geklappt, also alles zurück
        MessageBox(NULL,"Konnte den Rendering Context nmicht aktivieren.","Fehler",MB_OK|MB_ICONEXCLAMATION);
        return FALSE;
      }
    
      ShowWindow(hWnd,SW_SHOW); //Fenster anzeigen
      SetForegroundWindow(hWnd); //Priorität des Programms wird erhöht
      SetFocus(hWnd); //Tastatureingaben werden jetzt an das Programm geleitet
    
      ReSizeGLScene(width, height); //Die Perspektive wird aktiviert
    
      if (!InitGL()) //Initialisiere das OpenGL Fenster
      {
        KillGLWindow(); //Falls das nicht geklappt haben sollte alles rückgängig machen
    
        MessageBox(NULL,"Initialisierung fehlgeschlagen.","Error",MB_OK|MB_ICONEXCLAMATION);
        return FALSE; //FALSE wird zurückgegeben
      }
    
      return TRUE; //Alles hat geklappt
    
    }
    
    LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
    
      switch (uMsg) //Sind Nachrichten in der Nachrichtenschleife?
      {
    
        case WM_ACTIVATE: //Ist das Programm aktiv?
        {
          if (!HIWORD(wParam)) //Ist das Programm nicht minimiert?
          {
            active=TRUE; //active wird TRUE
          }
    
         else
         {
           active=FALSE; //Programm ist minimiert
         }   
    
         return 0; //Rückgabe: 0
       }
    
        case WM_SYSCOMMAND: //Ist ein Systemkommando 
                            //(wie z.B. "Bildschirmschoner soll gestartet werden") vorhanden?
        {
          switch (wParam) //wParam würde diesen Befehl enthalten
          {
            case SC_SCREENSAVE: 
            //Versucht Windows den Bildschirmschoner zu starten
    
            case SC_MONITORPOWER: 
            //Soll der Monitor in den Stromsparmodus gehen?
    
            return 0; 
            //Beide Fälle werden durch die Rückgabe von 0 verhindert
          }
          break; //Das wars.
        }
    
        case WM_CLOSE: //Ist eine WM_CLOSE Nachricht vorhanden?
        {
          PostQuitMessage(0); 
          //Die Nachricht zum Beenden wird "gepostet"
    
          return 0; //und zurück.
        }
    
        case WM_KEYDOWN: //Drückt der Benutzer eine Taste???
        {
          keys[wParam] = TRUE; 
          // Der Wert im Array keys[] der dem Code der Taste entspricht, wird true gesetzt
    
          return 0; //und zurück
        }
    
        case WM_KEYUP: //Wurde eine Taste losgelassen?
        {
          keys[wParam] = FALSE; 
          //Wen ja, dann soll dieser Wert im Array keys[] auf FALSE gesetzt werden
          return 0; //und zurück.
        }
    
        case WM_SIZE: //Die Fenstergröße wurde geändert
        {
          ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); 
          //LoWord ist die Breite, HiWord die Höhe, 
          //ReSizeGLScene() verändert dann die 
          //Größe des OpenGL-Fensters
          return 0; //und zurück
        }
      }
    
      return DefWindowProc(hWnd,uMsg,wParam,lParam);
    }
    
    //HAUPTPROGRAMMFUNKTION=========================================================>>>>>>Hier startet das ganze<<<<<<
    int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
    {
    
      MSG msg;
      BOOL done=FALSE;
    
      if (!CreateGLWindow("Daniel Knobes kleines schwarzen Fenster",1024,768,32,fullscreen))
      {
        return 0; //Falls ein Fehler auftrat, beenden
      }
    
      while(!done) //Solange done nicht TRUE ist:
      {
    
        if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) 
        //Sind Nachrichten vorhanden
        {
    
        if (msg.message==WM_QUIT) 
        //Liegt eine Nachricht zum beenden vpr?
        {
          done=TRUE; // Wenn dem so ist, wird done 
                     // true und das Programm beendet
        }
    
        else 
        //Wenn nicht werden die anderen Nachrichten ausgewertet
    
        {
          TranslateMessage(&msg); //Umformen der Nachricht
          DispatchMessage(&msg); 
        }
      }
    
      else //Falls keine Nachrichten bereit liegen
      {
    
        if (active) //Programm aktiv?
        {
          if (keys[VK_ESCAPE]) //Wurde ESC gedrückt?
          {
            done=TRUE; //Wenn ESC gedrückt wurde, beenden
          }
    
          else //ESC wurde nicht gedrückt
          {
    
            DrawGLScene(); //Die Szene ausgeben
            SwapBuffers(hDC); //Die Puffer werden getauscht
          }
        }
    
        if (keys[VK_F1]) //Wird F1 gedrückt?
        {
          keys[VK_F1]=FALSE; //Es darf nicht gewartet werden bis F1 losgelassen wird, ansonsten könnte das Bild 
    	                     //mehrmals hin und herschalten
    
          KillGLWindow(); //Das aktuelle Fenster wird gelöscht
          fullscreen=!fullscreen; 
          //fullscreen erhält seinen entgegengesetzten Wert (bei FALSE TRUE, und bei TRUE FALSE.)
    
          if (!CreateGLWindow("Fenstermodus",1024,768,32,fullscreen))    
          {
            return 0; //Zurück falls ein Fehler auftrat
          }
        }
      }
    }
    
      KillGLWindow(); //Das Fenster löschen.
      return (msg.wParam); //Das Programm verlassen.
    }
    


  • das gehört ganz klar in den winapi bereich des forums, und hat generell nichts mit spieleprogrammeirung zu tun



  • eigentlich ist das ein defizit der grundkenntnis von c, sonst würde er einfach die betreffende zeile auskommentieren... deswegen schieb ich das lieber in c forum.

    rapso->greetes();



  • Dieser Thread wurde von Moderator/in rapso aus dem Forum Spiele-/Grafikprogrammierung in das Forum ANSI C verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.



  • dwStyle=WS_OVERLAPPEDWINDOW;
    //Ein typisches Windowsfenster mit Minimieren, Maximieren, etc

    Du musst da dann nur die gewünschten Window-Styles einsetzen.

    http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/WinUI/WindowsUserInterface/Windowing/Windows/WindowReference/WindowStyles.asp

    z.B. diese Kombination:
    WS_BORDER, WS_MINIMIZEBOX WS_SYSMENU und WS_CAPTION
    (Fenster mit nicht-anfassbarem Rahmen, Titelleiste mit Schließen und Minimieren-Button)



  • thx für die Hilfe.
    mfg 🙂


Anmelden zum Antworten