OpenGLWindow.cpp

Go to the documentation of this file.

#include "GlobalGL.h"
#include "OpenGLWindow.h"

OpenGLWindow::OpenGLWindow( void ) {
  // needed handles are initialized to zero
  m_hWnd = NULL;
  m_hDC = NULL;
  m_hRC = NULL;

  // window position and size
  m_fullscreen = false;
  active = true;
  m_left = 0;                                               // window x Position
  m_top = 0;                                                // window y Position
  m_width = 800;
  m_height = 600;
  m_screenWidth = 1920;
  m_screenHeight = 1080;

  // frustum
  m_frustum.farDist = 5000.0;
  m_frustum.nearDist = 1.0;

  m_bpp = 32; // 32 bit farbtiefe anfordern
  //m_BitsPerPixel  = 16;                                               // Bits Per Pixel

  // input: characters and mouse
  for(unsigned char i=0;i<255;i++)
    keys[i] = false;
  keys[255] = false;
  m_mouseClick = false;
  m_mouseVisible = false;
}

OpenGLWindow::~OpenGLWindow( void ) {

}

bool OpenGLWindow::changeScreenResolution() {
  DEVMODE dmScreenSettings; // Device Mode
  ZeroMemory( &dmScreenSettings, sizeof( dmScreenSettings ) ); 

  dmScreenSettings.dmSize = sizeof( dmScreenSettings );
  dmScreenSettings.dmPelsWidth = getWidth(); // the new screen width
  dmScreenSettings.dmPelsHeight = getHeight(); // the new screen height
  dmScreenSettings.dmBitsPerPel = m_bpp; // the bits per pixel
  dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;

  if( ChangeDisplaySettings( &dmScreenSettings, CDS_FULLSCREEN )!= DISP_CHANGE_SUCCESSFUL ) {
    return false;
  }
  return true;
}

