DirectX Box

通过该Demo,可以清楚了解DirectX流程。将完整程序贴出，自己加以注释，方面查看理解。

/*
2015.4
d3dUtil.h

d3d 常用工具代码
*/

#ifndef D3DUTIL_H
#define D3DUTIL_H

// Let VC++ know we are compiling for WinXP and up.  This let's us use
// API functions specific to WinXP (e.g., WM_INPUT API).
#ifndef _WIN32_WINNT
#define _WIN32_WINNT   0x0600 // Vista
#endif

// Enable extra D3D debugging in debug builds if using the debug DirectX runtime.  
// This makes D3D objects work well in the debugger watch window, but slows down 
// performance slightly.
#if defined(DEBUG) || defined(_DEBUG)
    #ifndef D3D_DEBUG_INFO
    #define D3D_DEBUG_INFO
    #endif
#endif

#if defined(DEBUG) || defined(_DEBUG)
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif


#include <d3dx10.h>
#include <dxerr.h>
#include <cassert>

// Simple d3d error checker.
#if defined(DEBUG) | defined(_DEBUG)
#ifndef HR
#define HR(x)                                                    \
    {                                                            \
        HRESULT hr = (x);                                        \
        if (FAILED(hr))                                            \
        {                                                        \
            DXTrace(__FILE__, (DWORD)__LINE__, hr, L#x, true);    \
        }                                                        \
    }                                                            \
/*当DXTrace函数的最后一个参数设为false时，该函数不会显示消息框，
而是把调试信息输出到Visual C++的输出窗口*/
#endif

#else
#ifndef HR
#define HR(x) (x)
#endif
#endif 

// releasing COM objects
#define ReleaseCOM(x) { if(x){ x->Release();x = 0; } }

// 内联函数
// Converts ARGB 32-bit color format to ABGR 32-bit color format.
D3DX10INLINE UINT ARGB2ABGR(UINT argb)
{
    BYTE A = (argb >> 24) & 0xff;
    BYTE R = (argb >> 16) & 0xff;
    BYTE G = (argb >> 8) & 0xff;
    BYTE B = (argb >> 0) & 0xff;

    return (A << 24) | (B << 16) | (G << 8) | (R << 0);
}

// Returns random float in [0, 1).
D3DX10INLINE float RandF()
{
    return (float)(rand()) / (float)RAND_MAX;
}
// Returns random float in [a, b).
D3DX10INLINE float RandF(float a, float b)
{
    return a + RandF()*(b - a);
}

// 获得单位球体向量
D3DX10INLINE D3DXVECTOR3 RandUnitVec3()
{
    D3DXVECTOR3 v(RandF(), RandF(), RandF());
    D3DXVec3Normalize(&v, &v);
    return v;
}

template<typename T>
D3DX10INLINE T Min(const T& a, const T& b)
{
    return a < b ? a : b;
}

template<typename T>
D3DX10INLINE T Max(const T& a, const T& b)
{
    return a > b ? a : b;
}

//线性插值，在不生成像素的情况下增加图像像素大小的一种方法
template<typename T>
D3DX10INLINE T Lerp(const T& a, const T& b, float t)
{
    return a + (b - a)*t;
}

template<typename T>
D3DX10INLINE T Clamp(const T& x, const T& low, const T& high)
{
    return x < low ? low : (x > high ? high : x);
}

const float PI = 3.14159265358979323f;
const float MATH_EPS = 0.0001f;

const D3DXCOLOR WHITE(1.0f, 1.0f, 1.0f, 1.0f);
const D3DXCOLOR BLACK(0.0f, 0.0f, 0.0f, 1.0f);
const D3DXCOLOR RED(1.0f, 0.0f, 0.0f, 1.0f);
const D3DXCOLOR GREEN(0.0f, 1.0f, 0.0f, 1.0f);
const D3DXCOLOR BLUE(0.0f, 0.0f, 1.0f, 1.0f);
const D3DXCOLOR YELLOW(1.0f, 1.0f, 0.0f, 1.0f);
const D3DXCOLOR CYAN(0.0f, 1.0f, 1.0f, 1.0f);
const D3DXCOLOR MAGENTA(1.0f, 0.0f, 1.0f, 1.0f);

const D3DXCOLOR BEACH_SAND(1.0f, 0.96f, 0.62f, 1.0f);
const D3DXCOLOR LIGHT_YELLOW_GREEN(0.48f, 0.77f, 0.46f, 1.0f);
const D3DXCOLOR DARK_YELLOW_GREEN(0.1f, 0.48f, 0.19f, 1.0f);
const D3DXCOLOR DARKBROWN(0.45f, 0.39f, 0.34f, 1.0f);

#endif

 

/*
2015.4
GameTimer.h

*/

#ifndef GAMETIMER_H
#define GAMETIMER_H

class GameTimer
{
public:
    GameTimer();

    float getGameTime()const;  // in seconds

    // 获得增量
    float getDeltaTime()const; // in seconds

    void reset(); // Call before message loop.
    void start(); // Call when unpaused.
    void stop();  // Call when paused.
    void tick();  // Call every frame.

private:
    double mSecondsPerCount;
    double mDeltaTime;

    __int64 mBaseTime;
    __int64 mPausedTime;
    __int64 mStopTime;
    __int64 mPrevTime;
    __int64 mCurrTime;

    bool mStopped;
};

#endif 

 

/*
2015.4
GameTimer.cpp

*/
#include "GameTimer.h"
#include <windows.h>

GameTimer::GameTimer()
: mSecondsPerCount(0.0), mDeltaTime(-1.0), mBaseTime(0),
mPausedTime(0), mPrevTime(0), mCurrTime(0), mStopped(false)
{
    __int64 countsPerSec;

    // 获取性能计时器的频率（每秒的计数次数）
    QueryPerformanceFrequency((LARGE_INTEGER*)&countsPerSec);
    mSecondsPerCount = 1.0 / (double)countsPerSec;
}

// Returns the total time elapsed since reset() was called, NOT counting any
// time when the clock is stopped.
float GameTimer::getGameTime()const
{
    // If we are stopped, do not count the time that has passed since we stopped.
    //
    // ----*---------------*------------------------------*------> time
    //  mBaseTime       mStopTime                      mCurrTime

    if (mStopped)
    {
        return (float)((mStopTime - mBaseTime)*mSecondsPerCount);
    }

    // The distance mCurrTime - mBaseTime includes paused time,
    // which we do not want to count.  To correct this, we can subtract 
    // the paused time from mCurrTime:  
    //
    //  (mCurrTime - mPausedTime) - mBaseTime 
    //
    //                     |<-------d------->|
    // ----*---------------*-----------------*------------*------> time
    //  mBaseTime       mStopTime        startTime     mCurrTime

    else
    {
        return (float)(((mCurrTime - mPausedTime) - mBaseTime)*mSecondsPerCount);
    }
}

float GameTimer::getDeltaTime()const
{
    return (float)mDeltaTime;
}

void GameTimer::reset()
{
    __int64 currTime;
    QueryPerformanceCounter((LARGE_INTEGER*)&currTime);

    mBaseTime = currTime;
    mPrevTime = currTime;
    mStopTime = 0;
    mStopped = false;
}

void GameTimer::start()
{
    __int64 startTime;
    QueryPerformanceCounter((LARGE_INTEGER*)&startTime);


    // Accumulate the time elapsed between stop and start pairs.
    //
    //                     |<-------d------->|
    // ----*---------------*-----------------*------------> time
    //  mBaseTime       mStopTime        startTime     

    if (mStopped)
    {
        mPausedTime += (startTime - mStopTime);

        mPrevTime = startTime;
        mStopTime = 0;
        mStopped = false;
    }
}

void GameTimer::stop()
{
    if (!mStopped)
    {
        __int64 currTime;
        QueryPerformanceCounter((LARGE_INTEGER*)&currTime);

        mStopTime = currTime;
        mStopped = true;
    }
}

void GameTimer::tick()
{
    if (mStopped)
    {
        mDeltaTime = 0.0;
        return;
    }

    __int64 currTime;
    QueryPerformanceCounter((LARGE_INTEGER*)&currTime);
    mCurrTime = currTime;

    // Time difference between this frame and the previous.
    mDeltaTime = (mCurrTime - mPrevTime)*mSecondsPerCount;

    // Prepare for next frame.
    mPrevTime = mCurrTime;

    // Force nonnegative.  The DXSDK's CDXUTTimer mentions that if the 
    // processor goes into a power save mode or we get shuffled to another
    // processor, then mDeltaTime can be negative.
    if (mDeltaTime < 0.0)
    {
        mDeltaTime = 0.0;
    }
}

 

/*
2015.4
d3dApp.h

Simple Direct3D demo application class.

Make sure you link: d3d10.lib d3dx10d.lib dxerr.lib dxguid.lib.
Link d3dx10.lib for release mode builds instead of d3dx10d.lib.
*/

#ifndef D3DAPP_H
#define D3DAPP_H


#include "d3dUtil.h"
#include "GameTimer.h"
#include <string>

#pragma comment(lib, "d3d10.lib")
#pragma comment(lib, "d3dx10d.lib")
#pragma comment(lib, "dxguid.lib")
#pragma comment(lib, "dxerr.lib")

class D3DApp
{
public:
    D3DApp(HINSTANCE hInstance);
    virtual ~D3DApp();

    HINSTANCE getAppInst();
    HWND      getMainWnd();

    int run();

    // Framework methods.  Derived client class overrides these methods to 
    // implement specific application requirements.

    virtual void initApp();
    virtual void onResize();// reset projection/etc
    virtual void updateScene(float dt);
    virtual void drawScene();
    virtual LRESULT msgProc(UINT msg, WPARAM wParam, LPARAM lParam);

protected:
    void initMainWindow();
    void initDirect3D();

protected:

    HINSTANCE mhAppInst;
    HWND      mhMainWnd;
    bool      mAppPaused;
    bool      mMinimized;
    bool      mMaximized;
    bool      mResizing;

    GameTimer mTimer;

    std::wstring mFrameStats;

    ID3D10Device*    md3dDevice;
    IDXGISwapChain*  mSwapChain;
    ID3D10Texture2D* mDepthStencilBuffer;
    ID3D10RenderTargetView* mRenderTargetView;
    ID3D10DepthStencilView* mDepthStencilView;
    ID3DX10Font* mFont;

    // Derived class should set these in derived constructor to customize starting values.
    std::wstring mMainWndCaption;
    D3D10_DRIVER_TYPE md3dDriverType;
    D3DXCOLOR mClearColor;
    int mClientWidth;
    int mClientHeight;
};

#endif // D3DAPP_H

 

/*
2015.4
d3dApp.cpp

*/
#include "d3dApp.h"
#include <sstream>

LRESULT CALLBACK MainWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static D3DApp* app = 0;

    switch (msg)
    {
    case WM_CREATE:
    {
        // Get the 'this' pointer we passed to CreateWindow via the lpParam parameter.
        // CREATESTRUCT结构定义了应用程序中窗口过程的初始化参数
        CREATESTRUCT* cs = (CREATESTRUCT*)lParam;
        app = (D3DApp*)cs->lpCreateParams;
        return 0;
    }
    }

    // Don't start processing messages until after WM_CREATE.
    if (app)
        return app->msgProc(msg, wParam, lParam);
    else
        return DefWindowProc(hwnd, msg, wParam, lParam);
}

