// ...
g_pD3DDevice->SetVertexShader(D3DFVF_D3DVertex);
// ...

c:\Documents and Settings\lee\Desktop\d3d\d3d.cpp(165) : error C2664: 'IDirect3DDevice9::SetVertexShader' : cannot convert parameter 1 from 'int' to 'IDirect3DVertexShader9 *'
        Conversion from integral type to pointer type requires reinterpret_cast, C-style cast or function-style cast

    g_pD3DDevice->SetVertexShader(reinterpret_cast<IDirect3DVertexShader9 *> (D3DFVF_D3DVertex));

Unhandled exception at 0x4fe5831f in d3d.exe: 0xC0000005: Access violation writing location 0x0000004e.

#define D3DFVF_D3DVertex (D3DFVF_XYZ | D3DFVF_DIFFUSE)

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <d3d9.h>

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
HRESULT Direct3DInit(HWND hWnd);
void Direct3DShutdown();
void Direct3DRender();

const char *lpszClassName = "D3D_App";
LPDIRECT3D9 g_pD3D = NULL;
LPDIRECT3DDEVICE9 g_pD3DDevice = NULL;

struct D3DVertex
{
    float x, y, z;
    DWORD color;
};

#define D3DFVF_D3DVertex (D3DFVF_XYZ | D3DFVF_DIFFUSE)

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASSEX wc;
    HWND hWnd;
    MSG mMsg;

    wc.cbClsExtra = 0;
    wc.cbSize = sizeof(wc);
    wc.cbWndExtra = 0;
    wc.hbrBackground = static_cast<HBRUSH> (GetStockObject(GRAY_BRUSH));
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
    wc.hInstance = hInstance;
    wc.lpfnWndProc = WndProc;
    wc.lpszClassName = lpszClassName;
    wc.lpszMenuName = NULL;
    wc.style = CS_VREDRAW | CS_HREDRAW;

    if (! RegisterClassEx(&wc))
    {
        MessageBox(0, "Error registering window class", "Error",
                   MB_OK | MB_ICONERROR);
        return 1;
    }

    hWnd = CreateWindowEx(NULL, lpszClassName, "Direct3D App", WS_OVERLAPPEDWINDOW, 0, 0, 300, 300, NULL,
                          NULL, hInstance, NULL);
    if (! hWnd)
    {
        MessageBox(0, "Error creating window", "Error",
                   MB_OK | MB_ICONERROR);
        return 1;
    }

    if (SUCCEEDED(Direct3DInit(hWnd)))
    {
        ShowWindow(hWnd, SW_SHOWNORMAL);
        UpdateWindow(hWnd);
        SetFocus(hWnd);

        ZeroMemory(&mMsg, sizeof(mMsg));
        while (mMsg.message != WM_QUIT)
        {
            if (PeekMessage(&mMsg, NULL, 0, 0, PM_REMOVE))
            {
                TranslateMessage(&mMsg);
                DispatchMessage(&mMsg);
            }
            else
                Direct3DRender();
        }
    }
    else
    {
        UnregisterClass(lpszClassName, hInstance);
        MessageBox(0, "Error initialising Direct3D", "Error", MB_OK | MB_ICONERROR);
        return 1;
    }

    Direct3DShutdown();
    UnregisterClass(lpszClassName, hInstance);
    return 0;
}

// WndProc
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_DESTROY:
        PostQuitMessage(0);
        break;

    case WM_PAINT:
        Direct3DRender();
        ValidateRect(hWnd, NULL);
        break;

    default:
        return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }

    return 0;
}

// Direct3DInit
//
HRESULT Direct3DInit(HWND hWnd)
{
    D3DDISPLAYMODE d3ddm;
    D3DPRESENT_PARAMETERS d3dpp;

    if ((g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)) == NULL)
        return E_FAIL;

    if (FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
        return E_FAIL;

    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.Windowed = true;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = d3ddm.Format;
    d3dpp.EnableAutoDepthStencil = true;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

    if (FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                    D3DCREATE_HARDWARE_VERTEXPROCESSING,
                                    &d3dpp, &g_pD3DDevice)))
    {
        return E_FAIL;
    }

    g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
    g_pD3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);

    return S_OK;
}

// Direct3DShutdown
//
void Direct3DShutdown()
{
    if (g_pD3DDevice != NULL)
        g_pD3DDevice->Release();

    if (g_pD3D != NULL)
        g_pD3D->Release();
}

// Direct3DRender
//
void Direct3DRender()
{
    LPDIRECT3DVERTEXBUFFER9 vBuffer;
    D3DVertex *pVertices;
    D3DVertex tri[3] = {
        {-0.5f, 0.0f, 0.0f, D3DCOLOR_XRGB(255, 0, 0)},
        {0.5f, 0.5f, 0.0f,  D3DCOLOR_XRGB(0, 255, 0)},
        {0.5f, -0.5f, 0.0f, D3DCOLOR_XRGB(0, 0, 255)}
    };

    if (g_pD3DDevice == NULL) return;

    g_pD3DDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
    if (FAILED(g_pD3DDevice->CreateVertexBuffer(3 * sizeof(D3DVertex), 0, 
                                                D3DFVF_D3DVertex, D3DPOOL_DEFAULT, &vBuffer, NULL)))
    {
        return;
    }

    if (FAILED(vBuffer->Lock(0, sizeof(D3DVertex) * 3, (void **) &pVertices, 0)))
        return;

    memcpy(pVertices, tri, sizeof(D3DVertex) * 3);
    vBuffer->Unlock();

    g_pD3DDevice->BeginScene();

    g_pD3DDevice->SetStreamSource(0, vBuffer, sizeof(D3DVertex), 0);
    g_pD3DDevice->SetFVF(D3DFVF_D3DVertex);
    g_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 1);
    vBuffer->Release();

    g_pD3DDevice->EndScene();


    g_pD3DDevice->Present(NULL, NULL, NULL, NULL);
}