Direct3D Tutorial 3: Using Matrices

Direct3D Tutorial 3: Using Matrices

术语：
rotation period 旋转周期
radians              弧度

// -----------------------------------------------------------------------------
//  File: Matrices.cpp
//
//  Desc: Now that we know how to create a device and render some 2D vertices,
//        this tutorial goes the next step and renders 3D geometry. To deal with
//        3D geometry we need to introduce the use of 4x4 matrices to transform
//        the geometry with translations, rotations, scaling, and setting up our
//        camera.
//
//        Geometry is defined in model space. We can move it (translation),
//        rotate it (rotation), or stretch it (scaling) using a world transform.
//        The geometry is then said to be in world space. Next, we need to
//        position the camera, or eye point, somewhere to look at the geometry.
//        Another transform, via the view matrix, is used, to position and
//        rotate our view. With the geometry then in view space, our last
//        transform is the projection transform, which "projects" the 3D scene
//        into our 2D viewport.
//
//        Note that in this tutorial, we are introducing the use of D3DX, which
//        is a set of helper utilities for D3D. In this case, we are using some
//        of D3DX's useful matrix initialization functions. To use D3DX, simply
//        include <d3dx9.h> and link with d3dx9.lib.
//
//  Copyright (c) Microsoft Corporation. All rights reserved.
// -----------------------------------------------------------------------------
#include  < Windows.h >
#include  < mmsystem.h >
#include  < d3dx9.h >
#pragma warning( disable :  4996  )  //  disable deprecated warning 
#include  < strsafe.h >
#pragma warning(  default  :  4996  ) 




// -----------------------------------------------------------------------------
//  Global variables
// -----------------------------------------------------------------------------
LPDIRECT3D9             g_pD3D        =  NULL;  //  Used to create the D3DDevice
LPDIRECT3DDEVICE9       g_pd3dDevice  =  NULL;  //  Our rendering device
LPDIRECT3DVERTEXBUFFER9 g_pVB         =  NULL;  //  Buffer to hold vertices

//  A structure for our custom vertex type
struct  CUSTOMVERTEX
{
    FLOAT x, y, z;       //  The untransformed, 3D position for the vertex
    DWORD color;         //  The vertex color
};

//  Our custom FVF, which describes our custom vertex structure
#define  D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)




// -----------------------------------------------------------------------------
//  Name: InitD3D()
//  Desc: Initializes Direct3D
// -----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
     //  Create the D3D object.
     if ( NULL  ==  ( g_pD3D  =  Direct3DCreate9( D3D_SDK_VERSION ) ) )
         return  E_FAIL;

     //  Set up the structure used to create the D3DDevice
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory(  & d3dpp,  sizeof (d3dpp) );
    d3dpp.Windowed  =  TRUE;
    d3dpp.SwapEffect  =  D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat  =  D3DFMT_UNKNOWN;

     //  Create the D3DDevice
     if ( FAILED( g_pD3D -> CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                                      D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                       & d3dpp,  & g_pd3dDevice ) ) )
    {
         return  E_FAIL;
    }

     //  Turn off culling, so we see the front and back of the triangle
     //  关闭剔除，以便三角形的前后都能被我们看到
    g_pd3dDevice -> SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

     //  Turn off D3D lighting, since we are providing our own vertex colors
     //  关闭D3D光照，因为我们提供我们自己的顶点颜色
    g_pd3dDevice -> SetRenderState( D3DRS_LIGHTING, FALSE );

     return  S_OK;
}




// -----------------------------------------------------------------------------
//  Name: InitGeometry()
//  Desc: Creates the scene geometry
// -----------------------------------------------------------------------------
HRESULT InitGeometry()
{
     //  Initialize three vertices for rendering a triangle
    CUSTOMVERTEX g_Vertices[]  =
    {
        {  - 1.0f , - 1.0f ,  0.0f ,  0xffff0000 , },
        {   1.0f , - 1.0f ,  0.0f ,  0xff0000ff , },
        {   0.0f ,  1.0f ,  0.0f ,  0xffffffff , },
    };

     //  Create the vertex buffer.
     if ( FAILED( g_pd3dDevice -> CreateVertexBuffer(  3 * sizeof (CUSTOMVERTEX),
                                                   0 , D3DFVF_CUSTOMVERTEX,
                                                  D3DPOOL_DEFAULT,  & g_pVB, NULL ) ) )
    {
         return  E_FAIL;
    }

     //  Fill the vertex buffer.
    VOID *  pVertices;
     if ( FAILED( g_pVB -> Lock(  0 ,  sizeof (g_Vertices), ( void ** ) & pVertices,  0  ) ) )
         return  E_FAIL;
    memcpy( pVertices, g_Vertices,  sizeof (g_Vertices) );
    g_pVB -> Unlock();

     return  S_OK;
}