D3DApp::D3DApp(HINSTANCE hInstance)
{
    mhAppInst = hInstance;
    mhMainWnd = 0;
    mAppPaused = false;
    mMinimized = false;
    mMaximized = false;
    mResizing = false;

    mFrameStats = L"";

    md3dDevice = 0;
    mSwapChain = 0;
    mDepthStencilBuffer = 0;
    mRenderTargetView = 0;
    mDepthStencilView = 0;
    mFont = 0;

    mMainWndCaption = L"D3D10 Application";
    md3dDriverType = D3D10_DRIVER_TYPE_HARDWARE;
    mClearColor = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);    // Set background color
    mClientWidth = 800;
    mClientHeight = 600;
}

D3DApp::~D3DApp()
{
    ReleaseCOM(mRenderTargetView);
    ReleaseCOM(mDepthStencilView);
    ReleaseCOM(mSwapChain);
    ReleaseCOM(mDepthStencilBuffer);
    ReleaseCOM(md3dDevice);
    ReleaseCOM(mFont);
}

HINSTANCE D3DApp::getAppInst()
{
    return mhAppInst;
}

HWND D3DApp::getMainWnd()
{
    return mhMainWnd;
}

int D3DApp::run()
{
    MSG msg = { 0 };

    mTimer.reset();

    while (msg.message != WM_QUIT)
    {
        // If there are Window messages then process them.
        if (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        // Otherwise, do animation/game.
        else
        {
            mTimer.tick();

            if (!mAppPaused)
                updateScene(mTimer.getDeltaTime());
            else
                Sleep(50);

            drawScene();
        }
    }
    return (int)msg.wParam;
}

void D3DApp::initApp()
{
    initMainWindow();
    initDirect3D();

    D3DX10_FONT_DESC fontDesc;
    fontDesc.Height = 20;
    fontDesc.Width = 0;
    fontDesc.Weight = 500; // 字体的粗细0~1000
    fontDesc.MipLevels = 1;
    fontDesc.Italic = false;//非斜体
    fontDesc.CharSet = DEFAULT_CHARSET;
    fontDesc.OutputPrecision = OUT_DEFAULT_PRECIS;
    fontDesc.Quality = DEFAULT_QUALITY;
    fontDesc.PitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
    wcscpy_s(fontDesc.FaceName, L"Arial");// font style

    D3DX10CreateFontIndirect(md3dDevice, &fontDesc, &mFont);
    ////文本输出示例：
    //// We specify DT_NOCLIP, so we do not care about width/height of the rect.
    //const D3DXCOLOR BLACK(0.0f, 0.0f, 0.0f, 1.0f);
    //RECT R = { 5, 5, 0, 0 };
    //mFont->DrawText(0, L"Hello, Direct3D!", -1, &R, DT_NOCLIP, BLACK);
}

void D3DApp::onResize()
{
    // Release the old views, as they hold references to the buffers we
    // will be destroying.  Also release the old depth/stencil buffer.

    ReleaseCOM(mRenderTargetView);
    ReleaseCOM(mDepthStencilView);
    ReleaseCOM(mDepthStencilBuffer);


    // Resize the swap chain and recreate the render target view.

    HR(mSwapChain->ResizeBuffers(1, mClientWidth, mClientHeight, DXGI_FORMAT_R8G8B8A8_UNORM, 0));
    ID3D10Texture2D* backBuffer;
    HR(mSwapChain->GetBuffer(0, __uuidof(ID3D10Texture2D), reinterpret_cast<void**>(&backBuffer)));
    HR(md3dDevice->CreateRenderTargetView(backBuffer, 0, &mRenderTargetView));
    ReleaseCOM(backBuffer);


    // Create the depth/stencil buffer and view.

    D3D10_TEXTURE2D_DESC depthStencilDesc;

    depthStencilDesc.Width = mClientWidth;
    depthStencilDesc.Height = mClientHeight;
    depthStencilDesc.MipLevels = 1;
    depthStencilDesc.ArraySize = 1;
    depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    depthStencilDesc.SampleDesc.Count = 1; // multisampling must match
    depthStencilDesc.SampleDesc.Quality = 0; // swap chain values.
    depthStencilDesc.Usage = D3D10_USAGE_DEFAULT;
    depthStencilDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL;
    depthStencilDesc.CPUAccessFlags = 0;
    depthStencilDesc.MiscFlags = 0;

    HR(md3dDevice->CreateTexture2D(&depthStencilDesc, 0, &mDepthStencilBuffer));
    HR(md3dDevice->CreateDepthStencilView(mDepthStencilBuffer, 0, &mDepthStencilView));


    // Bind the render target view and depth/stencil view to the pipeline.

    md3dDevice->OMSetRenderTargets(1, &mRenderTargetView, mDepthStencilView);


    // Set the viewport transform.

    D3D10_VIEWPORT vp;
    vp.TopLeftX = 0;
    vp.TopLeftY = 0;
    vp.Width = mClientWidth;
    vp.Height = mClientHeight;
    vp.MinDepth = 0.0f;
    vp.MaxDepth = 1.0f;

    md3dDevice->RSSetViewports(1, &vp);
}

void D3DApp::updateScene(float dt)
{
    // Code computes the average frames per second, and also the 
    // average time it takes to render one frame.

    static int frameCnt = 0;
    static float t_base = 0.0f;

    frameCnt++;

    // Compute averages over one second period.
    if ((mTimer.getGameTime() - t_base) >= 1.0f)
    {
        float fps = (float)frameCnt; // fps = frameCnt / 1
        float mspf = 1000.0f / fps;

        std::wostringstream outs;
        outs.precision(6);
        outs << L"FPS: " << fps << L"\n"
            << "Milliseconds(Per Frame): " << mspf;
        mFrameStats = outs.str();

        // Reset for next average.
        frameCnt = 0;
        t_base += 1.0f;
    }
}

void D3DApp::drawScene()
{
    // Set all the elements in a render target to one value
    md3dDevice->ClearRenderTargetView(mRenderTargetView, mClearColor);

    // Clears the depth-stencil resource
    md3dDevice->ClearDepthStencilView(mDepthStencilView, D3D10_CLEAR_DEPTH | D3D10_CLEAR_STENCIL, 1.0f, 0);
}

LRESULT D3DApp::msgProc(UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch (msg)
    {
        // WM_ACTIVATE is sent when the window is activated or deactivated.  
        // We pause the game when the window is deactivated and unpause it 
        // when it becomes active.  
    case WM_ACTIVATE:
        if (LOWORD(wParam) == WA_INACTIVE)
        {
            mAppPaused = true;
            mTimer.stop();
        }
        else
        {
            mAppPaused = false;
            mTimer.start();
        }
        return 0;

        // WM_SIZE is sent when the user resizes the window.  
    case WM_SIZE:
        // Save the new client area dimensions.
        mClientWidth = LOWORD(lParam);
        mClientHeight = HIWORD(lParam);
        if (md3dDevice)
        {
            if (wParam == SIZE_MINIMIZED)
            {
                mAppPaused = true;
                mMinimized = true;
                mMaximized = false;
            }
            else if (wParam == SIZE_MAXIMIZED)
            {
                mAppPaused = false;
                mMinimized = false;
                mMaximized = true;
                onResize();
            }
            else if (wParam == SIZE_RESTORED)
            {

                // Restoring from minimized state?
                if (mMinimized)
                {
                    mAppPaused = false;
                    mMinimized = false;
                    onResize();
                }

                // Restoring from maximized state?
                else if (mMaximized)
                {
                    mAppPaused = false;
                    mMaximized = false;
                    onResize();
                }
                else if (mResizing)
                {
                    // If user is dragging the resize bars, we do not resize 
                    // the buffers here because as the user continuously 
                    // drags the resize bars, a stream of WM_SIZE messages are
                    // sent to the window, and it would be pointless (and slow)
                    // to resize for each WM_SIZE message received from dragging
                    // the resize bars.  So instead, we reset after the user is 
                    // done resizing the window and releases the resize bars, which 
                    // sends a WM_EXITSIZEMOVE message.
                }
                else // API call such as SetWindowPos or mSwapChain->SetFullscreenState.
                {
                    onResize();
                }
            }
        }
        return 0;

        // WM_EXITSIZEMOVE is sent when the user grabs the resize bars.
    case WM_ENTERSIZEMOVE:
        mAppPaused = true;
        mResizing = true;
        mTimer.stop();
        return 0;

        // WM_EXITSIZEMOVE is sent when the user releases the resize bars.
        // Here we reset everything based on the new window dimensions.
    case WM_EXITSIZEMOVE:
        mAppPaused = false;
        mResizing = false;
        mTimer.start();
        onResize();
        return 0;

        // WM_DESTROY is sent when the window is being destroyed.
    case WM_DESTROY:
        PostQuitMessage(0);
        return 0;

        // The WM_MENUCHAR message is sent when a menu is active and the user presses 
        // a key that does not correspond to any mnemonic or accelerator key. 
    case WM_MENUCHAR:
        // Don't beep when we alt-enter.
        return MAKELRESULT(0, MNC_CLOSE);

        // Catch this message so to prevent the window from becoming too small.
    case WM_GETMINMAXINFO:
        ((MINMAXINFO*)lParam)->ptMinTrackSize.x = 200;
        ((MINMAXINFO*)lParam)->ptMinTrackSize.y = 200;
        return 0;
    }

    return DefWindowProc(mhMainWnd, msg, wParam, lParam);
}

void D3DApp::initMainWindow()
{
    WNDCLASS wc;
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = MainWndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = mhAppInst;
    wc.hIcon = LoadIcon(0, IDI_APPLICATION);
    wc.hCursor = LoadCursor(0, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)GetStockObject(NULL_BRUSH);
    wc.lpszMenuName = 0;
    wc.lpszClassName = L"D3DWndClassName";

    if (!RegisterClass(&wc))
    {
        MessageBox(0, L"RegisterClass FAILED", 0, 0);
        PostQuitMessage(0);
    }

    // Compute window rectangle dimensions based on requested client area dimensions.
    RECT R = { 0, 0, mClientWidth, mClientHeight };
    AdjustWindowRect(&R, WS_OVERLAPPEDWINDOW, false);
    int width = R.right - R.left;
    int height = R.bottom - R.top;

    mhMainWnd = CreateWindow(L"D3DWndClassName", mMainWndCaption.c_str(),
        WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, width, height, 0, 0, mhAppInst, this);
    if (!mhMainWnd)
    {
        MessageBox(0, L"CreateWindow FAILED", 0, 0);
        PostQuitMessage(0);
    }

    ShowWindow(mhMainWnd, SW_SHOW);
    UpdateWindow(mhMainWnd);
}

void D3DApp::initDirect3D()
{
    // Fill out a DXGI_SWAP_CHAIN_DESC to describe our swap chain.
    DXGI_SWAP_CHAIN_DESC sd;

    // describes the backbuffer display mode
    sd.BufferDesc.Width = mClientWidth;
    sd.BufferDesc.Height = mClientHeight;
    sd.BufferDesc.RefreshRate.Numerator = 60;
    sd.BufferDesc.RefreshRate.Denominator = 1;
    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    sd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
    sd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;

    // describes multi-sampling parameters
    // No multisampling.
    sd.SampleDesc.Count = 1;
    sd.SampleDesc.Quality = 0;

    // The back buffer can be used for shader input or render-target output
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;

    sd.BufferCount = 1;

    sd.OutputWindow = mhMainWnd;

    sd.Windowed = true;

    sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

    sd.Flags = 0;


    // Create the device.
    UINT createDeviceFlags = 0;
#if defined(DEBUG) || defined(_DEBUG)  
    createDeviceFlags |= D3D10_CREATE_DEVICE_DEBUG;
#endif

    HR(D3D10CreateDeviceAndSwapChain(
        0,                 //default adapter
        md3dDriverType,
        0,                 // no software device
        createDeviceFlags,
        D3D10_SDK_VERSION,
        &sd,
        &mSwapChain,
        &md3dDevice));

    onResize();
}

 

/*
2015.4
Box.h

*/
#ifndef BOX_H
#define BOX_H

#include "d3dUtil.h"

struct Vertex
{
    D3DXVECTOR3 pos;
    D3DXCOLOR   color;
};

class Box
{
public:
    Box();
    ~Box();

    void init(ID3D10Device* device, float scale);
    void draw();

private:
    DWORD mNumVertices;
    DWORD mNumFaces;

    ID3D10Device* md3dDevice;
    ID3D10Buffer* mVB;
    ID3D10Buffer* mIB;
};

#endif // BOX_H

 

/*
2015.4
Box.cpp

*/

#include "Box.h"

Box::Box()
: mNumVertices(0), mNumFaces(0), md3dDevice(0), mVB(0), mIB(0)
{
}
 
Box::~Box()
{
    ReleaseCOM(mVB);
    ReleaseCOM(mIB);
}

void Box::init(ID3D10Device* device, float scale)
{
    md3dDevice = device;
 
    mNumVertices = 8;
    mNumFaces    = 12; 

    // Create vertex buffer
    Vertex vertices[] =
    {
        { D3DXVECTOR3(-1.0f, -1.0f, -1.0f), WHITE},
        { D3DXVECTOR3(-1.0f, +1.0f, -1.0f), BLACK},
        { D3DXVECTOR3(+1.0f, +1.0f, -1.0f), RED},
        { D3DXVECTOR3(+1.0f, -1.0f, -1.0f), GREEN},
        { D3DXVECTOR3(-1.0f, -1.0f, +1.0f),  BLUE},
        { D3DXVECTOR3(-1.0f, +1.0f, +1.0f), YELLOW},
        { D3DXVECTOR3(+1.0f, +1.0f, +1.0f), CYAN},
        { D3DXVECTOR3(+1.0f, -1.0f, +1.0f), MAGENTA},
    };

    // Scale the box.
    // 乘上比例
    for(DWORD i = 0; i < mNumVertices; ++i)
        vertices[i].pos *= scale;

    // Describes a buffer resource
    /*
    typedef enum D3D10_USAGE { 
        D3D10_USAGE_DEFAULT    = 0,
        D3D10_USAGE_IMMUTABLE  = 1,    // only be read by the GPU.
        D3D10_USAGE_DYNAMIC    = 2,    // is accessible by both the GPU and the CPU (write only).
        D3D10_USAGE_STAGING    = 3
    } D3D10_USAGE;

    */
    D3D10_BUFFER_DESC vbd;
    vbd.Usage = D3D10_USAGE_IMMUTABLE;
    vbd.ByteWidth = sizeof(Vertex) * mNumVertices;
    vbd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
    vbd.CPUAccessFlags = 0;
    vbd.MiscFlags = 0;

    // Specifies data for initializing a subresource
    D3D10_SUBRESOURCE_DATA vinitData;
    vinitData.pSysMem = vertices;

    // Create a buffer (vertex buffer, index buffer, or shader-constant buffer)
    /*
    HRESULT CreateBuffer(
        [in]   const D3D10_BUFFER_DESC *pDesc,
        [in]   const D3D10_SUBRESOURCE_DATA *pInitialData,
        [out]  ID3D10Buffer **ppBuffer );
    */
    HR(md3dDevice->CreateBuffer(&vbd, &vinitData, &mVB));

    // Create the index buffer
    // Box 六面
    DWORD indices[] = {
        // front face
        0, 1, 2,
        0, 2, 3,

        // back face
        4, 6, 5,
        4, 7, 6,

        // left face
        4, 5, 1,
        4, 1, 0,

        // right face
        3, 2, 6,
        3, 6, 7,

        // top face
        1, 5, 6,
        1, 6, 2,

        // bottom face
        4, 0, 3, 
        4, 3, 7
    };

    D3D10_BUFFER_DESC ibd;
    ibd.Usage = D3D10_USAGE_IMMUTABLE;
    ibd.ByteWidth = sizeof(DWORD) * mNumFaces*3;
    ibd.BindFlags = D3D10_BIND_INDEX_BUFFER;
    ibd.CPUAccessFlags = 0;
    ibd.MiscFlags = 0;

    D3D10_SUBRESOURCE_DATA iinitData;
    iinitData.pSysMem = indices;
    HR(md3dDevice->CreateBuffer(&ibd, &iinitData, &mIB));
}

void Box::draw()
{
    UINT stride = sizeof(Vertex);
    UINT offset = 0;
    /*
    Bind an array of vertex buffers to the input-assembler stage

    void IASetVertexBuffers(
        [in]  UINT StartSlot,
        [in]  UINT NumBuffers,
        [in]  ID3D10Buffer *const *ppVertexBuffers,
        [in]  const UINT *pStrides,
        [in]  const UINT *pOffsets );    //Pointer to an array of offset values;
    */
    md3dDevice->IASetVertexBuffers(0, 1, &mVB, &stride, &offset);

    /*
    Bind an index buffer to the input-assembler stage.
    将一个索引缓冲区绑定到输入汇编器阶段
    void IASetIndexBuffer(
        [in]  ID3D10Buffer *pIndexBuffer,
        [in]  DXGI_FORMAT Format,
        [in]  UINT Offset );
    */
    md3dDevice->IASetIndexBuffer(mIB, DXGI_FORMAT_R32_UINT, 0);

    /*
    void DrawIndexed(
        [in]  UINT IndexCount,
        [in]  UINT StartIndexLocation,
        [in]  INT BaseVertexLocation );    //Offset from the start of the vertex buffer to the first vertex
    */
    md3dDevice->DrawIndexed(mNumFaces*3, 0, 0);


    /*
    完成图元汇编后，顶点将被送往顶点着色器（vertex shader）阶段。顶点着色器可以被看成是一个以顶点作为输入输出数据的函数,
    每个将要绘制的顶点都会通过顶点着色器推送至硬件.
    */
}

 

/*
2015.4
color.fx

Transforms and colors geometry.
使用下面的后缀来表示空间：L（局部空间）、W（世界空间）、V（观察空间）、H（齐次裁剪空间）
*/


cbuffer cbPerObject
{
    // 常量缓冲区,由着色器来访问
    float4x4 gWVP; 
};

void VS(float3 iPosL  : POSITION,
        float4 iColor : COLOR,
        out float4 oPosH  : SV_POSITION,
        out float4 oColor : COLOR)
{
    // Transform to homogeneous clip space.
    // 将顶点位置从局部空间变换到齐次裁剪空间，矩阵gWVP是世界矩阵、观察矩阵和投影矩阵的组合矩阵
    // float4(iPosL, 1.0f)相当于“float4(iPosL.x,iPosL.y, iPosL.z, 1.0f)
    oPosH = mul(float4(iPosL, 1.0f), gWVP);
    
    oColor = iColor;
}

float4 PS(float4 posH  : SV_POSITION,
          float4 color : COLOR) : SV_Target
{
    // 这里像素着色器只是简单地返回插值颜色
    return color;
}

// 一个technique 由一个或多个pass 组成,每个pass实现一种不同的几何体渲染方式
technique10 ColorTech
{
    // 一个pass 由一个顶点着色器、一个可选的几何着色器、一个像素着色器和一些渲染状态组成
    pass P0
    {
        // 顶点着色器设置为版本4.0, 4.0不再使用常量寄存器，而是使用常量缓存Constant Buffer
        SetVertexShader( CompileShader( vs_4_0, VS() ) );
        SetGeometryShader( NULL );
        SetPixelShader( CompileShader( ps_4_0, PS() ) );
    }
}

 

/*
2015.4
main_Box.cpp

Color Cube
Controls:
'A'/'D'/'W'/'S' - Rotate
*/

#include "d3dApp.h"
#include "Box.h"

class ColoredCubeApp : public D3DApp
{
public:
    ColoredCubeApp(HINSTANCE hInstance);
    ~ColoredCubeApp();

    void initApp();
    void onResize();
    void updateScene(float dt);
    void drawScene();

private:
    void buildFX();
    void buildVertexLayouts();

private:
    Box mBox;

    ID3D10Effect* mFX;
    ID3D10EffectTechnique* mTech;
    ID3D10InputLayout* mVertexLayout;
    ID3D10EffectMatrixVariable* mfxWVPVar;

    D3DXMATRIX mView;
    D3DXMATRIX mProj;
    D3DXMATRIX mWVP;

    float mTheta;
    float mPhi;
};

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE prevInstance,PSTR cmdLine, int showCmd)
{
    // Enable run-time memory check for debug builds.
#if defined(DEBUG) | defined(_DEBUG)
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif

    ColoredCubeApp theApp(hInstance);
    theApp.initApp();

    return theApp.run();
}

