Dodanie tylko kilka linijek do kodu --> pilnie

0

Mam pytanie --> mógłby mi ktoś do tego kodu co zaraz dam dodać taka opcję jak:
Zapytanie uzytkownika o to czy włączyć fullscreen : Yes, No --> jesli yes to sie włączy jesli no to nie
Oto kod:

#define WIN32_LEAN_AND_MEAN

/////////////////////
Pliki nazgłówkowe
/////////////////////
#include<windows.h>
#include<gl/gl.h>
#include<gl/glu.h>
#include<gl/glaux.h>

////////////////////
Zmienne globalne
////////////////////
bool fullScreen = true; //aplikacja rozpocznie sie w trybie pelnoekranowym
float angle=0.0f;
HDC g_HDC; //kontekst urządzenia

///////////////////////////////////////////////////////////////
funkcja okreslająca format pikseli dla kontekstu urządzenia
///////////////////////////////////////////////////////////////
void SetupPixelFormat(HDC hDC)
{
int nPixelFormat;
static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), //rozmiar struktury
1, //domyslna wersja
PFD_DRAW_TO_WINDOW| //grafika w oknie
PFD_SUPPORT_OPENGL| //grafika w Opengl
PFD_DOUBLEBUFFER, //podwójne buforowanie
PFD_TYPE_RGBA, //tryb kolorów RGBA
32, //32-bitowy opsi kolorów
0, 0, 0, 0, 0, 0, //nie specyfikuje bitów kolorów
0, //bez bufora alfa
0, //ignoruje bit przesuniecia
0, //bez bufora akumulacji
0, 0, 0, 0, //ignoruje bity akumulacji
16, //16-bitowy bufor Z
0, //bez bufora powielania
0, //bez buforów pomocniczych
PFD_MAIN_PLANE, //główna płaszczyzna rysowania
0, //zarezerwowane
0, 0, 0,}; //ignoruje maski warstw

//wybiera najodpowiedniejszy format pixeli
nPixelFormat = ChoosePixelFormat(hDC, &pfd);

//okresla format pixeli dla kontekstu urządzenia
SetPixelFormat(hDC, nPixelFormat, &pfd);
}

//////////////////////
procedura okinkowa
//////////////////////
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HGLRC hRC; //kontekst tworzenia grafiki
static HDC hDC; //kontekst urzadzenia
int width, height; //szerokosc i wysokos okna

switch(message)
{
case WM_CREATE: //okno jest tworzone
hDC = GetDC(hwnd); //pobiera kontekst urządzenia dla okna
g_HDC = hDC;
SetupPixelFormat(hDC); //wywołuje funkcję okreslająca format pixeli
//tworzy kontekst tworzenia grafiki i czyni go bieżącym
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
return 0;
break;

case WM_CLOSE: //okno jest zamykane
//dezaktywuje bieżący kontekst i usuwa go
wglMakeCurrent(hDC, NULL);
wglDeleteContext(hRC);
//wstaiwa komunikat WM_QUIT do kolejki
PostQuitMessage(0);
return 0;
break;

case WM_SIZE:
height = HIWORD(lParam); //pobiera nową wysokosc i szerokos okna
width = LOWORD(lParam);

if (height==0){height =1;}
//nadaje nowe wymiary oknu OpenGl
glViewport(0, 0, width, height);
//okresla macierz rzutowania
glMatrixMode(GL_PROJECTION);
//resetuje macierz rzutowania
glLoadIdentity();
//wyznacza proporcje obrazu
gluPerspective(45,(GLfloat)width/(GLfloat)height,1,1000);
glMatrixMode(GL_MODELVIEW); //okresla macierz widoku modelu
glLoadIdentity();
return 0;
break;

default:
break;
}

return (DefWindowProc(hwnd, message, wParam, lParam));
}

///////////////////////////////////////////////////////
punkt w którym rozpoczyna sie wykonwyanie aplikacji
///////////////////////////////////////////////////////
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEX windowClass; //klasa okien
HWND hwnd; //uchwyt okna
MSG msg; //komunikat
bool done; //znacznik zakonczenia aplikacji

//definicja klasy okna
windowClass.cbSize= sizeof(WNDCLASSEX);
windowClass.style= CS_HREDRAW | CS_VREDRAW;
windowClass.lpfnWndProc= WndProc;
windowClass.cbClsExtra= 0;
windowClass.cbWndExtra= 0;
windowClass.hInstance= hInstance;
windowClass.hIcon= LoadIcon(NULL, IDI_APPLICATION);//domyslna ikona
windowClass.hCursor= LoadCursor(NULL, IDC_ARROW); //domyslny kursor
windowClass.hbrBackground= NULL; //bez tła
windowClass.lpszMenuName= NULL; //bez menu
windowClass.lpszClassName= "Moja Klasa";
windowClass.hIconSm= LoadIcon(NULL, IDI_WINLOGO); //logo windows
//rejestruje klasę okna
if(!RegisterClassEx(&windowClass))
return 0;

