Использование D3DXFont

#include "D3DUtility.h"

IDirect3DDevice9* device = NULL;

const int width = 640;
const int height = 480;

ID3DXFont* m_font  = NULL;
DWORD FrameCnt    = 0;
float TimeElapsed  = 0;
float fps      = 0;
wchar_t wcsFPS[9];

bool Setup()
{
  D3DXFONT_DESC lf;
  ZeroMemory(&lf, sizeof(lf));

  lf.Height      = 25;
  lf.Width      = 12;
  lf.Weight      = 500;
  lf.MipLevels    = D3DX_DEFAULT;
  lf.Italic      = false; 
  lf.CharSet      = 0;
  lf.Quality      = 0;           
  lf.PitchAndFamily  = 0; 
  wcscpy(lf.FaceName, L"Arial");

  if(FAILED
    (
      D3DXCreateFontIndirect(device, &lf, &m_font)
    ))
  {
    d3d::FailMsg(L"D3DXCreateFontIndirect()");
    PostQuitMessage(0);
  }

  return true;
}

void Cleanup()
{
  d3d::Release<ID3DXFont*>(m_font);
}

bool display(float timeDelta)
{
  if(device)
  {
    d3d::LogMsg(L"2");
    FrameCnt++;
    TimeElapsed += timeDelta;

    if(TimeElapsed >= 1.0f)
    {
        fps = (float)FrameCnt/TimeElapsed;

        swprintf(wcsFPS, L"%f\0", fps);
        wcsFPS[8] = L'\0';

        TimeElapsed = 0.0f;
        FrameCnt  = 0;
    }

    device->Clear(
          0, 0,
          D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
          0xffffffff, 1.0f, 0
        );

    device->BeginScene();

    RECT rect = {0, 0, width, height};
    m_font->DrawText(
        NULL,
        wcsFPS,
        -1,
        &rect,
        DT_TOP | DT_LEFT,
        0xff000000
      );


    device->EndScene();
    device->Present(0, 0, 0, 0);
  }

  return true;
}

//
// WndProc
//
LRESULT CALLBACK d3d::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
  switch( msg )
  {
  case WM_DESTROY:
    ::PostQuitMessage(0);
    break;
    
  case WM_KEYDOWN:
    if( wParam == VK_ESCAPE )
      ::DestroyWindow(hwnd);
    break;
  }
  return ::DefWindowProc(hwnd, msg, wParam, lParam);
}

//
// WinMain
//
int WINAPI WinMain(HINSTANCE hinstance,
           HINSTANCE prevInstance, 
           PSTR cmdLine,
           int showCmd)
{
  if(!d3d::InitD3D(hinstance,
    width, height, true, D3DDEVTYPE_HAL, &device))
  {
    d3d::FailMsg(L"InitD3D()");
    return 0;
  }
    
  if(!Setup())
  {
    d3d::FailMsg(L"Setup() - FAILED");
    return 0;
  }

  d3d::EnterMsgLoop( display );

  Cleanup();

  device->Release();

  return 0;
}

#include "D3DUtility.h"

void d3d::FailMsg(wchar_t *error)
{
    //wcscat(L" - FAILED", error);
    std::wstring err(error);
    err += L" - FAILED";
    //MessageBox(NULL, error, L"Error", MB_OK);
    MessageBox(NULL, err.c_str(), L"Error", MB_OK);
}

void d3d::LogMsg(wchar_t *log)
{
  MessageBox(NULL, log, L"Log Message", MB_OK);
}
 