ColoredCubeApp::ColoredCubeApp(HINSTANCE hInstance)
: D3DApp(hInstance), mFX(0), mTech(0), mVertexLayout(0),
mfxWVPVar(0), mTheta(0.0f), mPhi(PI*0.25f)
{
    // 设为单位矩阵
    D3DXMatrixIdentity(&mView);
    D3DXMatrixIdentity(&mProj);
    D3DXMatrixIdentity(&mWVP);
}

ColoredCubeApp::~ColoredCubeApp()
{
    if (md3dDevice)
        md3dDevice->ClearState();

    ReleaseCOM(mFX);
    ReleaseCOM(mVertexLayout);
}

void ColoredCubeApp::initApp()
{
    D3DApp::initApp();

    // Box 绑定到该 md3dDevice
    mBox.init(md3dDevice, 1.0f);

    buildFX();
    buildVertexLayouts();
}

void ColoredCubeApp::onResize()
{
    D3DApp::onResize();

    float aspect = (float)mClientWidth / mClientHeight;
    D3DXMatrixPerspectiveFovLH(&mProj, 0.25f*PI, aspect, 1.0f, 1000.0f);
}

void ColoredCubeApp::updateScene(float dt)
{
    D3DApp::updateScene(dt);

    // Update angles based on input to orbit camera around box.
    //改变夹角
    if (GetAsyncKeyState('A') & 0x8000)    mTheta -= 5.0f*dt; 
    if (GetAsyncKeyState('D') & 0x8000)    mTheta += 5.0f*dt;
    if (GetAsyncKeyState('W') & 0x8000)    mPhi -= 5.0f*dt;
    if (GetAsyncKeyState('S') & 0x8000)    mPhi += 5.0f*dt;

    // Restrict the angle mPhi.
    if (mPhi < 0.1f)    mPhi = 0.1f;
    if (mPhi > PI - 0.1f)    mPhi = PI - 0.1f;

    // Convert Spherical to Cartesian coordinates: mPhi measured from +y
    // and mTheta measured counterclockwise from -z.
    float x = 5.0f*sinf(mPhi)*sinf(mTheta);
    float z = -5.0f*sinf(mPhi)*cosf(mTheta);
    float y = 5.0f*cosf(mPhi);

    // Build the view matrix.
    D3DXVECTOR3 pos(x, y, z);
    D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
    D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);

    D3DXMatrixLookAtLH(&mView, &pos, &target, &up);
}

