// TileApp.cpp

#include <windows.h>
#include <d3d9.h>
#include <d3dx9tex.h>

// Constants.
const int COLUMNSINTILEFILE = 2;
const int TILESIZE = 32;
const int MAPCOLUMNCOUNT = 6;
const int XOFFSET = 220;
const int YOFFSET = 120;

// Function prototypes.
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
BOOL InitDirect3D();
void Render();
void CleanUpDirect3D();
void PlaceTile(IDirect3DSurface9* pBackBuffer, IDirect3DSurface9* pTileSurface,
         int TileNumber, int DstCol, int DstRow);
int ColumnRow2Sector(int c, int r);
int TileNumber2SourceX(int TileNumber);
int TileNumber2SourceY(int TileNumber);
int Column2X(int col);
int Row2Y(int r);

// Global variables.
HWND g_hWnd;
IDirect3D9* g_pDirect3D = NULL;
IDirect3DDevice9* g_pDirect3DDevice = NULL;
IDirect3DSurface9* g_pBitmapSurface = NULL;
HRESULT g_hResult = D3D_OK;
IDirect3DSurface9* g_pBackBuffer = NULL;
char g_Sectors[] =
    {0,0,0,0,0,0,
    0,2,2,2,2,0,
    0,2,1,1,2,0,
    0,2,1,1,2,0,
    0,2,0,2,2,0,
    0,0,0,0,0,3};

// WinMain()
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, INT)
{
  WNDCLASS wc = {CS_CLASSDC, WndProc, 0, 0, hInstance, NULL, NULL, NULL,
    NULL, "TileApp"};
    if (!RegisterClass(&wc)) return FALSE;
    g_hWnd = CreateWindow("TileApp", "Tile Application", WS_OVERLAPPEDWINDOW,
    100, 100, 648, 514, GetDesktopWindow(), NULL, hInstance, NULL);
  if (g_hWnd == NULL) return FALSE;
    if(InitDirect3D())
  {
      ShowWindow(g_hWnd, SW_SHOWDEFAULT);
    UpdateWindow(g_hWnd);
      MSG msg;
    ZeroMemory(&msg, sizeof(MSG));
      while(msg.message != WM_QUIT)
    {
      if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
          {
            TranslateMessage(&msg);
          DispatchMessage(&msg);
      }
          else
            Render();
    }
      CleanUpDirect3D();
    }
  UnregisterClass("TileApp", hInstance);
    return 0;
}

// WndProc()
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;
    case WM_PAINT:
        ValidateRect(g_hWnd, NULL);
        return 0;
    case WM_KEYDOWN:
        switch(wParam)
        {
            case VK_ESCAPE:
                PostQuitMessage(WM_QUIT);
                break;
        }
  default:
      return DefWindowProc(hWnd, msg, wParam, lParam);
    }
}

// InitDirect3D()
BOOL InitDirect3D()
{
    g_pDirect3D = Direct3DCreate9(D3D_SDK_VERSION);
    if (g_pDirect3D == NULL) return FALSE;
    HRESULT hResult = g_pDirect3D->CheckDeviceType(D3DADAPTER_DEFAULT,
    D3DDEVTYPE_HAL, D3DFMT_X8R8G8B8, D3DFMT_X8R8G8B8, TRUE);
    if (hResult != D3D_OK) return FALSE;
    D3DPRESENT_PARAMETERS D3DPresentParams;
    ZeroMemory(&D3DPresentParams, sizeof(D3DPRESENT_PARAMETERS));
    D3DPresentParams.Windowed = TRUE;
    D3DPresentParams.BackBufferCount = 1;
    D3DPresentParams.BackBufferWidth = 640;
    D3DPresentParams.BackBufferHeight = 480;
    D3DPresentParams.BackBufferFormat = D3DFMT_X8R8G8B8;
    D3DPresentParams.SwapEffect = D3DSWAPEFFECT_DISCARD;
    D3DPresentParams.hDeviceWindow = g_hWnd;
    hResult = g_pDirect3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
    g_hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &D3DPresentParams, &g_pDirect3DDevice);
    if (hResult != D3D_OK) return FALSE;
    g_hResult = g_pDirect3DDevice->CreateOffscreenPlainSurface(64, 64,
    D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &g_pBitmapSurface, NULL);
    if (hResult != D3D_OK) return FALSE;
    g_hResult = D3DXLoadSurfaceFromFile(g_pBitmapSurface, NULL, NULL,
    "image.bmp", NULL, D3DX_DEFAULT, 0, NULL);
    if (FAILED(g_hResult)) return FALSE;
    g_hResult = g_pDirect3DDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO,
    &g_pBackBuffer);
    if (FAILED(g_hResult)) return FALSE;
    return TRUE;
}

// CleanUpDirect3D()
void CleanUpDirect3D()
{
    if (g_pBackBuffer) g_pBackBuffer->Release();
    if (g_pBitmapSurface) g_pBitmapSurface->Release();
    if (g_pDirect3DDevice) g_pDirect3DDevice->Release();
    if (g_pDirect3D) g_pDirect3D->Release();
}

// Render()
void Render()
{
    g_pDirect3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0),
    1.0f, 0);
    for (int Row = 0; Row < MAPCOLUMNCOUNT; ++Row)
    {
        for (int Col = 0; Col < MAPCOLUMNCOUNT; ++Col)
        {
            int iSector = ColumnRow2Sector(Col, Row);
            int TileNumber = g_Sectors[iSector];
            PlaceTile(g_pBackBuffer, g_pBitmapSurface, TileNumber, Col, Row);
        }
    }
    g_pDirect3DDevice->Present(NULL, NULL, NULL, NULL);
}

// PlaceTile()
void PlaceTile(IDirect3DSurface9* pBackBuffer, IDirect3DSurface9* pTileSurface,
         int TileNumber, int DstCol, int DstRow)
{
    RECT SrcTileRect;
    POINT DstPoint;
    SrcTileRect.left = TileNumber2SourceX(TileNumber);
    SrcTileRect.right = SrcTileRect.left + TILESIZE;
    SrcTileRect.top = TileNumber2SourceY(TileNumber);
    SrcTileRect.bottom = SrcTileRect.top + TILESIZE;
    DstPoint.x = Column2X(DstCol) + XOFFSET;
    DstPoint.y = Row2Y(DstRow) + YOFFSET;
    HRESULT hResult = g_pDirect3DDevice->UpdateSurface(g_pBitmapSurface,
    &SrcTileRect, pBackBuffer, &DstPoint);
}

// ColumnRow2Sector()
int ColumnRow2Sector(int c, int r)
{
    return r * MAPCOLUMNCOUNT + c;
}

// TileNumber2SourceX()
int TileNumber2SourceX(int TileNumber)
{
    return (TileNumber - ((int)(TileNumber / COLUMNSINTILEFILE))
    * COLUMNSINTILEFILE) * TILESIZE;
}

// TileNumber2SourceY()
int TileNumber2SourceY(int TileNumber)
{
    return ((int)(TileNumber / COLUMNSINTILEFILE)) * TILESIZE;
}

// Column2X()
int Column2X(int col)
{
    return (col - ((int)((col / MAPCOLUMNCOUNT)) * MAPCOLUMNCOUNT)) * TILESIZE;
}

// Row2Y()
int Row2Y(int r)
{
    return r * TILESIZE;
}