bool d3d::InitD3D(
        HINSTANCE hInstance,
        int width, int height,
        bool windowed,
        D3DDEVTYPE deviceType,
        IDirect3DDevice9** device)
{
    WNDCLASSEX wc;
  ZeroMemory(&wc, sizeof(wc));
 
    wc.cbSize           = sizeof(WNDCLASSEX);
    wc.style            = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc      = (WNDPROC)d3d::WndProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = hInstance;
    wc.hIcon            = LoadIcon(NULL, IDI_APPLICATION);
    wc.hCursor          = LoadCursor(NULL, IDC_ARROW);
    wc.hbrBackground    = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName     = 0;
    wc.lpszClassName    = L"Direct3D9App";
 
    if(!RegisterClassEx(&wc))
    {
        d3d::FailMsg(L"RegisterClass()");
        return false;
    }
 
    HWND hWnd = NULL;
 
    hWnd = CreateWindow(
            L"Direct3D9App",
            L"Direct3D9App",
            WS_EX_TOPMOST,
            CW_USEDEFAULT, CW_USEDEFAULT,
            width, height,
            NULL,NULL,
            hInstance, NULL
        );
 
    if(!hWnd)
    {
        d3d::FailMsg(L"CreateWindow");
        return false;
    }
 
    ShowWindow(hWnd, SW_SHOW);
    UpdateWindow(hWnd);
 
    HRESULT hr = 0;
 
    IDirect3D9* pd3d = 0;
    pd3d = Direct3DCreate9(D3D_SDK_VERSION);
 
    if(!pd3d)
    {
        d3d::FailMsg(L"Direct3Dcreate9()");
        return false;
    }
 
    D3DCAPS9 caps;
    pd3d->GetDeviceCaps(D3DADAPTER_DEFAULT, deviceType, &caps);
 
    int vp = 0;
 
    if(caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
        vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
    else
        vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
 
    D3DPRESENT_PARAMETERS d3dpp;
    D3DDISPLAYMODE d3ddm;
 
    pd3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm);

 
    d3dpp.BackBufferWidth           = width;
    d3dpp.BackBufferHeight          = height;
    d3dpp.BackBufferFormat          = d3ddm.Format;
    d3dpp.BackBufferCount           = 1;
    d3dpp.MultiSampleType           = D3DMULTISAMPLE_NONE;
    d3dpp.MultiSampleQuality        = 0;
    d3dpp.SwapEffect                = D3DSWAPEFFECT_DISCARD;
    d3dpp.hDeviceWindow             = hWnd;
    d3dpp.Windowed                  = windowed;
    d3dpp.EnableAutoDepthStencil    = true;
    d3dpp.AutoDepthStencilFormat    = D3DFMT_D24S8;
    d3dpp.Flags                     = 0;
    d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
    d3dpp.PresentationInterval      = D3DPRESENT_INTERVAL_IMMEDIATE;
  
 
    hr = pd3d->CreateDevice(
            D3DADAPTER_DEFAULT,
            deviceType,
            hWnd,
            vp,
            &d3dpp,
            device
        );
 
    if(FAILED(hr))
    {
        pd3d->Release();
        d3d::FailMsg(L"CreateDevice()");
        return false;
    }
 
    pd3d->Release();
 
    return true;
}
 
int d3d::EnterMsgLoop(
            bool (*ptr_display)(float timeDelta)
        )
{
    MSG msg;
    ZeroMemory(&msg, sizeof(MSG));
 
    static float lastTime = (float)timeGetTime();
 
    while(msg.message != WM_QUIT)
    {
        if(PeekMessage(&msg, 0, 0, 0,PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {
            float currTime  = (float)timeGetTime();
            float timeDelta = (currTime - lastTime)*0.001f;
 
            ptr_display(timeDelta);
 
            lastTime = currTime;
        }
    }
 
    return msg.wParam;
}
 
 
D3DLIGHT9 d3d::InitDirectionalLight(
            D3DXVECTOR3* direction,
            D3DXCOLOR* color
        )
{
    D3DLIGHT9 light;
    ZeroMemory(&light, sizeof(light));
 
    light.Type      = D3DLIGHT_DIRECTIONAL;
    light.Ambient   = *color * 0.6f;
    light.Diffuse   = *color;
    light.Specular  = *color * 0.6f;
    light.Direction = *direction;
 
    return light;
}
 
D3DLIGHT9 d3dInitPointLight(
            D3DXVECTOR3* position,
            D3DXCOLOR* color
        )
{
    D3DLIGHT9 light;
    ZeroMemory(&light, sizeof(light));
 
    light.Type          = D3DLIGHT_POINT;
    light.Ambient       = *color * 0.6f;
    light.Diffuse       = *color;
    light.Specular      = *color * 0.6f;
    light.Position      = *position;
    light.Range         = 1000.0f;
    light.Falloff       = 1.0f;
    light.Attenuation0  = 1.0f;
    light.Attenuation1  = 0.0f;
    light.Attenuation2  = 0.0f;
 
    return light;
}
 
D3DLIGHT9 d3dInitSpotLight(
            D3DXVECTOR3* position,
            D3DXVECTOR3* direction,
            D3DXCOLOR* color
        )
{
    D3DLIGHT9 light;
    ZeroMemory(&light, sizeof(light));
 
    light.Type          = D3DLIGHT_SPOT;
    light.Ambient       = *color * 0.0f;
    light.Diffuse       = *color;
    light.Specular      = *color * 0.6f;
    light.Position      = *position;
    light.Direction     = *direction;
    light.Range         = 1000.0f;
    light.Falloff       = 1.0f;
    light.Attenuation0  = 1.0f;
    light.Attenuation1  = 0.0f;
    light.Attenuation2  = 0.0f;
    light.Theta         = 0.4f;
    light.Phi           = 0.9f;
 
    return light;
}
 
D3DMATERIAL9 d3d::InitMtrl(
            D3DXCOLOR ambient,
            D3DXCOLOR diffuse,
            D3DXCOLOR specular,
            D3DXCOLOR emissive,
            float power
        )
{
    D3DMATERIAL9 mtrl;
    mtrl.Ambient    = ambient;
    mtrl.Diffuse    = diffuse;
    mtrl.Specular   = specular;
    mtrl.Emissive   = emissive;
    mtrl.Power      = power;
 
    return mtrl;
}