Win32Window.cpp

Go to the documentation of this file.

#include "MercuryDisplay.h"
#include "Win32Window.h"
#include <windows.h>
#include "MercuryLog.h"
#include "MercuryINI.h"
#include "crash/crashDefines.h"
#include "MercuryInputWin32.h"

bool active = false;
bool W32W_KEYS[256];

//These two only work on Win32; it's for the input grabbing.
int g_iWindowX, g_iWindowY;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);   // Declaration For WndProc

Win32Window::Win32Window()
:MercuryWindow(0, 0, false)
{
    m_extendedStyle = (DWORD)NULL;
    m_style = (DWORD)NULL;      
    m_fullscreen = false;
    m_hRC = NULL;
    m_hDC = NULL;
    m_hWnd = NULL;
    m_hInstance = NULL; 
    active = false;
    memset(W32W_KEYS, false, 256);

//  SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
//  SetProcessPriorityBoost(GetCurrentProcess(), true);
}

Win32Window::~Win32Window()
{
    ShowCursor(true);
    DestroyWindowAndRender();
}

bool Win32Window::Update(const float dTime)
{
    RECT t;
    GetWindowRect( (HWND)m_hWnd, &t );
    g_iWindowX = t.left; g_iWindowY = t.top;

    while (PeekMessage(&m_message, NULL, 0, 0, PM_REMOVE))
    {
        // Stop Update if the user is trying to quit
        if (m_message.message == WM_QUIT)
            return false;
        else
        {
            TranslateMessage(&m_message);               // Translate The Message
            DispatchMessage(&m_message);                // Dispatch The Message
        }
    }
    return true;
}

bool Win32Window::MakeWindow(const char* title, int width, int height, int bits, bool fullscreen)
{
    m_bits = bits;
    m_width = width;
    m_height = height;
    m_fullscreen = fullscreen;
    SetTitle(title);

    //Dimensions
    m_rect.left = (long)0;
    m_rect.top = (long)0;
    m_rect.right = (long)m_width;
    m_rect.bottom = (long)m_height;

    m_fullscreen = fullscreen;

    m_hInstance         = GetModuleHandle(NULL);
    m_win.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    m_win.lpfnWndProc   = (WNDPROC)WndProc;
    m_win.cbClsExtra    = 0;
    m_win.cbWndExtra    = 0;
    m_win.hInstance     = m_hInstance;
    m_win.hIcon         = LoadIcon(NULL, IDI_WINLOGO);
    m_win.hCursor       = LoadCursor(NULL, IDC_ARROW);
    m_win.hbrBackground = NULL;
    m_win.lpszMenuName  = NULL;
    m_win.lpszClassName = GetTitle();

    if (!RegisterClass(&m_win))
    {
        LOG.Warn(ssprintf("Failed To Register Window Class %s", GetTitle()));
        return false;
    }

    if (m_fullscreen)
    {
        DEVMODE dmScreenSettings;
        memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
        dmScreenSettings.dmSize = sizeof(dmScreenSettings);
        dmScreenSettings.dmPelsWidth    = width;
        dmScreenSettings.dmPelsHeight   = height;
        dmScreenSettings.dmBitsPerPel   = bits;
        dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

        if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
            m_fullscreen = false;
    }

    if (m_fullscreen)
    {
        m_extendedStyle = WS_EX_APPWINDOW;
        m_style = WS_POPUP;
        ShowCursor(false);
    }
    else
    {
        m_extendedStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
        m_style = WS_OVERLAPPEDWINDOW;
    }

    AdjustWindowRectEx(&m_rect, m_style, false, m_extendedStyle);

    m_hWnd = (void*)CreateWindowEx(m_extendedStyle,
                                GetTitle(),                         // Class Name
                                title,
                                m_style |                           // Defined Window Style
                                WS_CLIPSIBLINGS |                   // Required Window Style
                                WS_CLIPCHILDREN,                    // Required Window Style
                                0, 0,                               // Window Position
                                m_rect.right-m_rect.left,           // Width
                                m_rect.bottom-m_rect.top,           // Height
                                NULL,                               // No Parent Window
                                NULL,                               // No Menu
                                m_hInstance,
                                NULL);                              // Dont Pass Anything To WM_CREATE

    if (!m_hWnd)
    {
        LOG.Warn("Window Creation Error.");
        DestroyWindowAndRender();
        return false;
    }

    ShowWindow((HWND)m_hWnd,SW_SHOW);
    SetForegroundWindow((HWND)m_hWnd);                  // Slightly Higher Priority
    SetFocus((HWND)m_hWnd);                             // Sets Keyboard Focus To The Window

    return true;
}

