#ifndef __d3dUtilityH__
#define __d3dUtilityH__

#include <d3dx9.h>
#include <string>

namespace d3d
{
  bool InitD3D(
   HINSTANCE hInstance,       // [in] Application instance.
   int width, int height,     // [in] Backbuffer dimensions.
   bool windowed,             // [in] Windowed (true)or full screen (false).
   D3DDEVTYPE deviceType,     // [in] HAL or REF
   IDirect3DDevice9** device);// [out]The created device.

  int EnterMsgLoop(  
   bool (*ptr_display)(float timeDelta));

  LRESULT CALLBACK WndProc(
   HWND hwnd,
   UINT msg,  
   WPARAM wParam,
   LPARAM lParam);

  template<class T> void Release(T t)
  {
   if( t )
   {
    t->Release();
    t = 0;
   }
  }
    
  template<class T> void Delete(T t)
  {
   if( t )
   {
    delete t;
    t = 0;
   }
  }

  const D3DXCOLOR      WHITE( D3DCOLOR_XRGB(255, 255, 255) );
  const D3DXCOLOR      BLACK( D3DCOLOR_XRGB(  0,   0,   0) );
  const D3DXCOLOR        RED( D3DCOLOR_XRGB(255,   0,   0) );
  const D3DXCOLOR      GREEN( D3DCOLOR_XRGB(  0, 255,   0) );
  const D3DXCOLOR       BLUE( D3DCOLOR_XRGB(  0,   0, 255) );
  const D3DXCOLOR     YELLOW( D3DCOLOR_XRGB(255, 255,   0) );
  const D3DXCOLOR       CYAN( D3DCOLOR_XRGB(  0, 255, 255) );
  const D3DXCOLOR    MAGENTA( D3DCOLOR_XRGB(255,   0, 255) );

  //
  // Lights
  //

  D3DLIGHT9 InitDirectionalLight(D3DXVECTOR3* direction, D3DXCOLOR* color);
  D3DLIGHT9 InitPointLight(D3DXVECTOR3* position, D3DXCOLOR* color);
  D3DLIGHT9 InitSpotLight(D3DXVECTOR3* position, D3DXVECTOR3* direction, D3DXCOLOR* color);

  //
  // Materials
  //

  D3DMATERIAL9 InitMtrl(D3DXCOLOR a, D3DXCOLOR d, D3DXCOLOR s, D3DXCOLOR e, float p);

  const D3DMATERIAL9 WHITE_MTRL  = InitMtrl(WHITE, WHITE, WHITE, BLACK, 2.0f);
  const D3DMATERIAL9 RED_MTRL    = InitMtrl(RED, RED, RED, BLACK, 2.0f);
  const D3DMATERIAL9 GREEN_MTRL  = InitMtrl(GREEN, GREEN, GREEN, BLACK, 2.0f);
  const D3DMATERIAL9 BLUE_MTRL   = InitMtrl(BLUE, BLUE, BLUE, BLACK, 2.0f);
  const D3DMATERIAL9 YELLOW_MTRL = InitMtrl(YELLOW, YELLOW, YELLOW, BLACK, 2.0f);
}

#endif // __d3dUtilityH__

#include "d3dUtility.h"

