На главную
ПРАВИЛА FAQ Помощь Участники Календарь Избранное DigiMania RSS
msm.ru
! Правила раздела "Программирование графики"
1) Данный раздел предназначен для обсуждения проблем, возникающих при программировании задач, связанных с чтением, сохранением, обработкой, созданием, отрисовкой графической информации (в том числе - 3D [OpenGL, Direct3D] и анимации [в т.ч. VFW, DirectShow, OpenDML]).
Флэш обсуждают здесь!.

2) Если вы хотите получить совет для конкретной платформы/языка программирования, обязательно укажите их в вопросе.

3) Уважаемые новички! Мы приветствуем Ваше желание научить всех посетителей раздела правильному программированию. Но огромная просьба, перед тем, как писать поучения в старых (последний ответ - "старее" месяца, а особенно, если вопрошавший не появляется на форуме уже не первый месяц, в чем можно убедиться в его профиле) темах, хорошо подумать, будет ли кому-нибудь, кроме Вас cамих, это интересно.



Ваше мнение о модераторах: user posted imageBarazuk, user posted imageOpenGL, user posted imageMikle
Модераторы: OpenGL, barazuk, Mikle
  
> Переключение режимов
Доброе время суток
Долго не понимал, куда задать этот вопрос: сюда или в WinAPI :unsure:
Собрал стартовый проект OGL с возможностью переключения режимов.
Помогите, пожалуйста, разобраться: когда приложение в полноэкраном режиме, визуализация в порядке. Но, когда переключаю в оконный режим, окно как бы растягивается по ширине экрана монитора. И получается лишняя область в окне OGL. :unsure:
Как с эти бороться? :rolleyes:
Проект сделал на основе 1-го урока NeHe

Добавлено
АААААА :blink: :wacko: cpp и h-файлы не могу прикрепить......
ExpandedWrap disabled
    HINSTANCE hInst;                                // текущий экземпляр
    TCHAR szTitle[MAX_LOADSTRING];                  // Текст строки заголовка
    TCHAR szWindowClass[MAX_LOADSTRING];            // имя класса главного окна
     
    int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                         _In_opt_ HINSTANCE hPrevInstance,
                         _In_ LPWSTR    lpCmdLine,
                         _In_ int       nCmdShow)
    {
        UNREFERENCED_PARAMETER(hPrevInstance);
        UNREFERENCED_PARAMETER(lpCmdLine);
     
        // TODO: разместите код здесь.
        BOOL fullscreen = TRUE;
     
     
        // Инициализация глобальных строк
        LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
        LoadString(hInstance, IDC_OGLWINDOW, szWindowClass, MAX_LOADSTRING);
     
        if (MessageBox(NULL, "Хотите ли Вы запустить приложение в полноэкранном режиме?",
            "Запустить в полноэкранном режиме?", MB_YESNO | MB_ICONQUESTION) == IDNO)
        {
            fullscreen = FALSE;          // Оконный режим
        }
     
        CScene2D m_Scene2D;
     
        //1024, 768
        //1920, 1080
        if (!m_Scene2D._CreateGLWindow(szWindowClass, szTitle, hInstance, 1024, 768, 32, fullscreen))
            return 0;
     
        
        return 0;
    }


ExpandedWrap disabled
    #pragma once
     
    #include <gl\glut.h>
     
    class CRD
    {
    public:
        CRD(void);
        virtual ~CRD(void);
        //Èíèöèàëèçàöèÿ ïðèëîæåíèÿ Win32
        BOOL _CreateGLWindow(LPCTSTR szWindowClass,LPCTSTR szAppTitle,HINSTANCE hInst, DWORD dwWidth,
                     DWORD dwHeight, int bits,BOOL fullscreen);
        
     
    protected:
        virtual bool RD_PrepareScene(){return true;};
        virtual void RD_DrawScene(){};
        virtual void RD_ReSizeGLScene() {};
        virtual void RD_DestroyScene(){};
     
    protected:
        BOOL OnCreate();
        BOOL OnDraw();
        BOOL OnDestroy();
        BOOL OnReSize();
        BOOL OnKeyDown(WPARAM wKey);
        BOOL OnActivateApp(BOOL fActive);
        
     
    private:
        ATOM MyRegisterClass(LPCTSTR szWindowClass,HINSTANCE hInstance);
        static LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg,WPARAM wParam,LPARAM lParam);
        BOOL InitGL();
        int SetWindowPixelFormat();
        void KillGLWindow(void);
     
     
    protected:
        HWND hWnd;
        HINSTANCE hInstance;
        BOOL   fFullscreen;
        HDC hDC;
        HGLRC hGlrc; //Êîíòåêñò Ðåäèíãà OpenGL
        BOOL fIsActive;
        LPCTSTR WindowClass;
        LPCTSTR Title;
        int m_Bits;
        BOOL fIsChangeMode;
        
    };