// -----------------------------------------------------------------------------
//  Name: Cleanup()
//  Desc: Releases all previously initialized objects
// -----------------------------------------------------------------------------
VOID Cleanup()
{
     if ( g_pVB  !=  NULL )
        g_pVB -> Release();

     if ( g_pd3dDevice  !=  NULL )
        g_pd3dDevice -> Release();

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

下面是最关键的函数:

// -----------------------------------------------------------------------------
//  Name: SetupMatrices()
//  Desc: Sets up the world, view, and projection transform matrices.
// -----------------------------------------------------------------------------
VOID SetupMatrices()
{
     //  For our world matrix, we will just rotate the object about the y-axis.
     //  物件只围绕y轴旋转
    D3DXMATRIXA16 matWorld;

     //  Set up the rotation matrix to generate 1 full rotation (2*PI radians) every 1000 ms. 
     //  配置旋转矩阵为每1000ms一整圈（2*PI 弧度）
     //  To avoid the loss of precision inherent in very high floating point numbers,
     //  为了避免高浮点数固有的精度损失，
     //  the system time is modulated by the rotation period before conversion to a radian angle.
     //  系统时间被旋转周期求模，在它被转化成弧度角前
    UINT  iTime   =  timeGetTime()  %   1000 ;
    FLOAT fAngle  =  iTime  *  ( 2.0f   *  D3DX_PI)  /   1000.0f ;
    D3DXMatrixRotationY(  & matWorld, fAngle );
    g_pd3dDevice -> SetTransform( D3DTS_WORLD,  & matWorld );

设置视图矩阵,看图：

     //  Set up our view matrix. 
     //  设置视图矩阵
     //  A view matrix can be defined given an eye point,
     //  a point to lookat, and a direction for which way is up. Here, we set the
     //  eye five units back along the z-axis and up three units, look at the
     //  origin, and define "up" to be in the y-direction.
    D3DXVECTOR3 vEyePt(  0.0f ,  3.0f , - 5.0f  );
    D3DXVECTOR3 vLookatPt(  0.0f ,  0.0f ,  0.0f  );
    D3DXVECTOR3 vUpVec(  0.0f ,  1.0f ,  0.0f  );
    D3DXMATRIXA16 matView;
    D3DXMatrixLookAtLH(  & matView,  & vEyePt,  & vLookatPt,  & vUpVec );
    g_pd3dDevice -> SetTransform( D3DTS_VIEW,  & matView );

投影矩阵：

     //  For the projection matrix, we set up a perspective transform (which
     //  transforms geometry from 3D view space to 2D viewport space, with
     //  a perspective divide making objects smaller in the distance). 
     //  投影矩阵，我们配置一个透视转化（把图形从3D视图空间转化到2D视口空间，透视划分使得远的物件小）
     //  To build a perpsective transform, we need the field of view (1/4 pi is common),
     //  the aspect ratio, and the near and far clipping planes (which define at
     //  what distances geometry should be no longer be rendered).
     //  构建透视转化，四个参数(1)the field of view (2)the aspect ratio (3)the near clipping plane (4)the far clipping plane
    D3DXMATRIXA16 matProj;
    D3DXMatrixPerspectiveFovLH(  & matProj, D3DX_PI / 4 ,  1.0f ,  1.0f ,  100.0f  );
    g_pd3dDevice -> SetTransform( D3DTS_PROJECTION,  & matProj );
}

// -----------------------------------------------------------------------------
//  Name: Render()
//  Desc: Draws the scene
// -----------------------------------------------------------------------------
VOID Render()
{
     //  Clear the backbuffer to a black color
    g_pd3dDevice -> Clear(  0 , NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 0 , 0 , 0 ),  1.0f ,  0  );

     //  Begin the scene
     if ( SUCCEEDED( g_pd3dDevice -> BeginScene() ) )
    {
         //  Setup the world, view, and projection matrices
        SetupMatrices();

         //  Render the vertex buffer contents
        g_pd3dDevice -> SetStreamSource(  0 , g_pVB,  0 ,  sizeof (CUSTOMVERTEX) );
        g_pd3dDevice -> SetFVF( D3DFVF_CUSTOMVERTEX );
        g_pd3dDevice -> DrawPrimitive( D3DPT_TRIANGLESTRIP,  0 ,  1  );

         //  End the scene
        g_pd3dDevice -> EndScene();
    }

     //  Present the backbuffer contents to the display
    g_pd3dDevice -> Present( NULL, NULL, NULL, NULL );
}




// -----------------------------------------------------------------------------
//  Name: MsgProc()
//  Desc: The window's message handler
// -----------------------------------------------------------------------------
LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
     switch ( msg )
    {
         case  WM_DESTROY:
            Cleanup();
            PostQuitMessage(  0  );
             return   0 ;
    }

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




// -----------------------------------------------------------------------------
//  Name: WinMain()
//  Desc: The application's entry point
// -----------------------------------------------------------------------------
INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
     //  Register the window class
    WNDCLASSEX wc  =  {  sizeof (WNDCLASSEX), CS_CLASSDC, MsgProc,  0L ,  0L ,
                      GetModuleHandle(NULL), NULL, NULL, NULL, NULL,
                       " D3D Tutorial " , NULL };
    RegisterClassEx(  & wc );

     //  Create the application's window
    HWND hWnd  =  CreateWindow(  " D3D Tutorial " ,  " D3D Tutorial 03: Matrices " ,
                              WS_OVERLAPPEDWINDOW,  100 ,  100 ,  256 ,  256 ,
                              NULL, NULL, wc.hInstance, NULL );

     //  Initialize Direct3D
     if ( SUCCEEDED( InitD3D( hWnd ) ) )
    {
         //  Create the scene geometry
         if ( SUCCEEDED( InitGeometry() ) )
        {
             //  Show the window
            ShowWindow( hWnd, SW_SHOWDEFAULT );
            UpdateWindow( hWnd );

             //  Enter the message loop
            MSG msg;
            ZeroMemory(  & msg,  sizeof (msg) );
             while ( msg.message != WM_QUIT )
            {
                 if ( PeekMessage(  & msg, NULL,  0U ,  0U , PM_REMOVE ) )
                {
                    TranslateMessage(  & msg );
                    DispatchMessage(  & msg );
                }
                 else
                    Render();
            }
        }
    }

    UnregisterClass(  " D3D Tutorial " , wc.hInstance );
     return   0 ;
}