CustomUI.cpp

Go to the documentation of this file.

#ifdef _DEBUG
#define DEBUG_VS   // Uncomment this line to debug vertex shaders 
#define DEBUG_PS   // Uncomment this line to debug pixel shaders
#endif

#include <WinSock2.h>
#define _WINSOCKAPI_ 
#include <WS2tcpip.h>
#include <Windows.h>

#include "GameClass.h"

//--------------------------------------------------------------------------------------
// Entry point to the program. Initializes everything and goes into a message processing 
// loop. Idle time is used to render the scene.
//--------------------------------------------------------------------------------------
INT WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
        // Enable run-time memory check for debug builds.
#ifdef _DEBUG
#define _CRTDBG_MAPALLOC
        //_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_CHECK_CRT_DF);
        //_CrtSetBreakAlloc(486);
#endif

        GameClass game_class = GameClass();
        GameClass* gPtr = &game_class;

        // Set the callback functions. These functions allow DXUT to notify
        // the application about device changes, user input, and windows messages.  The 
        // callbacks are optional so you need only set callbacks for events you're interested 
        // in. However, if you don't handle the device reset/lost callbacks then the sample 
        // framework won't be able to reset your device since the application must first 
        // release all device resources before resetting.  Likewise, if you don't handle the 
        // device created/destroyed callbacks then DXUT won't be able to 
        // recreate your device resources.
        DXUTSetCallbackD3D9DeviceCreated(GameClass::OnCreateDevice, gPtr);
        DXUTSetCallbackD3D9DeviceReset(GameClass::OnResetDevice, gPtr);
        DXUTSetCallbackD3D9DeviceLost(GameClass::OnLostDevice, gPtr);
        DXUTSetCallbackD3D9DeviceDestroyed(GameClass::OnDestroyDevice, gPtr);
        DXUTSetCallbackMsgProc(GameClass::MsgProc, gPtr);
        DXUTSetCallbackKeyboard(GameClass::KeyboardProc, gPtr);
        DXUTSetCallbackD3D9FrameRender(GameClass::OnFrameRender, gPtr);
        DXUTSetCallbackFrameMove(GameClass::OnFrameMove, gPtr);
        DXUTSetCallbackD3D9DeviceAcceptable(GameClass::IsDeviceAcceptable, gPtr);
        DXUTSetCallbackDeviceChanging(GameClass::ModifyDeviceSettings, gPtr);

        // Show the cursor and clip it when in full screen
        DXUTSetCursorSettings(true, true);
        DXUTSetHotkeyHandling(false, false, false);
        DXUTSetConstantFrameTime(false);

        // Initialize DXUT and create the desired Win32 window and Direct3D 
        // device for the application. Calling each of these functions is optional, but they
        // allow you to set several options which control the behavior of the framework.
        DXUTInit(false, false, nullptr, false, true); // Parse the command line, bShowMsgBoxOnError, and show msgboxes

        RECT desktop;
        if (!GetWindowRect(GetDesktopWindow(), &desktop))
        {
                char msg[99];
                sprintf_s(msg, 99, "Error in GetWindowRect: %d", GetLastError());
                gPtr->logger->Log(msg, Logger::Fatal);
                return 0;
        }

        const HDC hDC = GetDC(nullptr); // NOLINT
        const int nLogPixelsY = GetDeviceCaps(hDC, LOGPIXELSY);
        ReleaseDC(nullptr, hDC);
        gPtr->dpiscale = static_cast<float>(nLogPixelsY) / 96.0f; // 96 per inch was the original design, canary 2.5, Bill 1.8

        gPtr->displayWidth = static_cast<float>(desktop.right - desktop.left);
        gPtr->displayHeight = static_cast<float>(desktop.bottom - desktop.top);
        const float xScale = gPtr->displayWidth / designedWidthC; // canary 2.3, Bill 2.3
        const float yScale = gPtr->displayHeight / designedHeightC; // canary 2.1, Bill 2.1
        if (gPtr->dpiscale > xScale)
                gPtr->dpiscale = xScale; // dpi now 2.3x
        if (gPtr->dpiscale > yScale)
                gPtr->dpiscale = yScale; // dpi now 2.1x
        if (gPtr->config.scale == 0.0f) // none configured
        {
                // default to DPI scale but no lower than 1.0 ... they will be able to later adjust to 0.5x the dpiscale but never lower than 1.0
                gPtr->config.scale = max(1, gPtr->dpiscale); 

                char msg[99];
                sprintf_s(msg, 99, "config initial scale %.1f (dpiscale %.1f)", gPtr->config.scale, gPtr->dpiscale);
                gPtr->logger->Log(msg, Logger::Level::Debug);
        }
        else if (gPtr->config.scale > min(xScale, yScale) * 1.5f) // make sure that previously saved scale doesn't exceed monitor width/height
        {
                char msg[99];
                sprintf_s(msg, 99, "config adjust scale was %.1f xScale %.1f yScale %.1f (min %.1f): %.1f", gPtr->config.scale, xScale, yScale, min(xScale, yScale), min(xScale, yScale) * 1.5f);
                gPtr->logger->Log(msg, Logger::Level::Debug);

                gPtr->config.scale = min(xScale, yScale) * 1.5f;
        }
        else if (gPtr->config.scale < max(1, 0.5f * gPtr->dpiscale))
        {
                char msg[99];
                sprintf_s(msg, 99, "config adjust scale was %.1f xScale %.1f yScale %.1f (min %.1f): %.1f", gPtr->config.scale, xScale, yScale, min(xScale, yScale), max(1, 0.5f * gPtr->dpiscale));
                gPtr->logger->Log(msg, Logger::Level::Debug);

                gPtr->config.scale = max(1, 0.5f * gPtr->dpiscale);
        }
        gPtr->displayscale = gPtr->config.scale;

        // 700 500 of 1080p looks good
        // Both these use Y because we lock the aspect ratio at 700x500
        if (FAILED(DXUTCreateDevice(true, static_cast<int>(700 * gPtr->displayscale), static_cast<int>(500 * gPtr->displayscale))))
        {
                gPtr->logger->Log("Could not DXUTCreateDevice() instance...", Logger::Level::Fatal);
                return 0;
        }

        if (!SetWindowText(DXUTGetHWND(), L"Rise: The Vieneo Province"))
        {
                char msg[99];
                sprintf_s(msg, 99, "Error in SetWindowText: %d", GetLastError());
                gPtr->logger->Log(msg, Logger::Fatal);
                return 0;
        }

        // Keyboard and force-feedback
        if (FAILED(gPtr->InitDirectInput(DXUTGetHWND())))
        {
                gPtr->logger->Log("Could not InitDirectInput() instance...", Logger::Level::Fatal);
                return 0;
        }

        try
        {
                // Pass control to DXUT for handling the message pump and 
                // dispatching render calls. DXUT will call your FrameMove 
                // and FrameRender callback when there is idle time between handling window messages.
                DXUTMainLoop();

                gPtr->logger->AddToCallStack("Exited DXUTMainLoop()");

                if (DXUTGetExitCode() != 0)
                        gPtr->logger->Log(DXUTGetErrorMessage(), Logger::Level::Fatal);
        }
        catch (std::exception& e)
        {
                char msg[199];
                sprintf_s(msg, 199, "std::exception '%s'", e.what());
                gPtr->logger->Log(msg, Logger::Level::Fatal);
        }
        catch (char* e)
        {
                char msg[199];
                sprintf_s(msg, 199, "char* '%s'", e);
                gPtr->logger->Log(msg, Logger::Level::Fatal);
        }
        catch (std::string& e)
        {
                char msg[199];
                sprintf_s(msg, 199, "std::string '%s'", e.c_str());
                gPtr->logger->Log(msg, Logger::Level::Fatal);
        }
        catch (...)
        {
                gPtr->logger->Log("Untyped exception occurred", Logger::Level::Fatal);
        }

        // Perform any application-level cleanup here. Direct3D device resources are released within the
        // appropriate callback functions and therefore don't require any cleanup code here.

        gPtr->Close();

        DXUTSetCallbackMsgProc(nullptr, nullptr);
        DXUTSetCallbackD3D9DeviceCreated(nullptr, nullptr);
        DXUTSetCallbackD3D9DeviceReset(nullptr, nullptr);
        DXUTSetCallbackD3D9DeviceLost(nullptr, nullptr);
        DXUTSetCallbackD3D9DeviceDestroyed(nullptr, nullptr);
        DXUTSetCallbackMsgProc(nullptr, nullptr);
        DXUTSetCallbackKeyboard(nullptr, nullptr);
        DXUTSetCallbackD3D9FrameRender(nullptr, nullptr);
        DXUTSetCallbackFrameMove(nullptr, nullptr);
        DXUTSetCallbackD3D9DeviceAcceptable(nullptr, nullptr);
        DXUTSetCallbackDeviceChanging(nullptr, nullptr);

//      gPtr->OnLostDevice(gPtr);
        gPtr->OnDestroyDevice(gPtr);

        return DXUTGetExitCode();
}