На главную
ПРАВИЛА 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, 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,0941 ]   [ 14 queries used ]   [ Generated: 14.11.18, 02:52 GMT ]