bool d3d::InitD3D(
  HINSTANCE hInstance,
  int width, int height,
  bool windowed,
  D3DDEVTYPE deviceType,
  IDirect3DDevice9** device)
{
  //
  // Create the main application window.
  //

  WNDCLASS wc;

  wc.style         = CS_HREDRAW | CS_VREDRAW;
  wc.lpfnWndProc   = (WNDPROC)d3d::WndProc;  
  wc.cbClsExtra    = 0;
  wc.cbWndExtra    = 0;
  wc.hInstance     = hInstance;
  wc.hIcon         = LoadIcon(0, IDI_APPLICATION);
  wc.hCursor       = LoadCursor(0, IDC_ARROW);
  wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
  wc.lpszMenuName  = 0;
  wc.lpszClassName = "Direct3D9App";

  if( !RegisterClass(&wc) )  
  {
   ::MessageBox(0, "RegisterClass() - FAILED", 0, 0);
   return false;
  }
    
  HWND hwnd = 0;
  hwnd = ::CreateWindow("Direct3D9App", "Direct3D9App",  
   WS_EX_TOPMOST,
   0, 0, width, height,
   0 /*parent hwnd*/, 0 /* menu */, hInstance, 0 /*extra*/);  

  if( !hwnd )
  {
   ::MessageBox(0, "CreateWindow() - FAILED", 0, 0);
   return false;
  }

  ::ShowWindow(hwnd, SW_SHOW);
  ::UpdateWindow(hwnd);

  //
  // Init D3D:  
  //

  HRESULT hr = 0;

  // Step 1: Create the IDirect3D9 object.

  IDirect3D9* d3d9 = 0;
     d3d9 = Direct3DCreate9(D3D_SDK_VERSION);

     if( !d3d9 )
  {
   ::MessageBox(0, "Direct3DCreate9() - FAILED", 0, 0);
   return false;
  }

  // Step 2: Check for hardware vp.

  D3DCAPS9 caps;
  d3d9->GetDeviceCaps(D3DADAPTER_DEFAULT, deviceType, &caps);

  int vp = 0;
  if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT )
   vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
  else
   vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;

  // Step 3: Fill out the D3DPRESENT_PARAMETERS structure.
   
  D3DPRESENT_PARAMETERS d3dpp;
  d3dpp.BackBufferWidth            = width;
  d3dpp.BackBufferHeight           = height;
  d3dpp.BackBufferFormat           = D3DFMT_A8R8G8B8;
  d3dpp.BackBufferCount            = 1;
  d3dpp.MultiSampleType            = D3DMULTISAMPLE_NONE;
  d3dpp.MultiSampleQuality         = 0;
  d3dpp.SwapEffect                 = D3DSWAPEFFECT_DISCARD;  
  d3dpp.hDeviceWindow              = hwnd;
  d3dpp.Windowed                   = windowed;
  d3dpp.EnableAutoDepthStencil     = true;  
  d3dpp.AutoDepthStencilFormat     = D3DFMT_D24S8;
  d3dpp.Flags                      = 0;
  d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
  d3dpp.PresentationInterval       = D3DPRESENT_INTERVAL_IMMEDIATE;

  // Step 4: Create the device.

  hr = d3d9->CreateDevice(
   D3DADAPTER_DEFAULT, // primary adapter
   deviceType,         // device type
   hwnd,               // window associated with device
   vp,                 // vertex processing
      &d3dpp,             // present parameters
      device);            // return created device

  if( FAILED(hr) )
  {
   // try again using a 16-bit depth buffer
   d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
    
   hr = d3d9->CreateDevice(
    D3DADAPTER_DEFAULT,
    deviceType,
    hwnd,
    vp,
    &d3dpp,
    device);

   if( FAILED(hr) )
   {
    d3d9->Release(); // done with d3d9 object
    ::MessageBox(0, "CreateDevice() - FAILED", 0, 0);
    return false;
   }
  }

  d3d9->Release(); // done with d3d9 object
   
  return true;
}

int d3d::EnterMsgLoop( bool (*ptr_display)(float timeDelta) )
{
  MSG msg;
  ::ZeroMemory(&msg, sizeof(MSG));

  static float lastTime = (float)timeGetTime();  

  while(msg.message != WM_QUIT)
  {
   if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
   {
    ::TranslateMessage(&msg);
    ::DispatchMessage(&msg);
   }
   else
         {  
    float currTime  = (float)timeGetTime();
    float timeDelta = (currTime - lastTime)*0.001f;

    ptr_display(timeDelta);

    lastTime = currTime;
         }
     }
     return msg.wParam;
}

D3DLIGHT9 d3d::InitDirectionalLight(D3DXVECTOR3* direction, D3DXCOLOR* color)
{
  D3DLIGHT9 light;
  ::ZeroMemory(&light, sizeof(light));

  light.Type      = D3DLIGHT_DIRECTIONAL;
  light.Ambient   = *color * 0.4f;
  light.Diffuse   = *color;
  light.Specular  = *color * 0.6f;
  light.Direction = *direction;

  return light;
}

