Direct3D Tutorial 3: Using Matrices

Direct3D Tutorial 3: Using Matrices
术语:
rotation period 旋转周期
radians              弧度

Direct3D Tutorial 3: Using Matrices_第1张图片

// -----------------------------------------------------------------------------
//  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 );
设置视图矩阵,看图:

Direct3D Tutorial 3: Using Matrices_第2张图片

     //  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 ;
}

你可能感兴趣的:(Direct3D Tutorial 3: Using Matrices)