ch10p1_simplevertexshader.cpp

游戏开发特殊技巧-special.effects.game.programming

/*
#############################################################################

  Ch10p1_SimpleVertexShader.cpp: a program that demonstrates how to create
  and use vertex shaders.

#############################################################################
*/

// include files ////////////////////////////////////////////////////////////

#include <d3dx8.h>
#include <mmsystem.h>

//-----------------------------------------------------------------------------
// Global variables
//-----------------------------------------------------------------------------
LPDIRECT3D8             g_pD3D       = NULL; // Used to create the D3DDevice
LPDIRECT3DDEVICE8       g_pd3dDevice = NULL; // Our rendering device
LPDIRECT3DVERTEXBUFFER8 g_pVB        = NULL; // Buffer to hold vertices
DWORD                   g_dwShader   = 0;    // Handle to shader

D3DXMATRIX g_matProj;
D3DXMATRIX g_matView;
D3DXMATRIX g_matWorld;

// A structure for our custom vertex type.
struct CUSTOMVERTEX
{
  D3DXVECTOR3 position; // The position
  D3DCOLOR    color;    // The 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 = Direct3DCreate8( D3D_SDK_VERSION ) ) )
    return E_FAIL;

  // Get the current desktop display mode, so we can set up a back
  // buffer of the same format
  D3DDISPLAYMODE d3ddm;
  if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
    return E_FAIL;

  // Set up the structure used to create the D3DDevice. Since we are now
  // using more complex geometry, we will create a device with a zbuffer.
  D3DPRESENT_PARAMETERS d3dpp;
  ZeroMemory( &d3dpp, sizeof(d3dpp) );
  d3dpp.Windowed = TRUE;
  d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
  d3dpp.BackBufferFormat = d3ddm.Format;
  d3dpp.EnableAutoDepthStencil = TRUE;
  d3dpp.AutoDepthStencilFormat = D3DFMT_D16;

  // 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
  g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );

  // Turn off D3D lighting
  g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );

  // Turn on the zbuffer
  g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );

  return S_OK;
}

//-----------------------------------------------------------------------------
// Name: InitGeometry()
// Desc: Create the vertex buffer
//-----------------------------------------------------------------------------
HRESULT InitGeometry()
{
  HRESULT hr;
  
  // Create the vertex buffer.
  if( FAILED( g_pd3dDevice->CreateVertexBuffer( 6*2*sizeof(CUSTOMVERTEX),
                                                0, D3DFVF_CUSTOMVERTEX,
                                                D3DPOOL_DEFAULT, &g_pVB ) ) )
  {
    return E_FAIL;
  }

  // Fill the vertex buffer. We are setting the tu and tv texture
  // coordinates, which range from 0.0 to 1.0
  CUSTOMVERTEX* pVertices;
  if( FAILED( g_pVB->Lock( 0, 0, (BYTE**)&pVertices, 0 ) ) )
    return E_FAIL;
  
  // first triangle
  pVertices[0].position = D3DXVECTOR3(-2.0f, -2.0f, 0.0f);
  pVertices[0].color    = D3DCOLOR_ARGB(255, 255, 0, 0);
  
  pVertices[1].position = D3DXVECTOR3(2.0f, -2.0f, 0.0f);
  pVertices[1].color    = D3DCOLOR_ARGB(255, 0, 255, 0);
  
  pVertices[2].position = D3DXVECTOR3(2.0f, 2.0f, 0.0f);
  pVertices[2].color    = D3DCOLOR_ARGB(255, 0, 0, 255);
  
  // second triangle
  pVertices[3].position = D3DXVECTOR3(2.0f, 2.0f, 0.0f);
  pVertices[3].color    = D3DCOLOR_ARGB(255, 0, 255, 255);
  
  pVertices[4].position = D3DXVECTOR3(-2.0f, 2.0f, 0.0f);
  pVertices[4].color    = D3DCOLOR_ARGB(255, 255, 255, 0);
  
  pVertices[5].position = D3DXVECTOR3(-2.0f, -2.0f, 0.0f);
  pVertices[5].color    = D3DCOLOR_ARGB(255, 255, 0, 255);
  
  g_pVB->Unlock();

  // Create vertex shader
  {
    LPD3DXBUFFER pCode;

    DWORD dwDecl[] =
    {
      D3DVSD_STREAM(0),
      D3DVSD_REG(D3DVSDE_POSITION,  D3DVSDT_FLOAT3),
			D3DVSD_REG(D3DVSDE_DIFFUSE, 	D3DVSDT_D3DCOLOR),
      D3DVSD_END()
    };

    // Assemble the vertex shader from the file
    // change this to Ch10p1_SimpleShader2.vsh to see vertex diffuse colors
    if( FAILED( hr = D3DXAssembleShaderFromFile( "Ch10p1_SimpleShader1.vsh", 
                                                 0, NULL, &pCode, NULL ) ) )
      return hr;

    // Create the vertex shader
    hr = g_pd3dDevice->CreateVertexShader( dwDecl, 
      (DWORD*)pCode->GetBufferPointer(), &g_dwShader, 0 );
    pCode->Release();
    if( FAILED(hr) ) return hr;
  }

  return S_OK;
}