//tworzy okno
hwnd = CreateWindowEx(NULL, //rozszerzony styl okna
"Moja Klasa", //nazwa klasy
"Aplikacja OpenGl", //nazwa aplikacji
WS_OVERLAPPEDWINDOW | WS_VISIBLE |
WS_SYSMENU | WS_CLIPCHILDREN|
WS_CLIPSIBLINGS, //styl
100, 100, //współrzędne x,y
600, 600, //szerokosc i wysokosc
NULL, //uchwyt okna nadrzędnego
NULL, //uchwyt menu
hInstance, //instancja aplikacji
NULL); //bez dodatkowych parametrów

//sprawdza czy utworzenie okna nie powiodło się w przeciwnym razie hwnd ma wartosc NULL
if (!hwnd)
return 0;

ShowWindow(hwnd, SW_SHOW); //wyswietla okno
UpdateWindow(hwnd); //aktualizuje onko
done=false; //inicjuje zmienna warunku wykonania pętli

//petla przetwarzania komunikatów
while(!done)
{
PeekMessage(&msg, hwnd, NULL, NULL, PM_REMOVE);
if (msg.message == WM_QUIT) //otrzymano komunikat WM_QUIT?
{
done = true;
}
else
{

/////////////////////////////////////
tworzy grafike///////////////////
zeruje bufor ekranu i bufor głębi
/////////////////////////////////////
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity(); //resetuje macierz widoku modelu

angle = angle+1.1f;
if (angle >=360)
angle =0.0f;
glTranslatef(0,0,-5);
glRotatef(angle,0,0,1);
glColor3f(1,0,0);
glBegin(GL_TRIANGLES);
glVertex3f(0,0,0);
glVertex3f(1,0,0);
glVertex3f(1,1,0);
glEnd();
SwapBuffers(g_HDC); //przełącza bufory
TranslateMessage(&msg); //tłumaczy komunikat i wysyła go do systemu
DispatchMessage(&msg);
}
}
return msg.wParam;
}

P.S. NIe wiem czy to ważne, ale kompilowałem to w Borland 6.0 ;/

0

Jeśli chodzi o samo zapytanie to będzie tak :

int opcja = MessageBox(uchwyt, "Komunikat", "Pełny ekran?", MB_YESNO | MB_ICONQUESTION);

if(opcja == IDYES)
      // wywołujesz funkcję dającą pełen ekran
else if(opcja == IDNO)
     // zwykły ekran
0

A ten..mógłbyś no dodać to kodu ;/ ;/ --> jesli to nie problem :(
Z góry dzieki

0

A napisz mi proszę gdzie jest w kodzie funkcja odpowiedzialna za fullscreen ?

Jakoś połapać się nie mogę.

No chyba, że ta zmienna fullScreen decyduje o tym, tak więc :

int opcja = MessageBox(uchwyt, "Komunikat", "Pełny ekran?", MB_YESNO | MB_ICONQUESTION);

if(opcja == IDYES)
      fullScreen = true;// wywołujesz funkcję dającą pełen ekran
else if(opcja == IDNO)
     fullScreen = false;// zwykły ekran 

0

Znaczy yyy.. w ogóle nie ma w tym kodzie funkcji FullScreen --> właśnie chciałem aby ją dodać do tego kodu ;/ --> ogormne sorki jesli źle na początku sie wyraziłem, ale to mój pierwszy post ;/ :(

0

Oj, to będzie problem, nie wiem czy to zadziała, ale spróbuj :


#define WIN32_LEAN_AND_MEAN

/////////////////////
//Pliki nazgłówkowe//
/////////////////////
#include<windows.h>
#include<gl/gl.h>
#include<gl/glu.h>
#include<gl/glaux.h>

////////////////////
//Zmienne globalne//
////////////////////
bool fullScreen; //aplikacja rozpocznie sie w trybie pelnoekranowym
float angle=0.0f;
HDC g_HDC;              //kontekst urządzenia

int opcja = MessageBox(hwnd, "Komunikat", "Pełny ekran?", MB_YESNO | MB_ICONQUESTION);

if(opcja == IDYES)
      fullScreen = true;// wywołujesz funkcję dającą pełen ekran
else if(opcja == IDNO)
     fullScreen = false;// zwykły ekran  

///////////////////////////////////////////////////////////////
//funkcja okreslająca format pikseli dla kontekstu urządzenia//
///////////////////////////////////////////////////////////////
void SetupPixelFormat(HDC hDC)
{
int nPixelFormat;
static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), //rozmiar struktury
1,                              //domyslna wersja
PFD_DRAW_TO_WINDOW|             //grafika w oknie
PFD_SUPPORT_OPENGL|             //grafika w Opengl
PFD_DOUBLEBUFFER,               //podwójne buforowanie
PFD_TYPE_RGBA,                  //tryb kolorów RGBA
32,                             //32-bitowy opsi kolorów
0, 0, 0, 0, 0, 0,               //nie specyfikuje bitów kolorów
0,                              //bez bufora alfa
0,                              //ignoruje bit przesuniecia
0,                              //bez bufora akumulacji
0, 0, 0, 0,                     //ignoruje bity akumulacji
16,                             //16-bitowy bufor Z
0,                              //bez bufora powielania
0,                              //bez buforów pomocniczych
PFD_MAIN_PLANE,                 //główna płaszczyzna rysowania
0,                              //zarezerwowane
0, 0, 0,};                      //ignoruje maski warstw

//wybiera najodpowiedniejszy format pixeli
nPixelFormat = ChoosePixelFormat(hDC, &pfd);

//okresla format pixeli dla kontekstu urządzenia
SetPixelFormat(hDC, nPixelFormat, &pfd);
}