ExpandedWrap disabled
    #include "stdafx.h"
    #include "RD.h"
    #include "../../../../core/printError.h"
    #include "resource.h"
     
     
    BOOL done;
     
    CRD::CRD(void)
    {
        hWnd = NULL;
        hDC = NULL;
        hGlrc = NULL;
        fIsActive = FALSE;
        fIsChangeMode = FALSE;
     
        m_Bits = 0;
     
        done = FALSE;
    }
     
    CRD::~CRD(void)
    {
        KillGLWindow();
    }
     
    BOOL CRD::_CreateGLWindow(LPCTSTR szWindowClass,LPCTSTR szAppTitle,HINSTANCE hInst, DWORD dwWidth,
                     DWORD dwHeight, int bits,BOOL fullscreen)
    {
        RECT WindRect;
        WindRect.left   = (LONG)0;
        WindRect.right  = dwWidth;
        WindRect.top    = (LONG)0;
        WindRect.bottom = dwHeight;
     
        hInstance = hInst;
        WindowClass = szWindowClass;
        Title = szAppTitle;
        fFullscreen = fullscreen;
        m_Bits = bits;
        
     
        if (!MyRegisterClass(WindowClass, hInstance))
        {
            ErrMsg("Ðåãèñòðàöèÿ êëàññà îêíà");
            return FALSE;
        }
     
        if (fFullscreen)
        {
            //Ïåðåõîä â ïîëíîýêðàííûé ðåæèì - ÏÅÐÅÄ ñîçäàíèåì îêíà
            DEVMODE dmScreenSettings;
            memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
            
            dmScreenSettings.dmSize       = sizeof(dmScreenSettings);
            dmScreenSettings.dmPelsWidth  = dwWidth;
            dmScreenSettings.dmPelsHeight = dwHeight;
            dmScreenSettings.dmBitsPerPel = m_Bits;
            dmScreenSettings.dmFields     = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
     
            //Ïûòàþñü óñòàíîâèòü âûáðàííûé ðåæèì
            //CDS_FULLSCREEN ñêðûâàåò ïàíåëü óïðàâëåíèÿ
            if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
            {
                //Åñëè ïåðåõîä â ïîëíîýêðàííûé ðåæèì íåâîçìîæåí: ëèáî îêîííûé ðåæèì ëèáî âûõîä
                if (MessageBox(nullptr, "Ðåæèì FullScreen íå ïîääåðæèâàåòüñÿ Âàøåé âèäåîêàðòîé\nÏðîäîëæèòü â îêîííîì ðåæèìå?",
                    "StandartOGLWindow", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
                    fFullscreen = FALSE;
                else
                {
                    MessageBox(nullptr, "Îêíî áóäåò çàêðûòî", "Error", MB_OK | MB_ICONSTOP);
                    return FALSE;
                }
     
            }
     
            
        }
     
        DWORD dwStyle;
        DWORD dwExStyle;
     
        if (fFullscreen)
        {
            dwStyle     = WS_POPUP;
            dwExStyle   = WS_EX_APPWINDOW;
            ShowCursor(FALSE);
        }
        else
        {
            dwStyle = WS_OVERLAPPEDWINDOW;
            dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
        }
     
        // Ïîäáèðàåò îêíó ïîäõîäÿùèå ðàçìåðû
        AdjustWindowRectEx(&WindRect, dwStyle, false, dwExStyle);
     
        
        hWnd = CreateWindowEx(dwExStyle,szWindowClass,szAppTitle,
                              dwStyle | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
                              0,0,
                              WindRect.right  - WindRect.left,
                              WindRect.bottom - WindRect.top,
                              NULL,NULL,hInst,this);
        if (!hWnd)
        {
            KillGLWindow();
            ErrMsg("Ñîçäàíèå îêíà");
            return FALSE;
        }
     
        SetWindowLong(hWnd, GWL_USERDATA, (long)this);
        
     
        if (!OnCreate())
        {
            KillGLWindow();
            ErrMsg("Èíèöèàëèçàöèÿ OpenGL/DD îêíà");
            return FALSE;
        }
     
        
        ShowWindow(hWnd, SW_SHOW);
        UpdateWindow(hWnd);
        SetForegroundWindow(hWnd);
        SetFocus(hWnd);
                
        CRD::OnActivateApp(TRUE);
            
        MSG msg;
        while (!done)
        {
            if (PeekMessage(&msg,NULL,0,0,PM_NOREMOVE))
            {
                if (msg.message == WM_QUIT)
                    done = TRUE;
                else
                {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                }
            }
            else
            {
                if (fIsActive)
                    OnDraw();
            }
        }
        
        return TRUE;
    }
     
     
    //
    ATOM CRD::MyRegisterClass(LPCTSTR szWindowClass,HINSTANCE hInstance)
    {
        WNDCLASSEX wcex;
     
        ZeroMemory(&wcex,sizeof(wcex));
     
        wcex.cbSize = sizeof(WNDCLASSEX);
     
        wcex.style          = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
        wcex.lpfnWndProc    = CRD::WndProc;
        wcex.hInstance      = hInstance;
        wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_OGLWINDOW));
        wcex.hIcon          = LoadIcon(NULL,IDI_APPLICATION);
        wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
        wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+2);
        wcex.lpszMenuName   = NULL;
        wcex.lpszClassName  = szWindowClass;
        wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
     
        return RegisterClassEx(&wcex);
    }
     
    //
    LRESULT CALLBACK CRD::WndProc(HWND hwnd, UINT uMsg,WPARAM wParam,LPARAM lParam)
    {
        CRD* pRD = (CRD*)GetWindowLong(hwnd,GWL_USERDATA);
     
        switch(uMsg)
        {
        case WM_CREATE:
            break;
        case WM_ACTIVATEAPP:
            if (pRD)
                pRD->OnActivateApp((BOOL)wParam);
            break;
     
        case WM_SIZE:
            if (pRD)
                pRD->OnReSize();
            break;
        case WM_SYSCOMMAND:
        {
            switch (wParam)
            {
            case SC_SCREENSAVE:
            case SC_MONITORPOWER:
                return 0;
            }
            break;
        }
        case WM_KEYDOWN:
            if (pRD)
                pRD->OnKeyDown(wParam);
            break;
        
        case WM_CLOSE:
            if (pRD)
            {
                pRD->OnActivateApp(FALSE);
                pRD->OnDestroy();
            }
            PostQuitMessage(0);
            break;
        case WM_DESTROY:
            if (pRD)
            {
                if (pRD->fIsActive)
                    break;
            }
            else
                PostQuitMessage(0);
            break;
        default:
            return DefWindowProc(hwnd,uMsg,wParam,lParam);
        }
     
        return 0;
    }
     
    BOOL CRD::OnKeyDown(WPARAM wKey)
    {
        switch (wKey)
        {
        case VK_ESCAPE:
            PostQuitMessage(0);
            break;
        case VK_F1:
        {  
            KillGLWindow();
            fFullscreen = !fFullscreen;
            if (!_CreateGLWindow(WindowClass, Title, hInstance, 1920, 1080, 32, fFullscreen))
                PostQuitMessage(0);
            break;
        }
        default:
            break;
        }
        return TRUE;
    }
     
    BOOL CRD::OnCreate()
    {
        hDC = GetDC(hWnd);
        if (hDC == NULL)
        {
            ErrMsg("Êîíòåêñò DC");
            return FALSE;
        }
     
        if (SetWindowPixelFormat() == 0)
        {
            ErrMsg("Ôîðìàò ïèêñåëåé DC");
            return FALSE;
        }
     
     
        //fModeChanged = TRUE;
     
        if (!InitGL())
        {
            ErrMsg("Èíèöèàëèçàöèÿ OGL");
            return FALSE;
        }
            
        if (!RD_PrepareScene())
        {
            ErrMsg("Íàñòðîéêà ñöåíû îêíà OGL");
            return FALSE;
        }
        return TRUE;
    }
     
    BOOL CRD::InitGL()
    {
            
        hGlrc = wglCreateContext(hDC);
        if (hGlrc == NULL)
        {
            ErrMsg("Êîíòåêñò GL");
            return FALSE;
        }
     
        if (wglMakeCurrent(hDC,hGlrc) == FALSE)
            return FALSE;
     
        return TRUE;
    }
     
    int CRD::SetWindowPixelFormat()
    {
        if (!hDC)
            return 0;
     
        int m_GLPixelIndex;
     
        PIXELFORMATDESCRIPTOR pfd;
        pfd.nSize               = sizeof(PIXELFORMATDESCRIPTOR);
        pfd.nVersion            = 1;
        pfd.dwFlags             = PFD_DRAW_TO_WINDOW|PFD_SUPPORT_OPENGL|PFD_DOUBLEBUFFER;
        pfd.iPixelType          = PFD_TYPE_RGBA;
        pfd.cColorBits          = m_Bits;
        pfd.cRedBits            = 8;
        pfd.cRedShift           = 16;
        pfd.cGreenBits          = 8;
        pfd.cGreenShift         = 8;
        pfd.cBlueBits           = 8;
        pfd.cBlueShift          = 0;
        pfd.cAlphaBits          = 0;
        pfd.cAlphaShift         = 0;
        pfd.cAccumBits          = 64;
        pfd.cAccumRedBits       = 16;
        pfd.cAccumBlueBits      = 16;
        pfd.cAccumGreenBits     = 16;
        pfd.cAccumAlphaBits     = 0;
        pfd.cDepthBits          = 32;
        pfd.cStencilBits        = 8;
        pfd.cAuxBuffers         = 0;
        pfd.iLayerType          = PFD_MAIN_PLANE;
        pfd.bReserved           = 0;
        pfd.dwLayerMask         = 0;
        pfd.dwVisibleMask       = 0;
        pfd.dwDamageMask        = 0;
        
        m_GLPixelIndex = ChoosePixelFormat( hDC, &pfd);
        if (m_GLPixelIndex == 0)
        {
            m_GLPixelIndex = 1;
            if (DescribePixelFormat(hDC,m_GLPixelIndex,sizeof(PIXELFORMATDESCRIPTOR),&pfd) == 0)
                return 0;
        }
     
        if (SetPixelFormat(hDC,m_GLPixelIndex,&pfd) == FALSE)
            return 0;
     
        return 1;
    }
     
    BOOL CRD::OnActivateApp(BOOL fActive)
    {
        fIsActive = fActive;
        return TRUE;
    }
     
    BOOL CRD::OnDraw()
    {
        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
        RD_DrawScene();
        glFinish();
        SwapBuffers(hDC);
        return TRUE;
    }
     
    BOOL CRD::OnDestroy()
    {
        RD_DestroyScene();
        return TRUE;
    }
     
    void CRD::KillGLWindow(void)
    {
        if (fFullscreen)
        {
            ChangeDisplaySettings(nullptr, 0L);
            ShowCursor(TRUE);
        }
        
        if (hGlrc != NULL)
        {
            if (!wglMakeCurrent(NULL, NULL))
                ErrMsg("Îñâîáîæäåíèå Êîíòåêñò Ðåíäåðèíãà");
     
            if (!wglDeleteContext(hGlrc))
                ErrMsg("Óäàëåíèå Êîíòåêñò Ðåíäåðèíãà");
            hGlrc = NULL;
        }
     
        if (hDC)
        {
            if (!ReleaseDC(hWnd, hDC))
                ErrMsg("Óäàëåíèå Êîíòåêñò Óñòðîéñòâà");
            hDC = NULL;
        }
     
        if (hWnd)
        {
            if (!DestroyWindow(hWnd))
                ErrMsg("Óäàëåíèå îêíà");
            hWnd = NULL;
        }
        
        if (!UnregisterClass(WindowClass, hInstance))
        {
            ErrMsg("Error");
            //hInstance = NULL;
        }
    }
     
    BOOL CRD::OnReSize()
    {
        RD_ReSizeGLScene();
        return TRUE;
    }


ExpandedWrap disabled
    #include "stdafx.h"
     
    #include "Scene2D.h"
     
     
    CScene2D::CScene2D(void)
    {
    }
     
     
    CScene2D::~CScene2D(void)
    {
    }
     
    bool CScene2D::RD_PrepareScene()
    {
        glClearColor(0.12,0.12,0.12,0.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(-100.0,100.0,-100.0,100.0);  
     
        return true;
    }
    void CScene2D::RD_DrawScene()
    {
        glClear(GL_COLOR_BUFFER_BIT);
        glColor3f(1.0, 1.0, 1.0);
     
        glBegin(GL_LINES);
            glVertex2d(-90, -20);
            glVertex2d(50, 50);
        glEnd();
    }
    void CScene2D::RD_DestroyScene()
    {
    }
     
    void CScene2D::RD_ReSizeGLScene()
    {
        glClearColor(0.12, 0.12, 0.12, 0.0);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        gluOrtho2D(-100.0, 100.0, -100.0, 100.0);
    }
1 пользователей читают эту тему (1 гостей и 0 скрытых пользователей)
0 пользователей:


Рейтинг@Mail.ru
[ Script Execution time: 0,1079 ]   [ 19 queries used ]   [ Generated: 17.08.18, 03:16 GMT ]