//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
  if (g_dwShader != 0)       g_pd3dDevice->DeleteVertexShader(g_dwShader);
  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 leave it as the identity
  D3DXMatrixIdentity( &g_matWorld );
  D3DXMatrixRotationYawPitchRoll( &g_matWorld, timeGetTime()/1000.0f, 
    timeGetTime()/700.0f, timeGetTime()/850.0f );
  
  // 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.
  D3DXMatrixLookAtLH( &g_matView, &D3DXVECTOR3( 0.0f, 3.0f,-5.0f ),
                                &D3DXVECTOR3( 0.0f, 0.0f, 0.0f ),
                                &D3DXVECTOR3( 0.0f, 1.0f, 0.0f ) );
  
  // 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). 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).
  D3DXMatrixPerspectiveFovLH( &g_matProj, D3DX_PI/4, 1.0f, 1.0f, 100.0f );
  
}

//-----------------------------------------------------------------------------
// Name: Render()
// Desc: Draws the scene
//-----------------------------------------------------------------------------
VOID Render()
{
   // Setup the world, view, and projection matrices
  SetupMatrices();

  // Clear the backbuffer and the zbuffer
  g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
                       D3DCOLOR_XRGB(0,0,255), 1.0f, 0 );

  // Begin the scene
  g_pd3dDevice->BeginScene();

  g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
  g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE );
  g_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_DISABLE );

  // Render the vertex buffer contents
  g_pd3dDevice->SetStreamSource( 0, g_pVB, sizeof(CUSTOMVERTEX) );
  g_pd3dDevice->SetVertexShader( g_dwShader ); // set our vertex shader active
  
  // Set up the vertex shader constants
  {
    D3DXMATRIX mat;
    D3DXMatrixMultiply( &mat, &g_matWorld, &g_matView );
    D3DXMatrixMultiply( &mat, &mat, &g_matProj );
    D3DXMatrixTranspose( &mat, &mat );

    g_pd3dDevice->SetVertexShaderConstant(0, &mat,  4);

    // plug the diffuse color into constant register 4
    float color[4] = { 1.0f, 1.0f, 0.0f, 1.0f };
    g_pd3dDevice->SetVertexShaderConstant(4, color, 1);
  }
 

  g_pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 2 );

  // 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:
      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,
                    "Ch10p1_SimpleVertexShader", NULL };
  RegisterClassEx( &wc );

  // Create the application's window
  HWND hWnd = CreateWindow( "Ch10p1_SimpleVertexShader", "Ch10p1_SimpleVertexShader",
                            WS_OVERLAPPEDWINDOW, 100, 100, 300, 300,
                            GetDesktopWindow(), 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();
      }
    }
  }

  // Clean up everything and exit the app
  Cleanup();
  UnregisterClass("Ch10p1_SimpleVertexShader", wc.hInstance );
  return 0;
}