//////////////////////
//procedura okinkowa//
//////////////////////
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HGLRC hRC;         //kontekst tworzenia grafiki
static HDC hDC;           //kontekst urzadzenia
int width, height;        //szerokosc i wysokos okna

switch(message)
{
case WM_CREATE:           //okno jest tworzone
hDC = GetDC(hwnd);        //pobiera kontekst urządzenia dla okna
g_HDC = hDC;
SetupPixelFormat(hDC);    //wywołuje funkcję okreslająca format pixeli
//tworzy kontekst tworzenia grafiki i czyni go bieżącym
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
return 0;
break;

case WM_CLOSE:            //okno jest zamykane
//dezaktywuje bieżący kontekst i usuwa go
wglMakeCurrent(hDC, NULL);
wglDeleteContext(hRC);
//wstaiwa komunikat WM_QUIT do kolejki
PostQuitMessage(0);
return 0;
break;

case WM_SIZE:
height = HIWORD(lParam);  //pobiera nową wysokosc i szerokos okna
width = LOWORD(lParam);

if (height==0){height =1;}
//nadaje nowe wymiary oknu  OpenGl
glViewport(0, 0, width, height);
//okresla macierz rzutowania
glMatrixMode(GL_PROJECTION);
//resetuje macierz rzutowania
glLoadIdentity();
//wyznacza proporcje obrazu
gluPerspective(45,(GLfloat)width/(GLfloat)height,1,1000);
glMatrixMode(GL_MODELVIEW); //okresla macierz widoku modelu
glLoadIdentity();
return 0;
break;

default:
break;
}

return (DefWindowProc(hwnd, message, wParam, lParam));
}

///////////////////////////////////////////////////////
//punkt w którym rozpoczyna sie wykonwyanie aplikacji//
///////////////////////////////////////////////////////
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEX windowClass;    //klasa okien
HWND hwnd;                 //uchwyt okna
MSG msg;                   //komunikat
bool done;                 //znacznik zakonczenia aplikacji

//definicja klasy okna
windowClass.cbSize= sizeof(WNDCLASSEX);
windowClass.style= CS_HREDRAW | CS_VREDRAW;
windowClass.lpfnWndProc= WndProc;
windowClass.cbClsExtra= 0;
windowClass.cbWndExtra= 0;
windowClass.hInstance= hInstance;
windowClass.hIcon= LoadIcon(NULL, IDI_APPLICATION);//domyslna ikona
windowClass.hCursor= LoadCursor(NULL, IDC_ARROW);  //domyslny kursor
windowClass.hbrBackground= NULL;                   //bez tła
windowClass.lpszMenuName= NULL;                    //bez menu
windowClass.lpszClassName= "Moja Klasa";
windowClass.hIconSm= LoadIcon(NULL, IDI_WINLOGO);  //logo windows
//rejestruje klasę okna
if(!RegisterClassEx(&windowClass))
return 0;

//tworzy okno
hwnd = CreateWindowEx(NULL,                          //rozszerzony styl okna
"Moja Klasa",                                      //nazwa klasy
"Aplikacja OpenGl",                                //nazwa aplikacji
WS_OVERLAPPEDWINDOW | WS_VISIBLE |
WS_SYSMENU | WS_CLIPCHILDREN|
WS_CLIPSIBLINGS,                                   //styl
100, 100,                                          //współrzędne x,y
600, 600,                                          //szerokosc i wysokosc
NULL,                                              //uchwyt okna nadrzędnego
NULL,                                              //uchwyt menu
hInstance,                                         //instancja aplikacji
NULL);                                             //bez dodatkowych parametrów

//sprawdza czy utworzenie okna nie powiodło się w przeciwnym razie hwnd ma wartosc NULL
if (!hwnd)
return 0;

if(fullScreen == true)
{
     ShowWindow(hwnd, SW_MAXIMIZE);                          //wyswietla okno
     UpdateWindow(hwnd);                                 //aktualizuje onko
}
else if(fullScreen == false)
{
     ShowWindow(hwnd, SW_SHOW);                          //wyswietla okno
     UpdateWindow(hwnd);                                 //aktualizuje onko
}
done=false;                                         //inicjuje zmienna warunku wykonania pętli

