_In_opt_ HINSTANCE hPrevInstance,

_In_ LPWSTR lpCmdLine,

_In_ int nCmdShow)

{

UNREFERENCED_PARAMETER(hPrevInstance);

UNREFERENCED_PARAMETER(lpCmdLine);

// We can only run if an instance of a class that inherits from Framework

// has been created

if (_thisFramework)

{

return _thisFramework->Run(hInstance, nCmdShow);

}

return -1;

: _hInstance(0), _hWnd(0), _width(width), _height(height)

{

_thisFramework = this;

{

int returnValue;

_hInstance = hInstance;

if (!InitialiseMainWindow(nCmdShow))

{

return -1;

}

if (!Initialise())

{

return -1;

}

returnValue = MainLoop();

Shutdown();

return returnValue;

{

MSG msg;

HACCEL hAccelTable = LoadAccelerators(_hInstance, MAKEINTRESOURCE(IDC_RASTERISER));

LARGE_INTEGER counterFrequency;

LARGE_INTEGER nextTime;

LARGE_INTEGER currentTime;

LARGE_INTEGER lastTime;

bool updateFlag = true;

// Initialise timer

QueryPerformanceFrequency(&counterFrequency);

DWORD msPerFrame = static_cast<DWORD>(counterFrequency.QuadPart / DEFAULT_FRAMERATE);

double timeFactor = 1.0 / counterFrequency.QuadPart;

QueryPerformanceCounter(&nextTime);

lastTime = nextTime;

// Main message loop:

msg.message = WM_NULL;

while (msg.message != WM_QUIT)

{

if (updateFlag)

{

QueryPerformanceCounter(&currentTime);

_timeSpan = (currentTime.QuadPart - lastTime.QuadPart) * timeFactor;

lastTime = currentTime;

Update(_bitmap);

updateFlag = false;

}

QueryPerformanceCounter(&currentTime);

// Is it time to render the frame?

if (currentTime.QuadPart > nextTime.QuadPart)

{

Render(_bitmap);

// Make sure that the window gets repainted

InvalidateRect(_hWnd, NULL, FALSE);

// Set time for next frame

nextTime.QuadPart += msPerFrame;

// If we get more than a frame ahead, allow one to be dropped

// Otherwise, we will never catch up if we let the error accumulate

// and message handling will suffer

if (nextTime.QuadPart < currentTime.QuadPart)

{

nextTime.QuadPart = currentTime.QuadPart + msPerFrame;

}

updateFlag = true;

}

// Each time we go through this loop, we look to see if there is a Windows message

// that needs to be processed

if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))

{

if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))

{

TranslateMessage(&msg);

DispatchMessage(&msg);

}

}

}

return static_cast<int>(msg.wParam);

{

// Default render method just sets the background to the default window colour

bitmap.Clear(reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1));

{

#define MAX_LOADSTRING 100

WCHAR windowTitle[MAX_LOADSTRING];

WCHAR windowClass[MAX_LOADSTRING];

LoadStringW(_hInstance, IDS_APP_TITLE, windowTitle, MAX_LOADSTRING);

LoadStringW(_hInstance, IDC_RASTERISER, windowClass, MAX_LOADSTRING);

WNDCLASSEXW wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_HREDRAW | CS_VREDRAW;

wcex.lpfnWndProc = WndProc;

wcex.cbClsExtra = 0;

wcex.cbWndExtra = 0;

wcex.hInstance = _hInstance;

wcex.hIcon = LoadIcon(_hInstance, MAKEINTRESOURCE(IDI_RASTERISER));

wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);

wcex.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1);

wcex.lpszMenuName = nullptr;

wcex.lpszClassName = windowClass;

wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

if (!RegisterClassExW(&wcex))

{

return false;

}

// Now work out how large the window needs to be for our required client window size

RECT windowRect = { 0, 0, static_cast<LONG>(_width), static_cast<LONG>(_height) };

AdjustWindowRect(&windowRect, WS_OVERLAPPEDWINDOW, FALSE);

_width = windowRect.right - windowRect.left;

_height = windowRect.bottom - windowRect.top;

_hWnd = CreateWindowW(windowClass,

windowTitle,

WS_OVERLAPPEDWINDOW,

CW_USEDEFAULT, CW_USEDEFAULT, _width, _height,

nullptr, nullptr, _hInstance, nullptr);

if (!_hWnd)

{

return false;

}

ShowWindow(_hWnd, nCmdShow);

UpdateWindow(_hWnd);

// Create a bitmap of the same size as the client area of the window. This is what we

// will be drawing on

RECT clientArea;

GetClientRect(_hWnd, &clientArea);

_bitmap.Create(_hWnd, clientArea.right - clientArea.left, clientArea.bottom - clientArea.top);

return true;

{

if (_thisFramework != NULL)

{

// If framework is started, then we can call our own message proc

return _thisFramework->MsgProc(hWnd, message, wParam, lParam);

}

else

{

// otherwise, we just pass control to the default message proc

return DefWindowProc(hWnd, message, wParam, lParam);

}

{

switch (message)

{

case WM_PAINT:

{

// Copy the contents of the bitmap to the window

PAINTSTRUCT ps;

HDC hdc = BeginPaint(hWnd, &ps);

BitBlt(hdc, 0, 0, _bitmap.GetWidth(), _bitmap.GetHeight(), _bitmap.GetDC(), 0, 0, SRCCOPY);

EndPaint(hWnd, &ps);

}

break;

case WM_SIZE:

// Delete any existing bitmap and create a new one of the required size.

_bitmap.Create(hWnd, LOWORD(lParam), HIWORD(lParam));

// Now render to the resized bitmap

Update(_bitmap);

Render(_bitmap);

InvalidateRect(hWnd, NULL, FALSE);

break;

case WM_DESTROY:

PostQuitMessage(0);

break;

default:

return DefWindowProc(hWnd, message, wParam, lParam);

}

return 0;