bool Win32Window::MakeRender(const char* title, int width, int height, int bits, bool fullscreen, RendererType rt)
{
    m_brt = rt;

    MakeWindow( title, width, height, bits, fullscreen );
    if ( rt == RT_OGL )
    {
        if (!RestoreDevice())
            return false;

        if (!(m_hRC=wglCreateContext(m_hDC)))
        {
            LOG.Warn("GL Rendering failed.");
            DestroyWindowAndRender();
            return false;
        }

        return MakeRenderCurrent();
    }

    if( rt == RT_D3D )
    {
        if( !RestoreDevice())
        {
            return false;
        }
        //No code here.
        return true;
    }

    if( rt == RT_SW )
    {
        if( !RestoreDevice() )
            return false;
        m_compatDC = CreateCompatibleDC( m_hDC );
        m_hbm = CreateCompatibleBitmap( m_hDC, width, height );
        SelectObject( m_compatDC, m_hbm );
        m_BackBuffer = new unsigned char[width * height * bits / 8];
        return true;
    }

    return false;
}

bool Win32Window::MakeRenderCurrent()
{
    if(!wglMakeCurrent(m_hDC,m_hRC))
    {
        LOG.Warn("Rendering Context failed.");
        DestroyWindowAndRender();
        return false;
    }
    return true;
}

#ifndef WM_MOUSEWHEEL
# define WM_MOUSEWHEEL (WM_MOUSELAST + 1)
#endif

