Fixed time step

#define D3D_DEBUG_INFO          1
#define WIN32_LEAN_AND_MEAN

#include <Windows.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <vector>
#include <memory>
#include <array>
#include <ctime>

typedef unsigned long long uint64;

const SIZE WIN_DIM   = { 600, 600 };
HWND hwnd                           = NULL;;
LPDIRECT3D9       d3d9              = NULL;
LPDIRECT3DDEVICE9 d3d9device        = NULL;

class Timer
{
private:
    uint64 lastTime;
    uint64 currTime;

    uint64 getRealTime()
    {
        uint64 time;
        QueryPerformanceCounter(reinterpret_cast<LARGE_INTEGER*>(&time));
        return time;
    }

    void updateBy(uint64 t)
    {
        currTime += t;
    }

public:
    Timer()
        : lastTime(0ULL), currTime(0ULL)
    {
    }

    void update()
    {
        auto timeNow = getRealTime();
        auto diff    = timeNow - lastTime;
        lastTime     = timeNow;
        updateBy(diff);
    }

    uint64 get() const { return currTime; }
};

Timer gTimer;

float randfr(float l, float h)
{
    return l + (float)rand()/((float)RAND_MAX/(h-l));
}

struct Vertex
{
    D3DXVECTOR3 pos;
};

class Drawer
{
private:
    LPDIRECT3DVERTEXBUFFER9      vBuffer;
    LPDIRECT3DINDEXBUFFER9       iBuffer;
    LPDIRECT3DVERTEXDECLARATION9 vDeclaration;
    std::size_t                  maxVertices;
    std::vector<Vertex>          vVertices;
public:
    Drawer()
    {
        maxVertices = 1000u;
        HRESULT hr;
        hr = d3d9device->CreateVertexBuffer(sizeof(Vertex) * maxVertices, D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC, 0, D3DPOOL_DEFAULT, &vBuffer, nullptr);
        if(FAILED(hr))
        {
            MessageBox(0, TEXT("CreateVertexBuffer() failed!"), 0, MB_OK);
        }

        hr = d3d9device->CreateIndexBuffer(sizeof(USHORT) * ((maxVertices / 4) * 6), D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &iBuffer, nullptr);
        if(FAILED(hr))
        {
            MessageBox(0, TEXT("CreateIndexBuffer() failed!"), 0, MB_OK);
        }

        D3DVERTEXELEMENT9 vertexElements[] =
        {
            {0, 0,  D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
            D3DDECL_END()
        };
        hr = d3d9device->CreateVertexDeclaration(vertexElements, &vDeclaration);
        if(FAILED(hr))
        {
            MessageBox(0, TEXT("CreateVertexDeclaration() failed!"), 0, MB_OK);
        }

        int index       = 0;
        USHORT* indices = nullptr;
        iBuffer->Lock(0, 0, reinterpret_cast<LPVOID*>(&indices), D3DLOCK_DISCARD);
        for(USHORT vertex = 0; vertex < static_cast<USHORT>(maxVertices); vertex += 4)
        {
            indices[index]     = vertex;
            indices[index + 1] = vertex + 1;
            indices[index + 2] = vertex + 3;
            indices[index + 3] = vertex + 1;
            indices[index + 4] = vertex + 2;
            indices[index + 5] = vertex + 3;
            index += 6;
        }
        iBuffer->Unlock();
    }

    ~Drawer()
    {
        release();
    }
    void release()
    {
        vBuffer->Release();
        iBuffer->Release();
        vDeclaration->Release();
    }
    void addVertex(const Vertex& v) { vVertices.push_back(v); }

    void drawAll()
    {
        if(!vVertices.empty())
        {
            d3d9device->SetVertexDeclaration(vDeclaration);
            d3d9device->SetIndices(iBuffer);
            d3d9device->SetStreamSource(0, vBuffer, 0, sizeof(Vertex));

            DWORD numTris                = 0;

            Vertex* pVertices;
            vBuffer->Lock(0, 0, reinterpret_cast<LPVOID*>(&pVertices), D3DLOCK_DISCARD);

            for(std::size_t i = 0; i < (vVertices.size() / 4u); ++i)
            {
                *pVertices++ = vVertices[i * 4 + 0];
                *pVertices++ = vVertices[i * 4 + 1];
                *pVertices++ = vVertices[i * 4 + 2];
                *pVertices++ = vVertices[i * 4 + 3];

                numTris += 2;

                if(numTris == ((maxVertices / 4) * 2))
                {
                    vBuffer->Unlock();
                    d3d9device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, numTris * 2, 0, numTris);
                    vBuffer->Lock(0, 0, reinterpret_cast<LPVOID*>(&pVertices), D3DLOCK_DISCARD);
                    numTris = 0;
                }
            }
            vBuffer->Unlock();

            if(numTris > 0)
            {
                d3d9device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, numTris * 2, 0, numTris);
            }
            vVertices.clear();
        }
    }
};