bool OpenGLWindow::create( const char * windowTitle, bool fullscreen, const char  * className, HINSTANCE hInstance, LPVOID lpParam ) {
  GLuint PixelFormat;
  DWORD dwExStyle;
  DWORD dwStyle;

  m_fullscreen = fullscreen;// Übernehmen der Vollbild-Einstellung

  if(m_fullscreen) {
    if( !changeScreenResolution() ) { // try to change resolution, switch to window mode or quit if failed
      if( MessageBox( NULL, "The requested fullscreen mode is not supported by\nyour video card. Use windowed mode instead?", "Question", MB_YESNO | MB_ICONEXCLAMATION ) == IDYES ) {
        m_fullscreen = false;
      } else {
        MessageBox( NULL, "Program will now close.", "ERROR", MB_OK | MB_ICONSTOP );
        return false;
      }
    }
  }

  RECT windowRect = { getLeft(), getTop(), getLeft() + getWidth(), getTop() + getHeight() };

  if( fullscreen ) {
    dwExStyle = WS_EX_APPWINDOW | WS_EX_TOPMOST;
    dwStyle = WS_POPUP;
    ShowCursor( FALSE );
  } else {
    dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
    dwStyle = WS_OVERLAPPEDWINDOW;

    AdjustWindowRectEx( &windowRect, dwStyle, false, dwExStyle );
    // move window top left corner to visible area
    if (windowRect.left < 0) {
      windowRect.right -= windowRect.left;
      windowRect.left = 0;
    }
    if (windowRect.top < 0) {
      windowRect.bottom -= windowRect.top;
      windowRect.top = 0;
    }
  }

  // finally create the OpenGL Window
  if ( !(m_hWnd=CreateWindowEx( dwExStyle, // style
    className,                          // window class
    windowTitle,                                 // title
    dwStyle |                           // style
    WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
    windowRect.left, windowRect.top, // left, top
    windowRect.right - windowRect.left, // height
    windowRect.bottom - windowRect.top, // width
    HWND_DESKTOP,                                // desktop as parent
    NULL,                               // no menu
    hInstance,                           // the instance
    lpParam)))                               // application class context
  {
    kill();
    MessageBox( NULL, "Window creation error.", "ERROR", MB_OK | MB_ICONEXCLAMATION );
    return FALSE;
  }

  // the propertys our window should have
  static PIXELFORMATDESCRIPTOR pfd;
  ZeroMemory( &pfd, sizeof( pfd ) ); // fill with zeros
  pfd.nSize = sizeof( PIXELFORMATDESCRIPTOR ); // size of Pixelformat Descriptors
  pfd.nVersion = 1; // necessary
  pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; // use double buffering
  pfd.iPixelType = PFD_TYPE_RGBA; // RGBA colors
  pfd.cColorBits = m_bpp; // color depth
  pfd.cDepthBits = 24;// depth buffer size
  pfd.iLayerType = PFD_MAIN_PLANE;

  if( !(m_hDC=GetDC( m_hWnd )) ) { // quit if failed
    kill();
    MessageBox( NULL, "Can't create a GL Device Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION );
    return false;
  }
  if( !(PixelFormat = ChoosePixelFormat( m_hDC, &pfd )) ) {
    kill();
    MessageBox( NULL, "Can't find a suitable PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION );
    return false;
  }
  if( !SetPixelFormat( m_hDC, PixelFormat, &pfd ) ) {
    kill();
    MessageBox( NULL, "Can't set the PixelFormat.", "ERROR", MB_OK | MB_ICONEXCLAMATION );
    return FALSE;
  }
  if( !(m_hRC = wglCreateContext( m_hDC )) ) {
    kill();
    MessageBox( NULL, "Can't create a GL Rendering Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION );
    return FALSE;
  }
  if( !wglMakeCurrent( m_hDC, m_hRC ) ) {
    kill();
    MessageBox( m_hWnd, "Can't activate the GL Rendering Context.", "ERROR", MB_OK | MB_ICONEXCLAMATION );
    return FALSE;
  }

  // everything fine. finally show window
  ShowWindow( m_hWnd, SW_SHOW );
  SetFocus( m_hWnd );
  reshape();
  return true;
}


float OpenGLWindow::getAspect( void ) {
  return m_frustum.aspect;
}

unsigned int OpenGLWindow::getHeight( void ) {
  if( m_fullscreen )
    return m_screenHeight;
  else
    return m_height;
}

unsigned int OpenGLWindow::getWidth( void ) {
  if( m_fullscreen )
    return m_screenWidth;
  else
    return m_width;
}

unsigned int OpenGLWindow::getLeft( void ) {
  if( m_fullscreen )
    return 0;
  else
    return m_left;
}

unsigned int OpenGLWindow::getTop( void ) {
  if( m_fullscreen )
    return 0;
  else
    return m_top;
}

FrustumInformation OpenGLWindow::getFrustum( void ) {
  return m_frustum;
}

bool OpenGLWindow::isFullscreen( void ) {
  return m_fullscreen;
}


void OpenGLWindow::kill( void ) {
  if( m_fullscreen ) {
    ChangeDisplaySettings( NULL, 0 );
    ShowCursor( TRUE );
  }

  if( m_hRC ) {
    if( !wglMakeCurrent( NULL, NULL ) )
      MessageBox( NULL, "Release of DC and RC failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION );
    if( !wglDeleteContext( m_hRC ) )
      MessageBox( NULL, "Release rendering context failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION );
    m_hRC = NULL;
  }
  if( m_hDC && !ReleaseDC( m_hWnd, m_hDC ) ) {
    MessageBox( NULL, "Release device context failed.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION );
    m_hDC = NULL;
  }
  if( m_hWnd && !DestroyWindow( m_hWnd ) )  {
    MessageBox( NULL, "Could not release hWnd.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION );
    m_hWnd = NULL;
  }
}


GLvoid OpenGLWindow::reshape( ) {
  GLsizei width = getWidth();
  GLsizei height = getHeight();
  if( height == 0 ) // avoid division by zero
    height = 1;

  // Calculate correct perspective and aspect ratio of the window
  m_frustum.aspect = (float)width / (float)height;
  glViewport( 0, 0, width, height );
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective( m_frustum.fov, m_frustum.aspect, m_frustum.nearDist, m_frustum.farDist );

  // do _not_ forget transforming 45 degree angle to degree for use with tangens function!
  m_frustum.nearHeight = 2 * tan( m_frustum.fov * ANGLE2DEG * 0.5 ) * m_frustum.nearDist;
  m_frustum.farHeight  = 2 * tan( m_frustum.fov * ANGLE2DEG * 0.5 ) * m_frustum.farDist;
  m_frustum.nearWidth  = m_frustum.nearHeight * m_frustum.aspect;
  m_frustum.farWidth   = m_frustum.farHeight  * m_frustum.aspect;

  glMatrixMode( GL_MODELVIEW );
  glLoadIdentity();
}

void OpenGLWindow::setLeft( unsigned int left ) {
  m_left = left;
}

void OpenGLWindow::setTop( unsigned int top ) {
  m_top = top;
}

void OpenGLWindow::setHeight( unsigned int height ) {
  if ( m_fullscreen )
    m_screenHeight = height;
  else
    m_height = height;
}

void OpenGLWindow::setWidth( unsigned int width ) {
  if ( m_fullscreen )
    m_screenWidth = width;
  else
    m_width = width;
}

void OpenGLWindow::setMousePosition( int x, int y ) {
  m_mousePos.x = x;
  m_mousePos.y = y;
}

Position OpenGLWindow::getMousePosition() {
  return m_mousePos;
}

void OpenGLWindow::setMouseClick( bool click ) {
  m_mouseClick = click;
}

bool OpenGLWindow::getMouseClick( void ) {
  return m_mouseClick;
}

void OpenGLWindow::showMousePointer( bool mouseVisible ) {
  m_mouseVisible = mouseVisible;
  if( m_fullscreen )
    ShowCursor( mouseVisible );
}