D3DLIGHT9 d3d::InitPointLight(D3DXVECTOR3* position, D3DXCOLOR* color)
{
  D3DLIGHT9 light;
  ::ZeroMemory(&light, sizeof(light));

  light.Type      = D3DLIGHT_POINT;
  light.Ambient   = *color * 0.4f;
  light.Diffuse   = *color;
  light.Specular  = *color * 0.6f;
  light.Position  = *position;
  light.Range        = 1000.0f;
  light.Falloff      = 1.0f;
  light.Attenuation0 = 1.0f;
  light.Attenuation1 = 0.0f;
  light.Attenuation2 = 0.0f;

  return light;
}

D3DLIGHT9 d3d::InitSpotLight(D3DXVECTOR3* position, D3DXVECTOR3* direction, D3DXCOLOR* color)
{
  D3DLIGHT9 light;
  ::ZeroMemory(&light, sizeof(light));

  light.Type      = D3DLIGHT_SPOT;
  light.Ambient   = *color * 0.4f;
  light.Diffuse   = *color;
  light.Specular  = *color * 0.6f;
  light.Position  = *position;
  light.Direction = *direction;
  light.Range        = 1000.0f;
  light.Falloff      = 1.0f;
  light.Attenuation0 = 1.0f;
  light.Attenuation1 = 0.0f;
  light.Attenuation2 = 0.0f;
  light.Theta        = 0.5f;
  light.Phi          = 0.7f;

  return light;
}

D3DMATERIAL9 d3d::InitMtrl(D3DXCOLOR a, D3DXCOLOR d, D3DXCOLOR s, D3DXCOLOR e, float p)
{
  D3DMATERIAL9 mtrl;
  mtrl.Ambient  = a;
  mtrl.Diffuse  = d;
  mtrl.Specular = s;
  mtrl.Emissive = e;
  mtrl.Power    = p;
  return mtrl;
}

#include "d3dUtility.h"
#include <fstream>
#include <vector>

#pragma comment(lib, "d3dx9.lib")

//
// Globals
//

IDirect3DDevice9* Device = 0;  

const int Width  = 640;
const int Height = 480;

ID3DXMesh*         Mesh = 0;
const DWORD        NumSubsets = 3;
IDirect3DTexture9* Textures[3] = {0, 0, 0};// texture for each subset

std::ofstream OutFile; // used to dump mesh data to file

//
// Prototypes
//

void dumpVertices(std::ofstream& outFile, ID3DXMesh* mesh);
void dumpIndices(std::ofstream& outFile, ID3DXMesh* mesh);
void dumpAttributeBuffer(std::ofstream& outFile, ID3DXMesh* mesh);
void dumpAdjacencyBuffer(std::ofstream& outFile, ID3DXMesh* mesh);
void dumpAttributeTable(std::ofstream& outFile, ID3DXMesh* mesh);

//
// Classes and Structures
//
struct Vertex
{
  Vertex(){}
  Vertex(float x, float y, float z,  
   float nx, float ny, float nz, float u, float v)
  {
    _x = x;   _y = y;   _z = z;
   _nx = nx; _ny = ny; _nz = nz;
    _u = u;   _v = v;
  }

  float _x, _y, _z, _nx, _ny, _nz, _u, _v;

  static const DWORD FVF;
};
const DWORD Vertex::FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1;