Drawer* gDrawer;

class Sprite
{
private:
    D3DXVECTOR2 pos;
    D3DXVECTOR2 lastPos;
    D3DXVECTOR2 targetPos;
    D3DXVECTOR2 dim;
    std::array<Vertex, 4u> verts;
public:
    Sprite(const D3DXVECTOR2& startPos, float size)
        : pos(startPos), lastPos(startPos), targetPos(0.0f, 0.0f), dim(size, size)
    {
        float maxX = (float)WIN_DIM.cx - size;
        float maxY = (float)WIN_DIM.cy - size;
        targetPos = D3DXVECTOR2(randfr(0.0f, maxX), randfr(0.0f, maxY));
    }
    const D3DXVECTOR2& getPosition() const { return pos; }
    void setPos(const D3DXVECTOR2& _pos) { pos = _pos; }
    const D3DXVECTOR2& getDim() { return dim; }

    void moveRandom()
    {
        float moveSpeed = 0.1f;

        static const float collDist   = 2.0f;
        static const float collDistSq = collDist * collDist;

        auto oldPos      = getPosition();
        D3DXVECTOR2 dir  = targetPos - oldPos;
        float currDistSq = D3DXVec2LengthSq(&dir);
        D3DXVec2Normalize(&dir, &dir);

        D3DXVECTOR2 newPos = oldPos + dir * moveSpeed;
        setPos(newPos);

        if(collDistSq > currDistSq)
        {
            float maxX = (float)WIN_DIM.cx - dim.x;
            float maxY = (float)WIN_DIM.cy - dim.y;
            targetPos = D3DXVECTOR2(randfr(0.0f, maxX), randfr(0.0f, maxY));
        }
    }

    void commitVertices()
    {
        lastPos    = pos;

        verts[0].pos = D3DXVECTOR3(pos.x,         pos.y        , 1.0f);
        verts[1].pos = D3DXVECTOR3(pos.x + dim.x, pos.y        , 1.0f);
        verts[2].pos = D3DXVECTOR3(pos.x + dim.x, pos.y + dim.y, 1.0f);
        verts[3].pos = D3DXVECTOR3(pos.x,         pos.y + dim.y, 1.0f);

        gDrawer->addVertex(verts[0]);
        gDrawer->addVertex(verts[1]);
        gDrawer->addVertex(verts[2]);
        gDrawer->addVertex(verts[3]);
    }

    void update(uint64 dt)
    {
        float t = dt * (1.0f / 1000000.0f);
        D3DXVECTOR2 result_pos;
        D3DXVec2Lerp(&result_pos, &pos, &lastPos, t);
        pos = result_pos;
    }
};

typedef std::shared_ptr<Sprite> sp_Sprite;
typedef std::vector<sp_Sprite>  v_Sprite;
v_Sprite vSprites;

D3DMATRIX* D3DXMatrixOrtho2D(D3DMATRIX* m, const float w, const float h, const float znear, const float zfar)
{
    m->_11 = 2.0f / w;
    m->_12 = 0.0f;
    m->_13 = 0.0f;
    m->_14 = 0.0f;
    m->_21 = 0.0f;
    m->_22 = 2.0f / -h;
    m->_23 = 0.0f;
    m->_24 = 0.0f;
    m->_31 = 0.0f;
    m->_32 = 0.0f;
    m->_33 = 1.0f / (zfar - znear);
    m->_34 = 0.0f;
    m->_41 = (w + 1.0f) / -w;
    m->_42 = (h + 1.0f) / h;
    m->_43 = znear / (znear - zfar);
    m->_44 = 1.0;
    return m;
}