//petla przetwarzania komunikatów
while(!done)
{
PeekMessage(&msg, hwnd, NULL, NULL, PM_REMOVE);
if (msg.message == WM_QUIT)                         //otrzymano komunikat WM_QUIT?
{
done = true;
}
else
{

/////////////////////////////////////
//tworzy grafike/////////////////////
//zeruje bufor ekranu i bufor głębi//
/////////////////////////////////////
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();                                   //resetuje macierz widoku modelu

angle = angle+1.1f;
if (angle >=360)
angle =0.0f;
glTranslatef(0,0,-5);
glRotatef(angle,0,0,1);
glColor3f(1,0,0);
glBegin(GL_TRIANGLES);
glVertex3f(0,0,0);
glVertex3f(1,0,0);
glVertex3f(1,1,0);
glEnd();
SwapBuffers(g_HDC);                                 //przełącza bufory
TranslateMessage(&msg);                             //tłumaczy komunikat i wysyła go do systemu
DispatchMessage(&msg);
}
}
return msg.wParam;
}
0

Znaczy jesli idzie o zapytanie czy włączyć fullscreen'a to nie --> to trzbea dać w innym miejscu, mianowicie tutaj: --> i powinno byc tak (żeby wyskoczyło):

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEX windowClass;    //klasa okien
HWND hwnd;                 //uchwyt okna
MSG msg;                   //komunikat
bool done;                 //znacznik zakonczenia aplikacji

if (MessageBox(NULL,"Włączyc FullScreen?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION) == IDNO)
{
fullScreen = false;
}

Jak daje to twoje zapytnie to nie wiem cos nie działa i w ogóle nie wiem po co trzeba dawac to if przed MessageBox --> bo bez niego nie wyskoczy :(

0

Może tak się uda

Nie wiem czy zadziała bo siedze na Linuxie.

Tam gdzie jest ta duża przerwa w kodzie :) są linijki odpowiedzialne za pobranie rozmiaru i utworzenie okna

#define WIN32_LEAN_AND_MEAN

/////////////////////
//Pliki nazgłówkowe//
/////////////////////
#include<windows.h>
#include<gl/gl.h>
#include<gl/glu.h>
#include<gl/glaux.h>

////////////////////
//Zmienne globalne//
////////////////////
bool fullScreen = true; //aplikacja rozpocznie sie w trybie pelnoekranowym
float angle=0.0f;
HDC g_HDC;              //kontekst urządzenia

///////////////////////////////////////////////////////////////
//funkcja okreslająca format pikseli dla kontekstu urządzenia//
///////////////////////////////////////////////////////////////
void SetupPixelFormat(HDC hDC)
{
int nPixelFormat;
static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), //rozmiar struktury
1,                              //domyslna wersja
PFD_DRAW_TO_WINDOW|             //grafika w oknie
PFD_SUPPORT_OPENGL|             //grafika w Opengl
PFD_DOUBLEBUFFER,               //podwójne buforowanie
PFD_TYPE_RGBA,                  //tryb kolorów RGBA
32,                             //32-bitowy opsi kolorów
0, 0, 0, 0, 0, 0,               //nie specyfikuje bitów kolorów
0,                              //bez bufora alfa
0,                              //ignoruje bit przesuniecia
0,                              //bez bufora akumulacji
0, 0, 0, 0,                     //ignoruje bity akumulacji
16,                             //16-bitowy bufor Z
0,                              //bez bufora powielania
0,                              //bez buforów pomocniczych
PFD_MAIN_PLANE,                 //główna płaszczyzna rysowania
0,                              //zarezerwowane
0, 0, 0,};                      //ignoruje maski warstw

//wybiera najodpowiedniejszy format pixeli
nPixelFormat = ChoosePixelFormat(hDC, &pfd);

//okresla format pixeli dla kontekstu urządzenia
SetPixelFormat(hDC, nPixelFormat, &pfd);
}

//////////////////////
//procedura okinkowa//
//////////////////////
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HGLRC hRC;         //kontekst tworzenia grafiki
static HDC hDC;           //kontekst urzadzenia
int width, height;        //szerokosc i wysokos okna

switch(message)
{
case WM_CREATE:           //okno jest tworzone
hDC = GetDC(hwnd);        //pobiera kontekst urządzenia dla okna
g_HDC = hDC;
SetupPixelFormat(hDC);    //wywołuje funkcję okreslająca format pixeli
//tworzy kontekst tworzenia grafiki i czyni go bieżącym
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
return 0;
break;

case WM_CLOSE:            //okno jest zamykane
//dezaktywuje bieżący kontekst i usuwa go
wglMakeCurrent(hDC, NULL);
wglDeleteContext(hRC);
//wstaiwa komunikat WM_QUIT do kolejki
PostQuitMessage(0);
return 0;
break;

case WM_SIZE:
height = HIWORD(lParam);  //pobiera nową wysokosc i szerokos okna
width = LOWORD(lParam);

if (height==0){height =1;}
//nadaje nowe wymiary oknu  OpenGl
glViewport(0, 0, width, height);
//okresla macierz rzutowania
glMatrixMode(GL_PROJECTION);
//resetuje macierz rzutowania
glLoadIdentity();
//wyznacza proporcje obrazu
gluPerspective(45,(GLfloat)width/(GLfloat)height,1,1000);
glMatrixMode(GL_MODELVIEW); //okresla macierz widoku modelu
glLoadIdentity();
return 0;
break;

default:
break;
}