void ColoredCubeApp::drawScene()
{
    D3DApp::drawScene();

    // Restore default states, input layout and primitive topology 
    // because mFont->DrawText changes them.  Note that we can 
    // restore the default states by passing null.
    md3dDevice->OMSetDepthStencilState(0, 0);
    float blendFactors[] = { 0.0f, 0.0f, 0.0f, 0.0f };
    md3dDevice->OMSetBlendState(0, blendFactors, 0xffffffff);

    // 当一个input layout被创建以后， 调用IASetInputLayout函数可以把它绑定一个divece中
    md3dDevice->IASetInputLayout(mVertexLayout);

    // vertex buffer只是在内存中存储了一系列内存点,用Primitive Topology告诉Direct3D用点形成几何图形的方式
    md3dDevice->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    // set constants
    mWVP = mView*mProj;
    mfxWVPVar->SetMatrix((float*)&mWVP);

    D3D10_TECHNIQUE_DESC techDesc;
    mTech->GetDesc(&techDesc);
    for (UINT p = 0; p < techDesc.Passes; ++p)
    {
        /*Apply方法的作用：
        更新存储在GPU 内存中的常量缓冲区、将着色器程序绑定到管线、并启用在pass中指定的各种渲染状态。
        */
        mTech->GetPassByIndex(p)->Apply(0);

        mBox.draw();
    }

    // We specify DT_NOCLIP, so we do not care about width/height of the rect.
    RECT R = { 5, 5, 0, 0 };
    mFont->DrawText(0, mFrameStats.c_str(), -1, &R, DT_NOCLIP, BLACK);

    mSwapChain->Present(0, 0);
}