D3DXMATRIX proj;

bool run            = true;

bool init();
void sceneMove();
void sceneUpdate(uint64 dt);
void draw();
void close();

LRESULT CALLBACK StaticWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
    case WM_KEYUP:
        {
            if(wParam == VK_ESCAPE)
            {
                run = false;
            }
            return 0;
        }break;
    case WM_CLOSE:
        {
            run = false;
            return 0;
        }break;
    case WM_DESTROY:
        {
            PostQuitMessage(0);
            return 0;
        }break;
    };
    return DefWindowProc(hWnd, msg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASS wndClass;
    memset(&wndClass, 0, sizeof(WNDCLASS));
    wndClass.hInstance     = GetModuleHandle(0);
    wndClass.style         = CS_HREDRAW | CS_VREDRAW;
    wndClass.lpfnWndProc   = reinterpret_cast<WNDPROC>( StaticWindowProc );
    wndClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wndClass.lpszClassName = TEXT("FixTimeStepClass");
    wndClass.hbrBackground = GetSysColorBrush(COLOR_3DFACE);

    DWORD style = WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_CLIPSIBLINGS | WS_MINIMIZEBOX | WS_THICKFRAME;
    style |= WS_VISIBLE;

    if(0 == RegisterClass(&wndClass))
    {
        MessageBox(0, TEXT("RegisterClass() failed!"), 0, 0);
        return EXIT_FAILURE;
    }

    RECT clientSize;
    clientSize.top    = 0;
    clientSize.left   = 0;
    clientSize.right  = WIN_DIM.cx;
    clientSize.bottom = WIN_DIM.cy;
    AdjustWindowRect(&clientSize, style, FALSE);
    int realWidth  = clientSize.right - clientSize.left;
    int realHeight = clientSize.bottom - clientSize.top;
    int windowLeft = (GetSystemMetrics(SM_CXSCREEN) - realWidth) / 2;
    int windowTop  = (GetSystemMetrics(SM_CYSCREEN) - realHeight) / 2;

    hwnd = CreateWindowEx(0,
        TEXT("FixTimeStepClass"), TEXT("FixTimeStep"), style,
        windowLeft, windowTop, realWidth, realHeight,
        NULL, NULL, GetModuleHandle(0), NULL);
    if(NULL == hwnd)
    {
        MessageBox(0, TEXT("CreateWindowEx() failed!"), 0, 0);
        return EXIT_FAILURE;
    }

    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);

    if(!init())
    {
        close();
        return EXIT_FAILURE;
    }

    while(run)
    {
        MSG  msg   = {0};
        while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        // step one
        sceneMove();

        // step two
        static const uint64 freq = 33333ull;
        static auto updatedTime  = gTimer.get();
        auto currTime            = gTimer.get();
        while((currTime - updatedTime) > freq )
        {
            sceneUpdate(freq);
            updatedTime += freq;
        }

        // step three
        draw();
    }

    close();
    return EXIT_SUCCESS;
}