return (DefWindowProc(hwnd, message, wParam, lParam));
}

///////////////////////////////////////////////////////
//punkt w którym rozpoczyna sie wykonwyanie aplikacji//
///////////////////////////////////////////////////////
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEX windowClass;    //klasa okien
HWND hwnd;                 //uchwyt okna
MSG msg;                   //komunikat
bool done;                 //znacznik zakonczenia aplikacji

//definicja klasy okna
windowClass.cbSize= sizeof(WNDCLASSEX);
windowClass.style= CS_HREDRAW | CS_VREDRAW;
windowClass.lpfnWndProc= WndProc;
windowClass.cbClsExtra= 0;
windowClass.cbWndExtra= 0;
windowClass.hInstance= hInstance;
windowClass.hIcon= LoadIcon(NULL, IDI_APPLICATION);//domyslna ikona
windowClass.hCursor= LoadCursor(NULL, IDC_ARROW);  //domyslny kursor
windowClass.hbrBackground= NULL;                   //bez tła
windowClass.lpszMenuName= NULL;                    //bez menu
windowClass.lpszClassName= "Moja Klasa";
windowClass.hIconSm= LoadIcon(NULL, IDI_WINLOGO);  //logo windows
//rejestruje klasę okna
if(!RegisterClassEx(&windowClass))
return 0;










// tutaj pobierzemy rozmiary ekranu

// width
int cx = GetSystemMetrics(SM_CXSCREEN);
// height
int cy = GetSystemMetrics(SM_CYSCREEN);

// i do hwnd odamy kolejno cx i cy

int opcja = MessageBox(uchwyt, "Komunikat", "Pełny ekran?", MB_YESNO | MB_ICONQUESTION);

if(opcja == IDYES)
{
	//tworzy okno
	hwnd = CreateWindowEx(NULL,                          //rozszerzony styl okna
	"Moja Klasa",                                      //nazwa klasy
	"Aplikacja OpenGl",                                //nazwa aplikacji
	WS_OVERLAPPEDWINDOW | WS_VISIBLE |
	WS_SYSMENU | WS_CLIPCHILDREN|
	WS_CLIPSIBLINGS,                                   //styl
	0, 0,                                          //współrzędne x,y
	cx, cy,                                          //szerokosc i wysokosc
	NULL,                                              //uchwyt okna nadrzędnego
	NULL,                                              //uchwyt menu
	hInstance,                                         //instancja aplikacji
	NULL);     

}
else if(opcja == IDNO)
{
	//tworzy okno
	hwnd = CreateWindowEx(NULL,                          //rozszerzony styl okna
	"Moja Klasa",                                      //nazwa klasy
	"Aplikacja OpenGl",                                //nazwa aplikacji
	WS_OVERLAPPEDWINDOW | WS_VISIBLE |
	WS_SYSMENU | WS_CLIPCHILDREN|
	WS_CLIPSIBLINGS,                                   //styl
	100, 100,                                          //współrzędne x,y
	600, 600,                                          //szerokosc i wysokosc
	NULL,                                              //uchwyt okna nadrzędnego
	NULL,                                              //uchwyt menu
	hInstance,                                         //instancja aplikacji
	NULL);     

}






                                        //bez dodatkowych parametrów

//sprawdza czy utworzenie okna nie powiodło się w przeciwnym razie hwnd ma wartosc NULL
if (!hwnd)
return 0;

ShowWindow(hwnd, SW_SHOW);                          //wyswietla okno
UpdateWindow(hwnd);                                 //aktualizuje onko
done=false;                                         //inicjuje zmienna warunku wykonania pętli

//petla przetwarzania komunikatów
while(!done)
{
PeekMessage(&msg, hwnd, NULL, NULL, PM_REMOVE);
if (msg.message == WM_QUIT)                         //otrzymano komunikat WM_QUIT?
{
done = true;
}
else
{

/////////////////////////////////////
//tworzy grafike/////////////////////
//zeruje bufor ekranu i bufor głębi//
/////////////////////////////////////
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();                                   //resetuje macierz widoku modelu

angle = angle+1.1f;
if (angle >=360)
angle =0.0f;
glTranslatef(0,0,-5);
glRotatef(angle,0,0,1);
glColor3f(1,0,0);
glBegin(GL_TRIANGLES);
glVertex3f(0,0,0);
glVertex3f(1,0,0);
glVertex3f(1,1,0);
glEnd();
SwapBuffers(g_HDC);                                 //przełącza bufory
TranslateMessage(&msg);                             //tłumaczy komunikat i wysyła go do systemu
DispatchMessage(&msg);
}
}
return msg.wParam;
}
0