//
// Framework functions
//
bool Setup()
{
  HRESULT hr = 0;

  //
  // We are going to fill the empty mesh with the geometry of a box,
  // so we need 12 triangles and 24 vetices.
  //

  hr = D3DXCreateMeshFVF(
   12,
   24,
   D3DXMESH_MANAGED,
   Vertex::FVF,
   Device,
   &Mesh);

  if(FAILED(hr))
  {
   ::MessageBox(0, "D3DXCreateMeshFVF() - FAILED", 0, 0);
   return false;
  }

  //
  // Fill in vertices of a box
  //
  Vertex* v = 0;
  Mesh->LockVertexBuffer(0, (void**)&v);

  // fill in the front face vertex data
  v[0] = Vertex(-1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
  v[1] = Vertex(-1.0f,  1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
  v[2] = Vertex( 1.0f,  1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);
  v[3] = Vertex( 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);

  // fill in the back face vertex data
  v[4] = Vertex(-1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
  v[5] = Vertex( 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f);
  v[6] = Vertex( 1.0f,  1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);
  v[7] = Vertex(-1.0f,  1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f);

  // fill in the top face vertex data
  v[8]  = Vertex(-1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f);
  v[9]  = Vertex(-1.0f, 1.0f,  1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f);
  v[10] = Vertex( 1.0f, 1.0f,  1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f);
  v[11] = Vertex( 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);

  // fill in the bottom face vertex data
  v[12] = Vertex(-1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f);
  v[13] = Vertex( 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f);
  v[14] = Vertex( 1.0f, -1.0f,  1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f);
  v[15] = Vertex(-1.0f, -1.0f,  1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f);

  // fill in the left face vertex data
  v[16] = Vertex(-1.0f, -1.0f,  1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
  v[17] = Vertex(-1.0f,  1.0f,  1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
  v[18] = Vertex(-1.0f,  1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
  v[19] = Vertex(-1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);

  // fill in the right face vertex data
  v[20] = Vertex( 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
  v[21] = Vertex( 1.0f,  1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
  v[22] = Vertex( 1.0f,  1.0f,  1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
  v[23] = Vertex( 1.0f, -1.0f,  1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f);

  Mesh->UnlockVertexBuffer();

  //
  // Define the triangles of the box
  //
  WORD* i = 0;
  Mesh->LockIndexBuffer(0, (void**)&i);

  // fill in the front face index data
  i[0] = 0; i[1] = 1; i[2] = 2;
  i[3] = 0; i[4] = 2; i[5] = 3;

  // fill in the back face index data
  i[6] = 4; i[7]  = 5; i[8]  = 6;
  i[9] = 4; i[10] = 6; i[11] = 7;

  // fill in the top face index data
  i[12] = 8; i[13] =  9; i[14] = 10;
  i[15] = 8; i[16] = 10; i[17] = 11;

  // fill in the bottom face index data
  i[18] = 12; i[19] = 13; i[20] = 14;
  i[21] = 12; i[22] = 14; i[23] = 15;

  // fill in the left face index data
  i[24] = 16; i[25] = 17; i[26] = 18;
  i[27] = 16; i[28] = 18; i[29] = 19;

  // fill in the right face index data
  i[30] = 20; i[31] = 21; i[32] = 22;
  i[33] = 20; i[34] = 22; i[35] = 23;

  Mesh->UnlockIndexBuffer();

  //
  // Specify the subset each triangle belongs to, in this example
  // we will use three subsets, the first two faces of the cube specified
  // will be in subset 0, the next two faces will be in subset 1 and
  // the the last two faces will be in subset 2.
  //
  DWORD* attributeBuffer = 0;
  Mesh->LockAttributeBuffer(0, &attributeBuffer);

  for(int a = 0; a < 4; a++)
   attributeBuffer[a] = 0;

  for(int b = 4; b < 8; b++)
   attributeBuffer[b] = 1;

  for(int c = 8; c < 12; c++)
   attributeBuffer[c] = 2;

  Mesh->UnlockAttributeBuffer();

  //
  // Optimize the mesh to generate an attribute table.
  //

  std::vector<DWORD> adjacencyBuffer(Mesh->GetNumFaces() * 3);
  Mesh->GenerateAdjacency(0.0f, &adjacencyBuffer[0]);

  hr = Mesh->OptimizeInplace(   
   D3DXMESHOPT_ATTRSORT |
   D3DXMESHOPT_COMPACT  |
   D3DXMESHOPT_VERTEXCACHE,
   &adjacencyBuffer[0],
   0, 0, 0);

  //
  // Dump the Mesh Data to file.
  //

  OutFile.open("Mesh Dump.txt");

  dumpVertices(OutFile, Mesh);
  dumpIndices(OutFile, Mesh);
  dumpAttributeTable(OutFile, Mesh);   
  dumpAttributeBuffer(OutFile, Mesh);   
  dumpAdjacencyBuffer(OutFile, Mesh);
   
  OutFile.close();

  //
  // Load the textures and set filters.
  //

  D3DXCreateTextureFromFile(
   Device,
   "brick0.jpg",
   &Textures[0]);

  D3DXCreateTextureFromFile(
   Device,
   "brick1.jpg",
   &Textures[1]);

  D3DXCreateTextureFromFile(
   Device,
   "checker.jpg",
   &Textures[2]);

  Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
  Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
  Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);

  //  
  // Disable lighting.
  //

  Device->SetRenderState(D3DRS_LIGHTING, false);

  //
  // Set camera.
  //

  D3DXVECTOR3 pos(0.0f, 0.f, -4.0f);
  D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
  D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);

  D3DXMATRIX V;
  D3DXMatrixLookAtLH(
   &V,
   &pos,
   &target,
   &up);

  Device->SetTransform(D3DTS_VIEW, &V);

  //
  // Set projection matrix.
  //

  D3DXMATRIX proj;
  D3DXMatrixPerspectiveFovLH(
    &proj,
    D3DX_PI * 0.5f, // 90 - degree
    (float)Width / (float)Height,
    1.0f,
    1000.0f);
  Device->SetTransform(D3DTS_PROJECTION, &proj);

  return true;
}

void Cleanup()
{
  d3d::Release<ID3DXMesh*>(Mesh);
  d3d::Release<IDirect3DTexture9*>(Textures[0]);
  d3d::Release<IDirect3DTexture9*>(Textures[1]);
  d3d::Release<IDirect3DTexture9*>(Textures[2]);
}

bool Display(float timeDelta)
{
  if( Device )
  {
   //
   // Update: Rotate the cube.
   //

   D3DXMATRIX xRot;
   D3DXMatrixRotationX(&xRot, D3DX_PI * 0.2f);

   static float y = 0.0f;
   D3DXMATRIX yRot;
   D3DXMatrixRotationY(&yRot, y);
   y += timeDelta;

   if( y >= 6.28f )
    y = 0.0f;

   D3DXMATRIX World = xRot * yRot;

   Device->SetTransform(D3DTS_WORLD, &World);

   //
   // Render
   //

   Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0);
   Device->BeginScene();

   for(int i = 0; i < NumSubsets; i++)
   {
    Device->SetTexture( 0, Textures[i] );
    Mesh->DrawSubset( i );
   }

   Device->EndScene();
   Device->Present(0, 0, 0, 0);
  }
  return true;
}

//
// WndProc
//
LRESULT CALLBACK d3d::WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
  switch( msg )
  {
  case WM_DESTROY:
   ::PostQuitMessage(0);
   break;
    
  case WM_KEYDOWN:
   if( wParam == VK_ESCAPE )
    ::DestroyWindow(hwnd);
   break;
  }
  return ::DefWindowProc(hwnd, msg, wParam, lParam);
}

//
// WinMain
//
int WINAPI WinMain(HINSTANCE hinstance,
        HINSTANCE prevInstance,  
        PSTR cmdLine,
        int showCmd)
{
  if(!d3d::InitD3D(hinstance,
   Width, Height, true, D3DDEVTYPE_HAL, &Device))
  {
   ::MessageBox(0, "InitD3D() - FAILED", 0, 0);
   return 0;
  }
    
  if(!Setup())
  {
   ::MessageBox(0, "Setup() - FAILED", 0, 0);
   return 0;
  }

  d3d::EnterMsgLoop( Display );

  Cleanup();

  Device->Release();

  return 0;
}

//
// Prototype Implementations
//

void dumpVertices(std::ofstream& outFile, ID3DXMesh* mesh)
{
  outFile << "Vertices:" << std::endl;
  outFile << "---------" << std::endl << std::endl;

  Vertex* v = 0;
  mesh->LockVertexBuffer(0, (void**)&v);
  for(int i = 0; i < mesh->GetNumVertices(); i++)
  {
   outFile << "Vertex " << i << ": (";
   outFile << v[i]._x  << ", " << v[i]._y  << ", " << v[i]._z  << ", ";
   outFile << v[i]._nx << ", " << v[i]._ny << ", " << v[i]._nz << ", ";
   outFile << v[i]._u  << ", " << v[i]._v  << ")"  << std::endl;
  }
  mesh->UnlockVertexBuffer();

  outFile << std::endl << std::endl;
}

void dumpIndices(std::ofstream& outFile, ID3DXMesh* mesh)
{
  outFile << "Indices:" << std::endl;
  outFile << "--------" << std::endl << std::endl;

  WORD* indices = 0;
  mesh->LockIndexBuffer(0, (void**)&indices);

  for(int i = 0; i < mesh->GetNumFaces(); i++)
  {
   outFile << "Triangle " << i << ": ";
   outFile << indices[i * 3    ] << " ";
   outFile << indices[i * 3 + 1] << " ";
   outFile << indices[i * 3 + 2] << std::endl;
  }
  mesh->UnlockIndexBuffer();

  outFile << std::endl << std::endl;
}

void dumpAttributeBuffer(std::ofstream& outFile, ID3DXMesh* mesh)
{
  outFile << "Attribute Buffer:" << std::endl;
  outFile << "-----------------" << std::endl << std::endl;

  DWORD* attributeBuffer = 0;
  mesh->LockAttributeBuffer(0, &attributeBuffer);

  // an attribute for each face
  for(int i = 0; i < mesh->GetNumFaces(); i++)
  {
   outFile << "Triangle lives in subset " << i << ": ";
   outFile << attributeBuffer[i] << std::endl;
  }
  mesh->UnlockAttributeBuffer();

  outFile << std::endl << std::endl;
}

void dumpAdjacencyBuffer(std::ofstream& outFile, ID3DXMesh* mesh)
{
  outFile << "Adjacency Buffer:" << std::endl;
  outFile << "-----------------" << std::endl << std::endl;

  // three enttries per face
  std::vector<DWORD> adjacencyBuffer(mesh->GetNumFaces() * 3);

  mesh->GenerateAdjacency(0.0f, &adjacencyBuffer[0]);

  for(int i = 0; i < mesh->GetNumFaces(); i++)
  {
   outFile << "Triangle's adjacent to triangle " << i << ": ";
   outFile << adjacencyBuffer[i * 3    ] << " ";
   outFile << adjacencyBuffer[i * 3 + 1] << " ";
   outFile << adjacencyBuffer[i * 3 + 2] << std::endl;
  }

  outFile << std::endl << std::endl;
}

void dumpAttributeTable(std::ofstream& outFile, ID3DXMesh* mesh)
{
  outFile << "Attribute Table:" << std::endl;
  outFile << "----------------" << std::endl << std::endl;  

  // number of entries in the attribute table
  DWORD numEntries = 0;

  mesh->GetAttributeTable(0, &numEntries);

  std::vector<D3DXATTRIBUTERANGE> table(numEntries);

  mesh->GetAttributeTable(&table[0], &numEntries);

  for(int i = 0; i < numEntries; i++)
  {
   outFile << "Entry " << i << std::endl;
   outFile << "-----------" << std::endl;

   outFile << "Subset ID:    " << table[i].AttribId    << std::endl;
   outFile << "Face Start:   " << table[i].FaceStart   << std::endl;
   outFile << "Face Count:   " << table[i].FaceCount   << std::endl;
   outFile << "Vertex Start: " << table[i].VertexStart << std::endl;
   outFile << "Vertex Count: " << table[i].VertexCount << std::endl;
   outFile << std::endl;
  }

  outFile << std::endl << std::endl;
}