bool init()
{
    HRESULT hr = D3D_OK;
    D3DPRESENT_PARAMETERS  presentParams;
    D3DCAPS9               caps;
    D3DDISPLAYMODE         displayMode;
    D3DADAPTER_IDENTIFIER9 adapterIdentifier;
    UINT                   adapter;
    D3DDEVTYPE             deviceType;
    memset(reinterpret_cast<void*>(&presentParams),     0, sizeof(D3DPRESENT_PARAMETERS));
    memset(reinterpret_cast<void*>(&caps),              0, sizeof(D3DCAPS9));
    memset(reinterpret_cast<void*>(&displayMode),       0, sizeof(D3DDISPLAYMODE));
    memset(reinterpret_cast<void*>(&adapterIdentifier), 0, sizeof(D3DADAPTER_IDENTIFIER9));

    if(NULL == (d3d9 = Direct3DCreate9(D3D_SDK_VERSION)))
    {
        MessageBox(0, TEXT("Direct3DCreate9() failed!"), 0, 0);
        return false;
    }

    hr = d3d9->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &displayMode);
    if(FAILED(hr))
    {
        MessageBox(0, TEXT("GetAdapterDisplayMode() failed!"), 0, 0);
        return false;
    }

    hr = d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &caps);
    if(FAILED(hr))
    {
        MessageBox(0, TEXT("GetDeviceCaps() failed!"), 0, 0);
        return false;
    }

    hr = d3d9->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &adapterIdentifier);
    if(FAILED(hr))
    {
        MessageBox(0, TEXT("GetAdapterIdentifier() failed!"), 0, 0);
        return false;
    }

    //
    presentParams.hDeviceWindow              = hwnd;
    presentParams.Windowed                   = TRUE;
    presentParams.BackBufferWidth            = 0;
    presentParams.BackBufferHeight           = 0;
    presentParams.BackBufferCount            = 1;
    presentParams.SwapEffect                 = D3DSWAPEFFECT_DISCARD;
    presentParams.BackBufferFormat           = displayMode.Format;
    presentParams.MultiSampleType            = D3DMULTISAMPLE_NONE;
    presentParams.MultiSampleQuality         = 0;
    presentParams.FullScreen_RefreshRateInHz = 0;
#if 1
    presentParams.PresentationInterval       = D3DPRESENT_INTERVAL_ONE;
#else
    presentParams.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;
#endif
    presentParams.EnableAutoDepthStencil     = TRUE;
    presentParams.AutoDepthStencilFormat     = D3DFMT_D16;
    presentParams.Flags                      = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;

    DWORD Flags  = D3DCREATE_HARDWARE_VERTEXPROCESSING;
    adapter      = D3DADAPTER_DEFAULT;
    deviceType   = D3DDEVTYPE_HAL;

    hr = d3d9->CreateDevice(adapter, deviceType, presentParams.hDeviceWindow, Flags, &presentParams, &d3d9device);
    if(FAILED(hr))
    {
        MessageBox(0, TEXT("CreateDevice() failed!"), 0, 0);
        return false;
    }

    d3d9device->SetRenderState(D3DRS_LIGHTING, FALSE);

    gDrawer = new Drawer;

    const std::size_t numSprites = 100u;
    for(std::size_t i = 0u; i < numSprites; ++i)
    {
        float size = 15.0f;
        float maxX = (float)WIN_DIM.cx - size;
        float maxY = (float)WIN_DIM.cy - size;
        D3DXVECTOR2 startPos = D3DXVECTOR2(randfr(0.0f, maxX), randfr(0.0f, maxY));
        vSprites.push_back( sp_Sprite( new Sprite(startPos, size) ) );
    }

    D3DXMatrixOrtho2D(&proj, (float)WIN_DIM.cx, (float)WIN_DIM.cy, 0.0f, 1.0f);

    return true;
}

void sceneMove()
{
    for(std::size_t i = 0u; i < vSprites.size(); ++i)
    {
        vSprites[i]->moveRandom();
        vSprites[i]->commitVertices();
    }
}

void sceneUpdate(uint64 dt)
{
    for(std::size_t i = 0u; i < vSprites.size(); ++i)
    {
        vSprites[i]->update(dt);
    }
}

void draw()
{
    d3d9device->BeginScene();
    d3d9device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(255, 255, 0, 255), 1.0f, 0);

    D3DXMATRIX idnt;
    D3DXMatrixIdentity(&idnt);
    d3d9device->SetTransform(D3DTS_PROJECTION, &proj);
    d3d9device->SetTransform(D3DTS_VIEW, &idnt);
    d3d9device->SetTransform(D3DTS_WORLD, &idnt);

    gDrawer->drawAll();

    d3d9device->EndScene();
    d3d9device->Present(NULL, NULL, NULL, NULL);
}

void close()
{
    delete gDrawer;
    d3d9device->Release();
    d3d9->Release();
}