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

  Ch10p3_PixelShader.cpp: a program that demonstrates how to create and
  use pixel shaders in DirectX 8.0.

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

// 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
LPDIRECT3DTEXTURE8      g_pTexture   = NULL; // Our texture

DWORD                   g_dwVertexShader = 0;
DWORD                   g_dwPixelShader  = 0;

D3DXMATRIX g_matProj;
D3DXMATRIX g_matView;
D3DXMATRIX g_matWorld;

// A structure for our custom vertex type. We added texture coordinates
struct CUSTOMVERTEX
{
  D3DXVECTOR3 position; // The position
  D3DXVECTOR3 norm;     // normal
  D3DCOLOR    color;    // The color
  FLOAT       tu, tv;   // The texture coordinates
};

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

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

  // go for reference device
  if( FAILED( g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, 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 textures and vertex buffers
//-----------------------------------------------------------------------------
HRESULT InitGeometry()
{
  HRESULT hr;
  // Use D3DX to create a texture from a file based image
  if( FAILED( D3DXCreateTextureFromFile( g_pd3dDevice, "Ch10p3_brick.bmp",
                                         &g_pTexture ) ) )
    return E_FAIL;

  // 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].norm     = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
  pVertices[0].color    = D3DCOLOR_ARGB(255, 255, 0, 0);
  pVertices[0].tu       = 0.0f;
  pVertices[0].tv       = 0.0f;

  pVertices[1].position = D3DXVECTOR3(2.0f, -2.0f, 0.0f);
  pVertices[1].norm     = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
  pVertices[1].color    = D3DCOLOR_ARGB(255, 0, 255, 0);
  pVertices[1].tu       = 1.0f;
  pVertices[1].tv       = 0.0f;

  pVertices[2].position = D3DXVECTOR3(2.0f, 2.0f, 0.0f);
  pVertices[2].norm     = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
  pVertices[2].color    = D3DCOLOR_ARGB(255, 0, 0, 255);
  pVertices[2].tu       = 1.0f;
  pVertices[2].tv       = 1.0f;

  // second triangle
  pVertices[3].position = D3DXVECTOR3(2.0f, 2.0f, 0.0f);
  pVertices[3].norm     = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
  pVertices[3].color    = D3DCOLOR_ARGB(255, 0, 255, 255);
  pVertices[3].tu       = 1.0f;
  pVertices[3].tv       = 1.0f;

  pVertices[4].position = D3DXVECTOR3(-2.0f, 2.0f, 0.0f);
  pVertices[4].norm     = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
  pVertices[4].color    = D3DCOLOR_ARGB(255, 255, 255, 0);
  pVertices[4].tu       = 0.0f;
  pVertices[4].tv       = 1.0f;

  pVertices[5].position = D3DXVECTOR3(-2.0f, -2.0f, 0.0f);
  pVertices[5].norm     = D3DXVECTOR3(0.0f, 0.0f, 1.0f);
  pVertices[5].color    = D3DCOLOR_ARGB(255, 255, 0, 255);
  pVertices[5].tu       = 0.0f;
  pVertices[5].tv       = 0.0f;

  g_pVB->Unlock();

  // Create vertex shader
  {
    LPD3DXBUFFER pCode;

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

    // Assemble the vertex shader from the file
    if( FAILED( hr = D3DXAssembleShaderFromFile( "Ch10p3_VertexShader.vsh", 
                                                 0, NULL, &pCode, NULL ) ) )
      return hr;

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

    // Assemble the pixel shader from the file
    if( FAILED( hr = D3DXAssembleShaderFromFile( "Ch10p3_PixelShader.psh", 
      0, NULL, &pCode, NULL ) ) )
      return hr;
    
    
    // Create the pixel shader
    hr = g_pd3dDevice->CreatePixelShader((DWORD*)pCode->GetBufferPointer(), 
      &g_dwPixelShader);
    pCode->Release();
    if( FAILED(hr) ) return hr;
  }

  return S_OK;
}

//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
  if (g_dwVertexShader != 0)      g_pd3dDevice->DeleteVertexShader(g_dwVertexShader);
  if (g_dwPixelShader != 0)       g_pd3dDevice->DeletePixelShader(g_dwPixelShader);

  if( g_pTexture != NULL )   g_pTexture->Release();
  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();

  // Setup our texture. Using textures introduces the texture stage states,
  // which govern how textures get blended together (in the case of multiple
  // textures) and lighting information. In this case, we are modulating
  // (blending) our texture with the diffuse color of the vertices.
  g_pd3dDevice->SetTexture( 0, g_pTexture );
  
  g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_MODULATE );
  g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
  g_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_TEXTURE );
  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_dwVertexShader); // set our vertex shader active
  g_pd3dDevice->SetPixelShader(g_dwPixelShader);
  
  // Set up the vertex shader constants
  {
    D3DXMATRIX mat, matinv;
    D3DXMatrixMultiply( &mat, &g_matWorld, &g_matView );
    D3DXMatrixMultiply( &mat, &mat, &g_matProj );
    D3DXMatrixTranspose( &mat, &mat );

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

    // set up the light
		D3DXMatrixInverse(&matinv, NULL, &g_matWorld);
    D3DXVECTOR3 vLight(0.0f, 0.0f, 1.0f);
		D3DXVec3TransformNormal(&vLight, &vLight, &matinv);
		D3DXVec3Normalize((D3DXVECTOR3*)&vLight, (D3DXVECTOR3*)&vLight);
		vLight = -vLight;

		g_pd3dDevice->SetVertexShaderConstant(4, &vLight, 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,
                    "Ch10p3_PixelShader", NULL };
  RegisterClassEx( &wc );

  // Create the application's window
  HWND hWnd = CreateWindow( "Ch10p3_PixelShader", "Ch10p3_PixelShader",
                            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("Ch10p3_PixelShader", wc.hInstance );
  return 0;
}