DX shader根据顶点设置颜色

matrix ViewProjMatrix;
vector Blue = {0.0f, 0.0f, 1.0f, 0.0f};

struct VS_INPUT
{
    vector position : POSITION;
};

struct VS_OUTPUT
{
    vector position : POSITION;
    vector diffuse : COLOR;
};

VS_OUTPUT Main(VS_INPUT input)
{
    VS_OUTPUT output = (VS_OUTPUT);
    output.position = mul(input.position, ViewProjMatrix);
    output.diffuse = output.position;
    return output;
}

#ifndef QD3DWIDGET_H
#define QD3DWIDGET_H

#include <QtGui/QtGui>
#include <d3d9.h>
#include <d3dx9.h>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
extern LPDIRECT3D9 g_pD3D;
extern LPDIRECT3DDEVICE9 g_pDevice;
extern LPDIRECT3DVERTEXBUFFER9 g_pVertexBuffer;
extern LPDIRECT3DINDEXBUFFER9 g_pIndexBuffer;
HRESULT Init3D(HWND hWnd);

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

#define D3DFVF_CUSTOMVERTEXT (D3DFVF_XYZ|D3DFVF_DIFFUSE)

class QD3DWidget : public QWidget
{
    Q_OBJECT

public:
    QD3DWidget(QWidget *parent = NULL);
    ~QD3DWidget();
    QPaintEngine *paintEngine()const;
protected:
    void paintEvent(QPaintEvent *ev);
    virtual void initialize3D();
    virtual bool initGemetry();
private:
    void setupMatrices();
private:
    int fRotateY;
};

#endif // QD3DWIDGET_H

#include "MyFrame.h"
#include <iostream>
LPDIRECT3D9 g_pD3D = NULL;
LPDIRECT3DDEVICE9 g_pDevice = NULL;
LPDIRECT3DVERTEXBUFFER9 g_pVertexBuffer = NULL;
LPDIRECT3DINDEXBUFFER9 g_pIndexBuffeer = NULL;
LPD3DXMESH g_teapot = NULL;
IDirect3DVertexShader9 * g_pVertexShader = NULL;
ID3DXConstantTable * g_pConstantTable = NULL;
D3DXHANDLE ViewProjMatrixHandle = ;

bool PrepareShader()
{
    ID3DXBuffer * shader;
    ID3DXBuffer * errorBuffer;

    HRESULT hr = D3DXCompileShaderFromFileA("my.fx", , , "Main", "vs_1_1",
            D3DXSHADER_ENABLE_BACKWARDS_COMPATIBILITY, &shader, &errorBuffer, &g_pConstantTable
        );

    if (errorBuffer)
    {
        std::cout << errorBuffer->GetBufferPointer() << std::endl;
        errorBuffer->Release();
    }

    if (FAILED(hr))
    {
        std::cout << "CompileShader FAILED" << std::endl;
        exit(-);
    }

    hr = g_pDevice->CreateVertexShader((DWORD *)shader->GetBufferPointer(), &g_pVertexShader);
    if (FAILED(hr))
    {
        std::cout << "Create Shader FAILED" << std::endl;
    }
    shader->Release();
    ViewProjMatrixHandle = g_pConstantTable->GetConstantByName(, "ViewProjMatrix");
}
HRESULT Init3D(HWND hWnd)
{
    if(NULL ==(g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
        return E_FAIL;

    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory(&d3dpp , sizeof(d3dpp));
    d3dpp.Windowed = true;
    d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
    d3dpp.EnableAutoDepthStencil = TRUE;
    d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

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

    g_pDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE);

    g_pDevice->SetRenderState(D3DRS_LIGHTING,FALSE);
    g_pDevice->SetRenderState(D3DRS_ANTIALIASEDLINEENABLE,TRUE);
    g_pDevice->SetRenderState(D3DRS_ZENABLE,D3DZB_TRUE);
    return S_OK;
}

QD3DWidget::QD3DWidget(QWidget *parent)
    : QWidget(parent)
    , fRotateY()
{

    setAttribute(Qt::WA_PaintOnScreen , true);
    setGeometry(, , , );
    initialize3D();
}

QD3DWidget::~QD3DWidget()
{

    g_pDevice->Release();
    g_pD3D->Release();
}

QPaintEngine * QD3DWidget::paintEngine()const
{
    return NULL;
}

void QD3DWidget::initialize3D()
{
    Init3D(winId());
    initGemetry();
    D3DXCreateTeapot(g_pDevice, &g_teapot, NULL);
    PrepareShader();
}

void QD3DWidget::paintEvent(QPaintEvent *ev)
{

    g_pDevice->Clear(,NULL,D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,D3DCOLOR_XRGB(,,),1.0f,);
    setupMatrices();
    g_pDevice->BeginScene();
    g_pDevice->SetVertexShader(g_pVertexShader);
    g_teapot->DrawSubset();
    g_pDevice->EndScene();
    g_pDevice->Present(NULL,NULL,NULL,NULL);

    update();

}

bool QD3DWidget::initGemetry()
{

  return true;
}

void QD3DWidget::setupMatrices()
{
   static float angle = 0.0f;

   D3DXMATRIX worldMatrix;
   D3DXMatrixRotationY(&worldMatrix, angle);
   g_pDevice->SetTransform(D3DTS_WORLD, &worldMatrix);
   angle += 0.1f;

   D3DXMATRIX viewMatrix;
   D3DXVECTOR3 eye(0.0f, 0.0f, -5.0f);
   D3DXVECTOR3 center(0.0f, 0.0f, 0.0f);
   D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
   D3DXMatrixLookAtLH(&viewMatrix, &eye, &center, &up);
   g_pDevice->SetTransform(D3DTS_VIEW, &viewMatrix);

   D3DXMATRIX projMatrix;
   D3DXMatrixPerspectiveFovLH(&projMatrix, D3DX_PI/4.0f, (float)width()/(float)height(), 1.0f, 1000.0f);
   g_pDevice->SetTransform(D3DTS_PROJECTION, &projMatrix);

   D3DXMATRIX viewproj = worldMatrix * viewMatrix * projMatrix;
   g_pConstantTable->SetMatrix(g_pDevice, ViewProjMatrixHandle, &viewproj);
   g_pConstantTable->SetDefaults(g_pDevice);
}