// 着色器
void ColoredCubeApp::buildFX()
{
    DWORD shaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
    shaderFlags |= D3D10_SHADER_DEBUG;
    shaderFlags |= D3D10_SHADER_SKIP_OPTIMIZATION;
#endif

    // 通用内存块,使用时应该对它执行相应的类型转换
    // used to return object code and error messages in APIs that compile vertex, geometry and pixel shaders.
    ID3D10Blob* compilationErrors = 0;

    HRESULT hr = 0;
    // 编译着色器
    hr = D3DX10CreateEffectFromFile(L"color.fx", 0, 0,
        "fx_4_0", shaderFlags, 0, md3dDevice, 0, 0, &mFX, &compilationErrors, 0);
    if (FAILED(hr))
    {
        if (compilationErrors)
        {
            MessageBoxA(0, (char*)compilationErrors->GetBufferPointer(), 0, 0);
            ReleaseCOM(compilationErrors);
        }
        // Outputs a formatted error message to the debug stream
        DXTrace(__FILE__, (DWORD)__LINE__, hr, L"D3DX10CreateEffectFromFile", true);
    }

    // 获得指向technique对象的指针
    mTech = mFX->GetTechniqueByName("ColorTech");

    /*
    ID3D10Effect::GetVariableByName方法返回一个ID3D10EffectVariable指针。
    它是一种通用效果变量类型；要获得指向特定类型变量的指针（例如，矩阵、向量、标量），
    你必须使用相应的As*****方法（例如，AsMatrix、AsVector、AsScalar）。
    然后可以通过C++接口来更新它们
    */
    mfxWVPVar = mFX->GetVariableByName("gWVP")->AsMatrix();
}