Kur.cze --> pisze że nie zna takiego słowa jak "uchwyt" :( --> w tym poleceniu:

int opcja = MessageBox(uchwyt, "Komunikat", "Pełny ekran?", MB_YESNO | MB_ICONQUESTION);

0

moja wina :)

uchwyt tak sobie nazwałem, zmień na hwnd

0

hehe :) --> tylko no działa tylko nic sie nie pokazuje... ;/ tak jakby okna nie chciał zrobić :( ;/

0

A co się dzieje jak wybierzesz z MessageBoxa "NIE \ NO"

0

Spróbuj tak :

#define WIN32_LEAN_AND_MEAN

/////////////////////
//Pliki nazgłówkowe//
/////////////////////
#include<windows.h>
#include<gl/gl.h>
#include<gl/glu.h>
#include<gl/glaux.h>

////////////////////
//Zmienne globalne//
////////////////////
bool fullScreen = true; //aplikacja rozpocznie sie w trybie pelnoekranowym
float angle=0.0f;
HDC g_HDC;              //kontekst urządzenia

///////////////////////////////////////////////////////////////
//funkcja okreslająca format pikseli dla kontekstu urządzenia//
///////////////////////////////////////////////////////////////
void SetupPixelFormat(HDC hDC)
{
int nPixelFormat;
static PIXELFORMATDESCRIPTOR pfd = {
sizeof(PIXELFORMATDESCRIPTOR), //rozmiar struktury
1,                              //domyslna wersja
PFD_DRAW_TO_WINDOW|             //grafika w oknie
PFD_SUPPORT_OPENGL|             //grafika w Opengl
PFD_DOUBLEBUFFER,               //podwójne buforowanie
PFD_TYPE_RGBA,                  //tryb kolorów RGBA
32,                             //32-bitowy opsi kolorów
0, 0, 0, 0, 0, 0,               //nie specyfikuje bitów kolorów
0,                              //bez bufora alfa
0,                              //ignoruje bit przesuniecia
0,                              //bez bufora akumulacji
0, 0, 0, 0,                     //ignoruje bity akumulacji
16,                             //16-bitowy bufor Z
0,                              //bez bufora powielania
0,                              //bez buforów pomocniczych
PFD_MAIN_PLANE,                 //główna płaszczyzna rysowania
0,                              //zarezerwowane
0, 0, 0,};                      //ignoruje maski warstw

//wybiera najodpowiedniejszy format pixeli
nPixelFormat = ChoosePixelFormat(hDC, &pfd);

//okresla format pixeli dla kontekstu urządzenia
SetPixelFormat(hDC, nPixelFormat, &pfd);
}

//////////////////////
//procedura okinkowa//
//////////////////////
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
static HGLRC hRC;         //kontekst tworzenia grafiki
static HDC hDC;           //kontekst urzadzenia
int width, height;        //szerokosc i wysokos okna

switch(message)
{
case WM_CREATE:           //okno jest tworzone
hDC = GetDC(hwnd);        //pobiera kontekst urządzenia dla okna
g_HDC = hDC;
SetupPixelFormat(hDC);    //wywołuje funkcję okreslająca format pixeli
//tworzy kontekst tworzenia grafiki i czyni go bieżącym
hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC);
return 0;
break;

case WM_CLOSE:            //okno jest zamykane
//dezaktywuje bieżący kontekst i usuwa go
wglMakeCurrent(hDC, NULL);
wglDeleteContext(hRC);
//wstaiwa komunikat WM_QUIT do kolejki
PostQuitMessage(0);
return 0;
break;

case WM_SIZE:
height = HIWORD(lParam);  //pobiera nową wysokosc i szerokos okna
width = LOWORD(lParam);

if (height==0){height =1;}
//nadaje nowe wymiary oknu  OpenGl
glViewport(0, 0, width, height);
//okresla macierz rzutowania
glMatrixMode(GL_PROJECTION);
//resetuje macierz rzutowania
glLoadIdentity();
//wyznacza proporcje obrazu
gluPerspective(45,(GLfloat)width/(GLfloat)height,1,1000);
glMatrixMode(GL_MODELVIEW); //okresla macierz widoku modelu
glLoadIdentity();
return 0;
break;

default:
break;
}

return (DefWindowProc(hwnd, message, wParam, lParam));
}

///////////////////////////////////////////////////////
//punkt w którym rozpoczyna sie wykonwyanie aplikacji//
///////////////////////////////////////////////////////
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
WNDCLASSEX windowClass;    //klasa okien
HWND hwnd;                 //uchwyt okna
MSG msg;                   //komunikat
bool done;                 //znacznik zakonczenia aplikacji

