DirectX9 照明 C++照明不工作

Question

这是一个简单的程序，可以绘制带有纹理的 3D 立方体。问题是我看不到纹理，因为灯不工作。我关掉灯只是为了确保纹理存在并且它确实存在。所以如果有人可以帮助我弄清楚为什么灯不工作我将不胜感激。

#include "DirectXGame.h"

DirectXGame::DirectXGame(void)
{
    //init to zero good pratice

    m_pD3DObject=0;
    m_pD3DDevice=0;
    m_currTime=0;
    m_prevTime=0;

    ZeroMemory(&m_D3Dpp,sizeof(m_D3Dpp));
    FOV=D3DXToRadian(65.0f);
    aspectRatio=800/600;
    nearPlane=1.0f;
    farPlane=1000.0f;
}

DirectXGame::~DirectXGame(void)
{
}

//create class for input
DirectXInput DXClass;
void DirectXGame::Initialize(HWND hWnd ,HINSTANCE hInst,bool bWindowed) // create the material struct)//
{
    // grab the window width and height fronm the HWND
    RECT r;
    GetWindowRect(hWnd, &r);
    m_nWidth = r.right - r.left;
    m_nHeight = r.bottom - r.top;
    m_bVSync = false;

    // Create the D3D Object
    m_pD3DObject = Direct3DCreate9(D3D_SDK_VERSION);

    // Create our presentation parameters for our D3D Device
    m_D3Dpp.hDeviceWindow = hWnd; // Handle to the window
    m_D3Dpp.Windowed = bWindowed; // Windowed or Full-screen?
    m_D3Dpp.BackBufferCount = 1; // Number of back-buffers
    m_D3Dpp.BackBufferFormat = D3DFMT_X8R8G8B8; // Back-buffer pixel format
    m_D3Dpp.BackBufferWidth = m_nWidth; // Back-buffer width
    m_D3Dpp.BackBufferHeight = m_nHeight; // Back-buffer height
    m_D3Dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; // Swap effectm_bVSync ? D3DPRESENT_INTERVAL_DEFAULT :
    m_D3Dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
    m_D3Dpp.FullScreen_RefreshRateInHz = bWindowed ? 0 : D3DPRESENT_RATE_DEFAULT;
    m_D3Dpp.EnableAutoDepthStencil = TRUE; // Enable depth and stencil buffer
    m_D3Dpp.AutoDepthStencilFormat = D3DFMT_D24S8; // Depth/Stencil buffer bit format
    m_D3Dpp.Flags = D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL; // Discard the depth/stencil buffer upon Present()
    m_D3Dpp.MultiSampleQuality = 0; // MSAA quality
    m_D3Dpp.MultiSampleType = D3DMULTISAMPLE_NONE; // MSAA type

    // Check the device's capabilities
    DWORD deviceBehaviorFlags = 0;
    m_pD3DObject->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &m_D3DCaps);

    // Determine vertex processing mode
    if(m_D3DCaps.DevCaps & D3DCREATE_HARDWARE_VERTEXPROCESSING)
    {
        deviceBehaviorFlags |= D3DCREATE_HARDWARE_VERTEXPROCESSING;
    }
    else
    {
        deviceBehaviorFlags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING;
    }

    // if hardware vertex processing is on, check for pure
    if(m_D3DCaps.DevCaps & D3DCREATE_PUREDEVICE && deviceBehaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING)
    {
        deviceBehaviorFlags |= D3DCREATE_PUREDEVICE;
    }

    // Create D3D Device
    m_pD3DObject->CreateDevice(
        D3DADAPTER_DEFAULT, // Default display adapter
        D3DDEVTYPE_HAL, // Device type to use
        hWnd, // Handle to our window
        deviceBehaviorFlags, // D3DCREATE_HARDWARE_VERTEXPROCESSINGVertex Processing Behavior Flags (PUREDEVICE, HARDWARE_VERTEXPROCESSING, SOFTWARE_VERTEXPROCESSING)
        &m_D3Dpp, // Presentation parameters
        &m_pD3DDevice); // Return a created D3D Device

    //=================================================================//
    // Create/Load Sprite & Font D3D and COM objects

    //Create font
    D3DXCreateFont(m_pD3DDevice, 23, 0, FW_BOLD, 0, true,
        DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, DEFAULT_QUALITY,
        DEFAULT_PITCH | FF_DONTCARE, TEXT("Times New Roman"),
        &m_pD3DFont);

    //for font 1 "Name"
    RECT rct;
    rct.left=2;
    rct.right=780;
    rct.top=10;
    rct.bottom=rct.top+20;

    //MATRIX
    eyePos.x = 0;
    eyePos.y = 2;
    eyePos.z = -10;
    lookAt.x = 0;
    lookAt.y = 0;
    lookAt.z = 0;
    upVec.x = 0;
    upVec.y = 1;
    upVec.z = 0;

    D3DXMatrixLookAtLH( &view_Matrix, &eyePos, &lookAt, &upVec);

    m_pD3DDevice->SetTransform( D3DTS_VIEW, &view_Matrix);

    // projection matrix
    D3DXMatrixPerspectiveFovLH( &pro_Matrix, FOV, aspectRatio, nearPlane, farPlane);
    m_pD3DDevice->SetTransform( D3DTS_PROJECTION, &pro_Matrix);

    // MATRIX: VertexElement Declaration
    D3DVERTEXELEMENT9 declaration[] =
    {
        {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
        {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0},
        {0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
        D3DDECL_END()
    };

    //LPDIRECT3DVERTEXDECLARATION9 m_pVtxDeclObject;
    // Create vertex declaration
    m_pD3DDevice->CreateVertexDeclaration(declaration,&vertDec);

    ///---CUBE: Vertex and Indicies :START---///
    // Load vertex info, listed per cube face quads
    // Front
    m_cubeVerts[0].position = D3DXVECTOR3(-1.0f, -1.0f, -1.0f);
    m_cubeVerts[1].position = D3DXVECTOR3(-1.0f, 1.0f, -1.0f);
    m_cubeVerts[2].position = D3DXVECTOR3(1.0f, 1.0f, -1.0f);
    m_cubeVerts[3].position = D3DXVECTOR3(1.0f, -1.0f, -1.0f);
    D3DXVec3Normalize(&m_cubeVerts[0].normal, &D3DXVECTOR3(0.0f, 0.0f, -1.0f));
    D3DXVec3Normalize(&m_cubeVerts[1].normal, &D3DXVECTOR3(0.0f, 0.0f, -1.0f));
    D3DXVec3Normalize(&m_cubeVerts[2].normal, &D3DXVECTOR3(0.0f, 0.0f, -1.0f));
    D3DXVec3Normalize(&m_cubeVerts[3].normal, &D3DXVECTOR3(0.0f, 0.0f, -1.0f));
    m_cubeVerts[0].uv = D3DXVECTOR2(0.0f, 1.0f);
    m_cubeVerts[1].uv = D3DXVECTOR2(0.0f, 0.0f);
    m_cubeVerts[2].uv = D3DXVECTOR2(1.0f, 0.0f);
    m_cubeVerts[3].uv = D3DXVECTOR2(1.0f, 1.0f);

    // Back
    m_cubeVerts[4].position = D3DXVECTOR3(-1.0f, -1.0f, 1.0f);
    m_cubeVerts[5].position = D3DXVECTOR3(1.0f, -1.0f, 1.0f);
    m_cubeVerts[6].position = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
    m_cubeVerts[7].position = D3DXVECTOR3(-1.0f, 1.0f, 1.0f);
    D3DXVec3Normalize(&m_cubeVerts[4].normal, &D3DXVECTOR3(0.0f, 0.0f, 1.0f));
    D3DXVec3Normalize(&m_cubeVerts[5].normal, &D3DXVECTOR3(0.0f, 0.0f, 1.0f));
    D3DXVec3Normalize(&m_cubeVerts[6].normal, &D3DXVECTOR3(0.0f, 0.0f, 1.0f));
    D3DXVec3Normalize(&m_cubeVerts[7].normal, &D3DXVECTOR3(0.0f, 0.0f, 1.0f));
    m_cubeVerts[4].uv = D3DXVECTOR2(1.0f, 1.0f);
    m_cubeVerts[5].uv = D3DXVECTOR2(0.0f, 1.0f);
    m_cubeVerts[6].uv = D3DXVECTOR2(0.0f, 0.0f);
    m_cubeVerts[7].uv = D3DXVECTOR2(1.0f, 0.0f);

    // Top
    m_cubeVerts[8].position = D3DXVECTOR3(-1.0f, 1.0f, -1.0f);
    m_cubeVerts[9].position = D3DXVECTOR3(-1.0f, 1.0f, 1.0f);
    m_cubeVerts[10].position = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
    m_cubeVerts[11].position = D3DXVECTOR3(1.0f, 1.0f, -1.0f);
    D3DXVec3Normalize(&m_cubeVerts[8].normal, &D3DXVECTOR3(0.0f, 1.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[9].normal, &D3DXVECTOR3(0.0f, 1.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[10].normal, &D3DXVECTOR3(0.0f, 1.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[11].normal, &D3DXVECTOR3(0.0f, 1.0f, 0.0f));
    m_cubeVerts[8].uv = D3DXVECTOR2(0.0f, 1.0f);
    m_cubeVerts[9].uv = D3DXVECTOR2(0.0f, 0.0f);
    m_cubeVerts[10].uv = D3DXVECTOR2(1.0f, 0.0f);
    m_cubeVerts[11].uv = D3DXVECTOR2(1.0f, 1.0f);

    // Bottom
    m_cubeVerts[12].position = D3DXVECTOR3(-1.0f, -1.0f, -1.0f);
    m_cubeVerts[13].position = D3DXVECTOR3(1.0f, -1.0f, -1.0f);
    m_cubeVerts[14].position = D3DXVECTOR3(1.0f, -1.0f, 1.0f);
    m_cubeVerts[15].position = D3DXVECTOR3(-1.0f, -1.0f, 1.0f);
    D3DXVec3Normalize(&m_cubeVerts[12].normal, &D3DXVECTOR3(0.0f, -1.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[13].normal, &D3DXVECTOR3(0.0f, -1.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[14].normal, &D3DXVECTOR3(0.0f, -1.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[15].normal, &D3DXVECTOR3(0.0f, -1.0f, 0.0f));
    m_cubeVerts[12].uv = D3DXVECTOR2(1.0f, 1.0f);
    m_cubeVerts[13].uv = D3DXVECTOR2(0.0f, 1.0f);
    m_cubeVerts[14].uv = D3DXVECTOR2(0.0f, 0.0f);
    m_cubeVerts[15].uv = D3DXVECTOR2(1.0f, 0.0f);

    // Left
    m_cubeVerts[16].position = D3DXVECTOR3(-1.0f, -1.0f, 1.0f);
    m_cubeVerts[17].position = D3DXVECTOR3(-1.0f, 1.0f, 1.0f);
    m_cubeVerts[18].position = D3DXVECTOR3(-1.0f, 1.0f, -1.0f);
    m_cubeVerts[19].position = D3DXVECTOR3(-1.0f, -1.0f, -1.0f);
    D3DXVec3Normalize(&m_cubeVerts[16].normal, &D3DXVECTOR3(-1.0f, 0.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[17].normal, &D3DXVECTOR3(-1.0f, 0.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[18].normal, &D3DXVECTOR3(-1.0f, 0.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[19].normal, &D3DXVECTOR3(-1.0f, 0.0f, 0.0f));
    m_cubeVerts[16].uv = D3DXVECTOR2(0.0f, 1.0f);
    m_cubeVerts[17].uv = D3DXVECTOR2(0.0f, 0.0f);
    m_cubeVerts[18].uv = D3DXVECTOR2(1.0f, 0.0f);
    m_cubeVerts[19].uv = D3DXVECTOR2(1.0f, 1.0f);

    // Right
    m_cubeVerts[20].position = D3DXVECTOR3(1.0f, -1.0f, -1.0f);
    m_cubeVerts[21].position = D3DXVECTOR3(1.0f, 1.0f, -1.0f);
    m_cubeVerts[22].position = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
    m_cubeVerts[23].position = D3DXVECTOR3(1.0f, -1.0f, 1.0f);
    D3DXVec3Normalize(&m_cubeVerts[20].normal, &D3DXVECTOR3(1.0f, 0.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[21].normal, &D3DXVECTOR3(1.0f, 0.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[22].normal, &D3DXVECTOR3(1.0f, 0.0f, 0.0f));
    D3DXVec3Normalize(&m_cubeVerts[23].normal, &D3DXVECTOR3(1.0f, 0.0f, 0.0f));
    m_cubeVerts[20].uv = D3DXVECTOR2(0.0f, 1.0f);
    m_cubeVerts[21].uv = D3DXVECTOR2(0.0f, 0.0f);
    m_cubeVerts[22].uv = D3DXVECTOR2(1.0f, 0.0f);
    m_cubeVerts[23].uv = D3DXVECTOR2(1.0f, 1.0f);

    // Load index info, refers into index into verts array to compose triangles
    // Note: A clockwise winding order of verts will show the front face.

    // Front
    m_cubeIndices[0] = 0; m_cubeIndices[1] = 1; m_cubeIndices[2] = 2; // Triangle 0
    m_cubeIndices[3] = 0; m_cubeIndices[4] = 2; m_cubeIndices[5] = 3; // Triangle 1

    // Back
    m_cubeIndices[6] = 4; m_cubeIndices[7] = 5; m_cubeIndices[8] = 6; // Triangle 2
    m_cubeIndices[9] = 4; m_cubeIndices[10] = 6; m_cubeIndices[11] = 7; // Triangle 3

    // Top
    m_cubeIndices[12] = 8; m_cubeIndices[13] = 9; m_cubeIndices[14] = 10; // Triangle 4
    m_cubeIndices[15] = 8; m_cubeIndices[16] = 10; m_cubeIndices[17] = 11; // Triangle 5

    // Bottom
    m_cubeIndices[18] = 12; m_cubeIndices[19] = 13; m_cubeIndices[20] = 14; // Triangle 6
    m_cubeIndices[21] = 12; m_cubeIndices[22] = 14; m_cubeIndices[23] = 15; // Triangle 7

    // Left
    m_cubeIndices[24] = 16; m_cubeIndices[25] = 17; m_cubeIndices[26] = 18; // Triangle 8
    m_cubeIndices[27] = 16; m_cubeIndices[28] = 18; m_cubeIndices[29] = 19; // Triangle 9

    // Right
    m_cubeIndices[30] = 20; m_cubeIndices[31] = 21; m_cubeIndices[32] = 22; // Triangle 10
    m_cubeIndices[33] = 20; m_cubeIndices[34] = 22; m_cubeIndices[35] = 23; // Triangle 11
    ///---CUBE: Vertex and Indicies :END---///

    //create buffers
    // create a vertex buffer interface called i_buffer
    m_pD3DDevice->CreateVertexBuffer(4*6*sizeof(Vertex),
        D3DUSAGE_WRITEONLY,
        0,
        D3DPOOL_MANAGED,
        &VB,
        NULL);

    void* pVertices;
    // lock VB and load the vertices into it
    VB->Lock(0, 0,&pVertices, 0);

    // send array
    memcpy(pVertices, m_cubeVerts, 4*6*sizeof(Vertex));

    //unlock
    VB->Unlock();

    ///////////////////////////////////////////////////

    m_pD3DDevice->CreateIndexBuffer(3*12*sizeof(WORD), // 3 and 12
        D3DUSAGE_WRITEONLY,
        D3DFMT_INDEX16,
        D3DPOOL_MANAGED,
        &IB,
        NULL);

    void* pIndices;
    // lock index
    IB->Lock(0,0,&pIndices,0);
    //send array of indices to vram
    memcpy(pIndices, m_cubeIndices, 3*12*sizeof(WORD));

    //unlock index
    IB->Unlock();

    D3DLIGHT9 light;
    D3DMATERIAL9 m_Mat;

    ZeroMemory(&light, sizeof(light));
    // clear out the light struct for use
    light.Type = D3DLIGHT_POINT;
    // make the light type 'directional light'
    light.Diffuse.r = 0.5f;
    light.Diffuse.g = 0.5f;
    light.Diffuse.b = 0.5f;
    light.Diffuse.a = 1.0f;
    light.Ambient.r = 0.2f;
    light.Ambient.g = 0.2f;
    light.Ambient.b = 1.0f;
    light.Specular.r = 1.0f;
    light.Specular.g = 1.0f;
    light.Specular.b = 1.0f;
    // set the lighting position
    light.Position.x = 30;
    light.Position.y = 10;
    light.Position.z = -10;
    light.Range = 900.0f;
    light.Attenuation0 = 0.0f;
    light.Attenuation1 = 0.125f;
    light.Attenuation2 = 0.0f;
    m_pD3DDevice->SetLight(0, &light);
    // send the light struct properties to light #0
    m_pD3DDevice->LightEnable(0, TRUE);
    // turn on light #0
    ZeroMemory(&m_Mat, sizeof(m_Mat));
    // clear out the struct for use
    m_Mat.Diffuse.r = 1.0f;
    m_Mat.Diffuse.g = 0.0f;
    m_Mat.Diffuse.b = 0.0f;
    m_Mat.Diffuse.a = 0.0f;
    // set diffuse color to white
    m_Mat.Ambient.r = 0.2f;
    m_Mat.Ambient.g = 0.2f;
    m_Mat.Ambient.b = 0.2f;
    m_Mat.Ambient.a = 1.0f;
    // set ambient color to white
    m_Mat.Specular.r = 1.0f;
    m_Mat.Specular.g =1.0f;
    m_Mat.Specular.b =1.0f;
    m_Mat.Specular.a =1.0f;
    m_Mat.Power = 100.0f;

    m_pD3DDevice->SetMaterial(&m_Mat);

    // Create a texture using the with "test.tga" from the sprite labs.
    //Apply tri-linear filtering to the texture, by modifying the sampler states by calling the device's SetSamplerState().
    D3DXCreateTextureFromFile(m_pD3DDevice, L"test.png",&m_Texture);

    //Apply tri-linear filtering to the texture, by modifying the sampler states by calling the device's SetSamplerState().

    m_pD3DDevice->SetSamplerState( 0,D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
    m_pD3DDevice->SetSamplerState( 0,D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
    m_pD3DDevice->SetSamplerState( 0,D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
}

void DirectXGame::Update(HWND hWnd, bool& bWindowed, double dt)
{
}

void DirectXGame::Render()
{
    // if our d3d device was not craeted return
    if(!m_pD3DDevice)
        return;

    m_pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
    D3DCOLOR_XRGB(100,149,237), 1, 0); // 100,149,237 00255

    // Begin the scene
    if( SUCCEEDED( m_pD3DDevice->BeginScene() ) )
    {
        m_pD3DDevice->SetVertexDeclaration( vertDec);

        //set cube postion
        D3DXMATRIX translation, rotation, scale, world, position;
        float index = 0.0f; index+=0.05f;
        D3DXMatrixTranslation(&translation,0,0,0);
        D3DXMatrixRotationY(&rotation, timeGetTime()/1000);
        D3DXMatrixScaling(&scale,1,1, 1.0f);

        world = scale*rotation*translation;

        m_pD3DDevice->SetTransform(D3DTS_WORLD, &world);

        // select the vertex and index buffers to use
        m_pD3DDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
        m_pD3DDevice->SetRenderState( D3DRS_SPECULARENABLE, TRUE );
        m_pD3DDevice->SetRenderState( D3DRS_AMBIENT, D3DCOLOR_XRGB(60,60,60));
        m_pD3DDevice->SetStreamSource(0, VB, 0, sizeof(Vertex));
        m_pD3DDevice->SetIndices(IB);
        m_pD3DDevice->SetMaterial(&m_Mat);
        m_pD3DDevice->SetTexture( 0,m_Texture);

        m_pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,//D3DPRIMITIVETYPE Type
            0,/*BaseVertexIndex*/
            0, //* MinIndex*/
            24, /*NumVertices*/
            0, /*StartIndex*/
            12);//PrimitiveCount

        ///////////////////////////////////////////////////////////////////////////

        //Font 1 "Name"
        RECT rct;
        rct.bottom = m_nHeight;
        rct.top=2;
        rct.left=658;
        rct.right=m_nWidth;

        //for the font2 FPS
        RECT rect;
        rect.bottom = m_nHeight;
        rect.top =2;
        rect.left = 10;
        rect.right = m_nWidth;

        wchar_t buffer[64];
        swprintf_s(buffer, 64,L"Frames Per Second: %d", m_FPS);
        m_pD3DFont->DrawText(0, buffer, -1, &rect, DT_TOP | DT_NOCLIP, D3DCOLOR_ARGB(255,255,255,255));

        // Create a colour for the text ( blue)
        D3DCOLOR fontColor = D3DCOLOR_ARGB(255,0,0,255);

        //draw the text
        m_pD3DFont->DrawText(NULL, L"Mariana Serrato", -1, &rct, 0, fontColor ); // move test to far right

        // End the scene
        m_pD3DDevice->EndScene();

        // present the back buffer to the screen
        m_pD3DDevice->Present(NULL, NULL, NULL, NULL);

        //calculate Frames Per Second
        m_currTime = timeGetTime();
        static int fspCounter = 0;
        if(m_currTime - m_prevTime >= 1000.0f)
        {
            m_prevTime = m_currTime;
            m_FPS = fspCounter;
            fspCounter =0;
        } else {
            ++fspCounter;
        }
    }
}

void DirectXGame::Shutdown()
{
    SAFE_RELEASE(VB);
    SAFE_RELEASE(IB);
    SAFE_RELEASE(vertDec);
    SAFE_RELEASE(m_pD3DFont);
    SAFE_RELEASE(m_Texture);
    SAFE_RELEASE(m_Sprite);
    SAFE_RELEASE(m_pD3DDevice);
    SAFE_RELEASE(m_pD3DObject);
}

/////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////// .h 头文件

pragma 一次

include // 对于随机数字

include

include

include

include

include

"DirectXInput.h"

include

include

pragma comment (lib, "d3d9.lib")

pragma comment (lib, "d3dx9.lib")

pragma comment( lib, "winmm.lib")//for timeGetTime()

pragma comment(lib, "dinput8.lib")

pragma comment(lib, "dxguid.lib")

// 安全释放 com 对象的宏

Define SAFE_RELEASE(x) if (x) {x->Release(); x = 0;}

// 直接输入版本

define DIRECTINPUT_VERSION 0x0800

// 定义窗口大小

define SCREEN_WIDTH 800

Define SCREEN_HEIGHT 600

//#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)

class DirectXGame { 结构顶点 { D3DXVECTOR3位置； D3DXVECTOR3正常； D3DXVECTOR2 紫外线； }; IDirect3D9* m_pD3DObject; IDirect3DDevice9* m_pD3DDevice;

D3DPRESENT_PARAMETERS   m_D3Dpp; 
ID3DXFont*              m_pD3DFont; //Font
LPDIRECT3DTEXTURE9      m_Texture;
ID3DXSprite*            m_Sprite;//Sprite
D3DXVECTOR3             texCenter,eyePos,lookAt,upVec;
D3DCAPS9                m_D3DCaps; //D3D Device Caps
D3DLIGHT9               m_Light;
D3DMATERIAL9            m_Mat; 
D3DVERTEXELEMENT9       m_Element;
D3DXMATRIX              view_Matrix, pro_Matrix;

// cube
Vertex m_cubeVerts[24];
WORD m_cubeIndices[36];
IDirect3DVertexBuffer9* VB;
IDirect3DIndexBuffer9* IB;  
IDirect3DVertexDeclaration9* vertDec;

bool m_bVSync;
char buffer [256];
int m_nWidth, m_nHeight;
int m_FPS,alfa[5],mFPS,mMilliSecPerFrame;
float m_currTime,m_prevTime,FOV, aspectRatio, nearPlane, farPlane;
DWORD D3DUSASE_DYNAMIC,D3DUSASE_WRITEONLY;

民众： DirectXGame(无效); 〜DirectXGame（无效）； void Initialize(HWND hWnd,HINSTANCE hInst, bool bWindowed); 布尔 isDeviceLost(); void Update(HWND hWnd, bool& bWindowed, double dt); 无效渲染（）； 无效检查位置（）； 无效关机（）；

};

Answer 1

您尚未启用 D3DRS_LIGHTING。

m_pD3DDevice->setRenderState(D3DRS_LIGHTING, TRUE);