// 构建图元
void ColoredCubeApp::buildVertexLayouts()
{
    /*
    typedef struct D3D10_INPUT_ELEMENT_DESC {
        LPCSTR                     SemanticName;
        UINT                       SemanticIndex;
        DXGI_FORMAT                Format;
        UINT                       InputSlot;        // between 0 and 15
        UINT                       AlignedByteOffset;
        D3D10_INPUT_CLASSIFICATION InputSlotClass;
        UINT                       InstanceDataStepRate;
    } D3D10_INPUT_ELEMENT_DESC;
    */
    D3D10_INPUT_ELEMENT_DESC vertexDesc[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 }
    };

    D3D10_PASS_DESC PassDesc;
    // Get a pass description by calling ID3D10EffectPass::GetDesc
    mTech->GetPassByIndex(0)->GetDesc(&PassDesc);

    /*
    Create an input-layout object to describe the input-buffer data for the input-assembler stage.

    HRESULT CreateInputLayout(
        [in]   const D3D10_INPUT_ELEMENT_DESC *pInputElementDescs,
        [in]   UINT NumElements,
        [in]   const void *pShaderBytecodeWithInputSignature,
        [in]   SIZE_T BytecodeLength,
        [out]  ID3D10InputLayout **ppInputLayout );

    After creating an input layout object, it must be bound to the input-assembler stage
    before calling a draw API. 
    */
    HR(md3dDevice->CreateInputLayout(vertexDesc, 2, PassDesc.pIAInputSignature,
        PassDesc.IAInputSignatureSize, &mVertexLayout));
}