//definicja klasy okna
windowClass.cbSize= sizeof(WNDCLASSEX);
windowClass.style= CS_HREDRAW | CS_VREDRAW;
windowClass.lpfnWndProc= WndProc;
windowClass.cbClsExtra= 0;
windowClass.cbWndExtra= 0;
windowClass.hInstance= hInstance;
windowClass.hIcon= LoadIcon(NULL, IDI_APPLICATION);//domyslna ikona
windowClass.hCursor= LoadCursor(NULL, IDC_ARROW);  //domyslny kursor
windowClass.hbrBackground= NULL;                   //bez tła
windowClass.lpszMenuName= NULL;                    //bez menu
windowClass.lpszClassName= "Moja Klasa";
windowClass.hIconSm= LoadIcon(NULL, IDI_WINLOGO);  //logo windows
//rejestruje klasę okna
if(!RegisterClassEx(&windowClass))
return 0;










// tutaj pobierzemy rozmiary ekranu

// width
int cx = GetSystemMetrics(SM_CXSCREEN);
// height
int cy = GetSystemMetrics(SM_CYSCREEN);

// i do hwnd odamy kolejno cx i cy

int opcja = MessageBox(uchwyt, "Komunikat", "Pełny ekran?", MB_YESNO | MB_ICONQUESTION);

if(opcja == IDYES)
{
        //tworzy okno
        hwnd = CreateWindowEx(NULL,                          //rozszerzony styl okna
        "Moja Klasa",                                      //nazwa klasy
        "Aplikacja OpenGl",                                //nazwa aplikacji
        WS_OVERLAPPEDWINDOW | WS_VISIBLE |
        WS_SYSMENU | WS_CLIPCHILDREN|
        WS_CLIPSIBLINGS,                                   //styl
        0, 0,                                          //współrzędne x,y
        cx, cy,                                          //szerokosc i wysokosc
        NULL,                                              //uchwyt okna nadrzędnego
        NULL,                                              //uchwyt menu
        hInstance,                                         //instancja aplikacji
        NULL);     
    
        
ShowWindow(hwnd, SW_SHOW);                          //wyswietla okno
UpdateWindow(hwnd);                                 //aktualizuje onko
done=false;                                         //inicjuje zmienna warunku wykonania pętli

}
else if(opcja == IDNO)
{
        //tworzy okno
        hwnd = CreateWindowEx(NULL,                          //rozszerzony styl okna
        "Moja Klasa",                                      //nazwa klasy
        "Aplikacja OpenGl",                                //nazwa aplikacji
        WS_OVERLAPPEDWINDOW | WS_VISIBLE |
        WS_SYSMENU | WS_CLIPCHILDREN|
        WS_CLIPSIBLINGS,                                   //styl
        100, 100,                                          //współrzędne x,y
        600, 600,                                          //szerokosc i wysokosc
        NULL,                                              //uchwyt okna nadrzędnego
        NULL,                                              //uchwyt menu
        hInstance,                                         //instancja aplikacji
        NULL);     


ShowWindow(hwnd, SW_SHOW);                          //wyswietla okno
UpdateWindow(hwnd);                                 //aktualizuje onko
done=false;                                         //inicjuje zmienna warunku wykonania pętli

}






                                        //bez dodatkowych parametrów

//sprawdza czy utworzenie okna nie powiodło się w przeciwnym razie hwnd ma wartosc NULL
if (!hwnd)
return 0;


//petla przetwarzania komunikatów
while(!done)
{
PeekMessage(&msg, hwnd, NULL, NULL, PM_REMOVE);
if (msg.message == WM_QUIT)                         //otrzymano komunikat WM_QUIT?
{
done = true;
}
else
{

/////////////////////////////////////
//tworzy grafike/////////////////////
//zeruje bufor ekranu i bufor głębi//
/////////////////////////////////////
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();                                   //resetuje macierz widoku modelu

angle = angle+1.1f;
if (angle >=360)
angle =0.0f;
glTranslatef(0,0,-5);
glRotatef(angle,0,0,1);
glColor3f(1,0,0);
glBegin(GL_TRIANGLES);
glVertex3f(0,0,0);
glVertex3f(1,0,0);
glVertex3f(1,1,0);
glEnd();
SwapBuffers(g_HDC);                                 //przełącza bufory
TranslateMessage(&msg);                             //tłumaczy komunikat i wysyła go do systemu
DispatchMessage(&msg);
}
}
return msg.wParam;
}
0