LRESULT CALLBACK WndProc(   HWND    hWnd,
                            UINT    uMsg,
                            WPARAM  wParam,
                            LPARAM  lParam)
{
    /* I should replace this section with some sort of messaging system. */
    switch (uMsg)                                   // Check For Windows Messages
    {
        case WM_MOUSEWHEEL:
            //Ok, this is where wheel stuff happens.  Not sure how to implement it yet.
            //We probably should look at wParam and lParam
        case WM_ACTIVATE:                           
            if (!HIWORD(wParam))                    
                active = true;                      
            else
                active = false;
            return 0;
            break;
        case WM_SYSCOMMAND:                         // Intercept System Commands
            switch (wParam)
            {
                case SC_SCREENSAVE:
                case SC_MONITORPOWER:
                return 0;
            }
            break;
        case WM_CLOSE:
            PostQuitMessage(0);                     // Quit Message
            return 0;
        case WM_KEYDOWN:                            // Is A Key Being Held Down?
            W32W_KEYS[wParam] = true;               // If So, Mark It As TRUE

            //Key repeat
            if( lParam & 0x40000000 )
                DeviceKeyboardW32::TickRepeat( wParam );
            return 0;
        case WM_KEYUP:                              // Has A Key Been Released?
            W32W_KEYS[wParam] = false;              // If So, Mark It As FALSE
            return 0;
        case WM_SIZE:                               // Resize The OpenGL Window
            DISPLAY->Resize(LOWORD(lParam),HIWORD(lParam));  // LoWord=Width, HiWord=Height
            return 0;
    }

    return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

bool Win32Window::RestoreDevice()
{
    static  PIXELFORMATDESCRIPTOR pfd =
    {
        sizeof(PIXELFORMATDESCRIPTOR),
        1,                                          // Version?
        PFD_DRAW_TO_WINDOW |                        // Window
        PFD_SUPPORT_OPENGL |                        // OpenGL
        PFD_DOUBLEBUFFER,                           // Double Buffering
        PFD_TYPE_RGBA,                              // RGBA
        m_bits,
        0, 0, 0, 0, 0, 0,                           // Color Bits Ignored
        0,                                          // No Alpha Buffer
        0,                                          // Shift Bit Ignored
        0,                                          // No Accumulation Buffer
        0, 0, 0, 0,                                 // Accumulation Bits Ignored
        16,                                         // 16Bit Z-Buffer (Depth Buffer)  
        8,                                          // 8bit Stencil Buffer
        0,                                          // No Auxiliary Buffer
        PFD_MAIN_PLANE,                             // Main Drawing Layer
        0,                                          // Reserved
        0, 0, 0                                     // Layer Masks Ignored
    };

    if (!(m_hDC = GetDC((HWND)m_hWnd))) // Did We Get A Device Context?
    {
        LOG.Warn("Create A GL Device failed.");
        DestroyWindowAndRender();
        return false;
    }

    if (!(m_pixelFormat = ChoosePixelFormat(m_hDC,&pfd)))   // Did Windows Find A Matching Pixel Format?
    {
        LOG.Warn("PixelFormat failed.");
        DestroyWindowAndRender();
        return false;
    }

    if(!SetPixelFormat(m_hDC, m_pixelFormat, &pfd))     // Are We Able To Set The Pixel Format?
    {
        LOG.Warn("Set PixelFormat failed.");
        DestroyWindowAndRender();
        return false;
    }

    return MakeRenderCurrent();
}

void Win32Window::DestroyWindow()
{
    if (m_fullscreen)
    {
        ChangeDisplaySettings(NULL,0);                  // Desktop
        ShowCursor(true);
    }

    if (m_hDC && !ReleaseDC((HWND)m_hWnd,m_hDC))
    {
        LOG.Log("Release Device Context Failed.");
        m_hDC = NULL;
    }

    if (m_hWnd && !::DestroyWindow((HWND)m_hWnd))
    {
        LOG.Log("Could Not Release hWnd.");
        m_hWnd = NULL;
    }

    if (!UnregisterClass(GetTitle(),m_hInstance))
    {
        LOG.Log(ssprintf("Could Not Unregister Class %s", GetTitle()));
        m_hInstance = NULL;
    }
}

void Win32Window::DestroyWindowAndRender()
{
    if (m_hRC)
    {
        if (!wglMakeCurrent(NULL,NULL))                 // Release The DC And RC Contexts?
            LOG.Log("Release Of DC And RC Failed.");

        if (!wglDeleteContext(m_hRC))
            LOG.Log("Destroy m_hRC failed");

        m_hRC = NULL;
    }

    DestroyWindow();
}

bool Win32Window::HasFocus()
{
    return ( GetForegroundWindow() == this->m_hWnd );
}

void Win32Window::SwapBuffersInternal()
{
    if( m_brt == RT_SW )
    {
        SetBitmapBits( m_hbm,m_width*m_height*m_bits/8,m_BackBuffer );
        BitBlt( m_hDC,0,0,m_width,m_height,m_compatDC ,0,0,SRCCOPY );
        UpdateWindow( (HWND)m_hWnd );
        return;
    }

	::SwapBuffers(m_hDC);
}

unsigned char * Win32Window::GetBackDirectBuffer()
{
    if( m_brt == RT_SW )
        return m_BackBuffer;
    else
        return NULL;
}


/* Much thanks to the NeHe lesson one tutorial for explaining how to create
 * and set up an OpenGL window for Windows.
 * http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=01
 *
 * 
 * Copyright (c) 2005-2006, Joshua Allen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by