Znaczy w ogóle nic nie moge nacisnąć bo nic sie nie pokazuje :( ;/

Zrobiłem zdjęcie --> jak na nim widać po skompilowaniu nic sie nie pokazuje :(:(:(
http://www.fotosik.pl/pokaz_obrazek/07d2a1cacf074298.html

0

No to lipa :( nie wiem co z tym może być, popróbuje u siebie i dam jeszcze znać czy coś wymyśliłem

0

Ok, na swoim kodzie zrobiłem to tak, teraz tylko dostosuj sobie swoją procedurę okna do mojej i będzie git. Nie mogę tego zrobić u siebie bo nie mam tych plików nagłówkoych co Ty.

Ale ogólnie rzecz biorą działa.

Jak klikniesz na tak to robi Ci fullscreen a jak nie to okno 600px na 600px czy ile tam ustawisz.

Tylko przy fullscreen musisz od zmiennych cx oraz cy poodejmować chyba po 10 px bo inaczej wyjedzie po za ekran - trzeba wliczyć obramwoanie okna.

Kod :

Edit : poprawka, miałeś CreateWindowEx a ja napisałem dla CreateWindow

#include <windows.h>               // biblioteka windows

HINSTANCE hInst;        // uchwyt programu
HWND      Edit;         // uchwyt EditBox-a
HWND      uchwyt;       // uchwyt okna


LRESULT CALLBACK ProcOkna(HWND uchwyt, UINT message, WPARAM wParam, LPARAM lParam);

/*************************** Główna funkcja programu*******************************/
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	WNDCLASS klasaokna;   // klasa okna


	klasaokna.style         = CS_HREDRAW | CS_VREDRAW;              // styl okna
	klasaokna.lpfnWndProc   = ProcOkna;                             // adres procedury okna głównego
	klasaokna.cbClsExtra    = 0;                                    // dodatkowa pamięć
	klasaokna.cbWndExtra    = 0;                                    // dodatkowa pamięć
	klasaokna.hInstance     = hInstance;                            // uchwyt relizacji
	klasaokna.hIcon         = NULL;                                 // ikona programu
	klasaokna.hCursor       = LoadCursor(NULL,IDC_ARROW);           // kursor
	klasaokna.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH); // tło okna głównego
	klasaokna.lpszMenuName  = NULL;           // nazwa menu
	klasaokna.lpszClassName = "okno_glowne";                        // nazwa klasy okna


    int cx = GetSystemMetrics(SM_CXSCREEN);
    // height
    int cy = GetSystemMetrics(SM_CYSCREEN);

	// rejestrowanie klasy okna
	if(RegisterClass(&klasaokna)==0)
	{
		MessageBox(NULL, "lipa", "Błąd 00", MB_OK | MB_ICONWARNING);
		return false;
	}

	/************************** Tworzenie okna głównego ****************************/



	int opcja = MessageBox(uchwyt, "Wiadomość","Pełny ekran ?", MB_YESNO | MB_ICONQUESTION);

	if(opcja == IDYES)
	{
        uchwyt = CreateWindowEx(NULL,"okno_glowne","Mój program",WS_OVERLAPPEDWINDOW | WS_VISIBLE |WS_SYSMENU | WS_CLIPCHILDREN|
        WS_CLIPSIBLINGS,0, 0,cx, cy,NULL,NULL,hInstance,NULL);
    }
    else if(opcja == IDNO)
	{
        uchwyt = CreateWindowEx(NULL,"okno_glowne","Mój program",WS_OVERLAPPEDWINDOW | WS_VISIBLE |WS_SYSMENU | WS_CLIPCHILDREN|
        WS_CLIPSIBLINGS,0, 0,600, 600,NULL,NULL,hInstance,NULL);
    }


	if(uchwyt==0)
	{
		MessageBox(NULL, "lipa", "Błąd 01", MB_OK | MB_ICONWARNING);
		return false; // utworzenie okna głównego nie powiodło się
	}

	/************************** Tworzenie EditBox-a ****************************/


	ShowWindow(uchwyt,SW_SHOW);    // pokazanie okna głównego
	UpdateWindow(uchwyt);          // odświeżenie okna głównego

	// pętla odbierania komunikatów

	MSG message;

	while(GetMessage(&message,NULL,0,0))
	{
		TranslateMessage(&message);  // tłumaczenie komunikatów
		DispatchMessage(&message);   // rozsyłanie komunikatów do procedur okna
	}


	return 0;
}



/***************************** DEFINICJA PROCEDURY OKNA ********************************/
LRESULT CALLBACK ProcOkna(HWND uchwyt, UINT message, WPARAM wParam, LPARAM lParam)
{
	int ID = LOWORD(wParam);

	// obsługa wiadomości okna głównego
	switch(message)
	{
		case WM_CREATE:
			break;
		case WM_DESTROY:
			PostQuitMessage(0);			                  // obsługa komunikatów końca pracy programu
			break;
		case WM_KEYDOWN:
            break;
		case WM_HOTKEY:                                   // obsługa komunikatów klawiszy szybkiego uruchamiania
			break;
		case WM_COMMAND:
			break;
		default:
			return (DefWindowProc(uchwyt,message,wParam,lParam));
	}

	return (0L);
}

0

OK działa --> dzieki za pomoc :)
Można zamknąc

0

Zmien może temat postu, żeby w przyszłości inni mogli z łatwością wyszukać rozwiązanie.

Pozdrawiam.

1 użytkowników online, w tym zalogowanych: 0, gości: 1