fixedfuncshader.cpp

activate your member account after checking your files. If

      if(FAILED(ReleaseDiff()))
      {
         return E_FAIL;
      }
   }

   return S_OK;
}

//-----------------------------------------------------------------------------
// Name: DeleteDeviceObjects()
// Desc: Called when the app is exiting, or the device is being changed,
//       this function deletes any device dependent objects.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::DeleteDeviceObjects()
{
   SAFE_RELEASE(m_pVertexDeclaration);
   SAFE_RELEASE(m_pVertexDeclarationTween);
   SAFE_RELEASE(m_pMeshVB);
   SAFE_RELEASE(m_pMesh2VB);
   SAFE_RELEASE(m_pMeshIB);

   SAFE_RELEASE(m_pEffect);

   m_pFont->DeleteDeviceObjects();
   m_pFontSmall->DeleteDeviceObjects();
   m_pObject->Destroy();
   m_pObject2->Destroy();

   return S_OK;
}

//-----------------------------------------------------------------------------
// Name: FinalCleanup()
// Desc: Called before the app exits, this function gives the app the chance
//       to cleanup after itself.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::FinalCleanup()
{
   SAFE_DELETE(m_pFont);
   SAFE_DELETE(m_pFontSmall);
   SAFE_DELETE(m_pObject);

   return S_OK;
}

//-----------------------------------------------------------------------------
// Name: ConfirmDevice()
// Desc: Called during device initialization, this code checks the device
//       for some minimum set of capabilities
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::ConfirmDevice(D3DCAPS9* pCaps, DWORD dwBehavior,
                                          D3DFORMAT adapterFormat, D3DFORMAT backBufferFormat)
{
   if(dwBehavior & D3DCREATE_PUREDEVICE)
   {
      return E_FAIL;
   }

   // If this is a TnL device, make sure it supports lights/tweening/texgen lights
   if((dwBehavior & D3DCREATE_HARDWARE_VERTEXPROCESSING) ||
      (dwBehavior & D3DCREATE_MIXED_VERTEXPROCESSING))
   {
      if(!(pCaps->VertexProcessingCaps & D3DVTXPCAPS_DIRECTIONALLIGHTS))
      {
         return E_FAIL;
      }
      if(!(pCaps->VertexProcessingCaps & D3DVTXPCAPS_POSITIONALLIGHTS))
      {
         return E_FAIL;
      }
      if(!(pCaps->VertexProcessingCaps & D3DVTXPCAPS_TWEENING))
      {
         return E_FAIL;
      }
      if(!(pCaps->VertexProcessingCaps & D3DVTXPCAPS_TEXGEN))
      {
         return E_FAIL;
      }
   }
    // Check for cubemapping devices
   if( 0 == ( pCaps->TextureCaps & D3DPTEXTURECAPS_CUBEMAP ) )
   {
      return E_FAIL;
   }

   if( pCaps->VertexShaderVersion < D3DVS_VERSION(2,0) )
   {
      return E_FAIL;
   }
   if( pCaps->PixelShaderVersion < D3DVS_VERSION(2,0) )
   {
      return E_FAIL;
   }
   return S_OK;
}

//-----------------------------------------------------------------------------
// Name: MsgProc()
// Desc: Overrrides the main WndProc, so the sample can do custom message
//       handling (e.g. processing mouse, keyboard, or menu commands).
//-----------------------------------------------------------------------------
LRESULT CMyD3DApplication::MsgProc(HWND hWnd, UINT msg, WPARAM wParam,
                                    LPARAM lParam)
{
   if(m_ArcBall.HandleMessages(hWnd, msg, wParam, lParam))
   {
      // process arcball
      D3DXMatrixInverse(&m_matArcBall, NULL, &m_matViewTrans);
      D3DXMatrixMultiply(&m_matArcBall, &m_matArcBall, m_ArcBall.GetRotationMatrix());
      D3DXMatrixMultiply(&m_matArcBall, &m_matArcBall, m_ArcBall.GetTranslationMatrix());
      D3DXMatrixMultiply(&m_matArcBall, &m_matArcBall, &m_matViewTrans);
   
      // recompute view matrix
      D3DXMatrixMultiply(&m_matView, &m_matViewRot, &m_matViewTrans);
      D3DXMatrixMultiply(&m_matView, &m_matView, &m_matArcBall);
      m_pd3dDevice->SetTransform(D3DTS_VIEW, &m_matView);
      return CD3DApplication::MsgProc(hWnd, msg, wParam, lParam);
   }

   bool bChangeFast = false;
   bool bReInitAll = false;
   switch(msg)
   {
      case WM_COMMAND:
         switch(LOWORD(wParam))
         {
            case IDM_TOGGLED3DX:
               m_bUseD3DX = !m_bUseD3DX;
               break;
            case IDM_PROGRAMMABLE:
               m_Mode = FFS_MODE_SHADER;
               break;
            case IDM_FIXED:
               m_Mode = FFS_MODE_FIXED;
               break;
            case IDM_BOTH:
               m_Mode = FFS_MODE_BOTH;
               break;
            case IDM_DIFF:
               m_Mode = FFS_MODE_DIFF;
               if(!m_bDiffInit)
               {
                  InitDiff();
               }
               break;
            case IDM_LOADMESH:
            {
               TCHAR g_strFilename[512]   = _T("");
               // Display the OpenFileName dialog. Then, try to load the specified file
               SetCurrentDirectory(m_strMeshInitialDir);
               OPENFILENAME ofn = { sizeof(OPENFILENAME), NULL, NULL,
                                _T(".X Files (.x)\0*.x\0\0"), 
                                NULL, 0, 1, m_strMeshFilename, 512, g_strFilename, 512, 
                                m_strMeshInitialDir, _T("Open Mesh File"), 
                                OFN_FILEMUSTEXIST, 0, 1, NULL, 0, NULL, NULL };

               if(GetOpenFileName(&ofn) == TRUE)
               {
                  _tcscpy(m_strMeshInitialDir, m_strMeshFilename);
                  TCHAR* pLastSlash =  _tcsrchr(m_strMeshInitialDir, _T('\\'));
                  if(pLastSlash)
                  {
                     *pLastSlash = 0;
                  }
                  SetCurrentDirectory(m_strAppDir);

                  // Destroy and recreate everything
                  bReInitAll = true;

                  m_ArcBall.Reset(); //must reset arcball since loading new mesh
               }
               break;
            }
            case IDM_LOADSTATEFULL:
            {
               TCHAR strFilename[512]   = _T("");
               // Display the OpenFileName dialog. Then, try to load the specified file
               SetCurrentDirectory(m_strStateInitialDir);
               OPENFILENAME ofn = { sizeof(OPENFILENAME), NULL, NULL,
                                _T(".S Files (.s)\0*.s\0\0"), 
                                NULL, 0, 1, m_strStateFilename, 512, strFilename, 512, 
                                m_strStateInitialDir, _T("Open State File"), 
                                OFN_FILEMUSTEXIST, 0, 1, NULL, 0, NULL, NULL };

               if(GetOpenFileName(&ofn) == TRUE)
               {
                  _tcscpy(m_strStateInitialDir, m_strStateFilename);
                  TCHAR* pLastSlash =  _tcsrchr(m_strStateInitialDir, _T('\\'));
                  if(pLastSlash)
                  {
                     *pLastSlash = 0;
                  }

                  SetCurrentDirectory(m_strAppDir);

                  LoadFullState();
               }
               break;
            }
            case IDM_LOADSTATE:
            {
               TCHAR strFilename[512]   = _T("");
               // Display the OpenFileName dialog. Then, try to load the specified file
               SetCurrentDirectory(m_strStateInitialDir);
               OPENFILENAME ofn = { sizeof(OPENFILENAME), NULL, NULL,
                                _T(".S Files (.s)\0*.s\0\0"), 
                                NULL, 0, 1, m_strStateFilename, 512, strFilename, 512, 
                                m_strStateInitialDir, _T("Open State File"), 
                                OFN_FILEMUSTEXIST, 0, 1, NULL, 0, NULL, NULL };

               if(GetOpenFileName(&ofn) == TRUE)
               {
                  _tcscpy(m_strStateInitialDir, m_strStateFilename);
                  TCHAR* pLastSlash =  _tcsrchr(m_strStateInitialDir, _T('\\'));
                  if(pLastSlash)
                  {
                     *pLastSlash = 0;
                  }

                  SetCurrentDirectory(m_strAppDir);
                    
                  LoadState();
               }
               break;
            }
            case IDM_SAVESTATE:
            {
               TCHAR strFilename[512]   = _T("");
               // Display the SaveFileName dialog. Then, try to save the specified file
               SetCurrentDirectory(m_strStateInitialDir);
               OPENFILENAME ofn = { sizeof(OPENFILENAME), NULL, NULL,
                                _T(".S Files (.s)\0*.s\0\0"), 
                                NULL, 0, 1, m_strStateFilename, 512, strFilename, 512, 
                                m_strStateInitialDir, _T("Save State File"), 
                                OFN_FILEMUSTEXIST, 0, 1, NULL, 0, NULL, NULL };

               if(GetSaveFileName(&ofn) == TRUE)
               {
                  _tcscpy(m_strStateInitialDir, m_strStateFilename);
                  TCHAR* pLastSlash =  _tcsrchr(m_strStateInitialDir, _T('\\'));
                  if(pLastSlash)
                  {
                     *pLastSlash = 0;
                  }

                  SetCurrentDirectory(m_strAppDir);

                  SaveState();
               }
               break;
            }
            case IDM_REFRESH_EFFECTS:
            {
               LPD3DXEFFECT pDummyEffect;
               LPD3DXBUFFER pBufferErrors = NULL;
               HRESULT hr;

               //recompile effect. If it fails, keep the old one
               hr = D3DXCreateEffectFromFile(m_pd3dDevice, "Effects\\FixedFuncShader.fx", 
	                     NULL, NULL, D3DXSHADER_DEBUG, NULL, &pDummyEffect, &pBufferErrors);

               if(FAILED(hr))
               {
                  MessageBox(m_hWnd, "Effects failed to compile.", "Error", MB_ICONERROR);
               }
               else
               {
                  SAFE_RELEASE(m_pEffect);
                  m_pEffect = pDummyEffect;
               }
               break;
            }
            case IDM_NEXT_PARAMETER:
               m_iCurParam = (m_iCurParam + 1) % NUM_PARAMETERS;
               break;
            case IDM_PREVIOUS_PARAMETER:
               m_iCurParam = (m_iCurParam - 1 + NUM_PARAMETERS) % NUM_PARAMETERS;
               break;
            case IDM_INCREASE_CURRENT_PARAMETER_FAST:
               bChangeFast = true;
            case IDM_INCREASE_CURRENT_PARAMETER:
                  m_scenestate.Change(m_iCurParam, m_iCurParamLight, 1, bChangeFast, m_hWnd, &bReInitAll);
               break;
            case IDM_DECREASE_CURRENT_PARAMETER_FAST:
               bChangeFast = true;
            case IDM_DECREASE_CURRENT_PARAMETER:
                  m_scenestate.Change(m_iCurParam, m_iCurParamLight, -1, bChangeFast, m_hWnd, &bReInitAll);
               break;
            case IDM_DIFF_SENSITIVE:
               m_bDiffSensitivity = !m_bDiffSensitivity;
               m_pEffect->SetBool("bDiffSensitivity", m_bDiffSensitivity);
               break;
            case IDM_SHOWTEXT:
               m_bShowSettingsText = !m_bShowSettingsText;
               break;
         }
         m_scenestate.Set(m_pd3dDevice, m_pEffect);
         if(bReInitAll)
         {
            InvalidateDeviceObjects();
            DeleteDeviceObjects();
            InitDeviceObjects();
            RestoreDeviceObjects();
         }
         break;
   }
   if(m_Mode != FFS_MODE_DIFF && m_bDiffInit)
   {
      ReleaseDiff();
   }
   return CD3DApplication::MsgProc(hWnd, msg, wParam, lParam);
}


//-----------------------------------------------------------------------------
// Name: LoadState()
// Desc: Load state from disk
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::LoadState()
{
   FILE *fp = fopen(m_strStateFilename, "rb");
   if(fp == NULL)
   {
      MessageBox(m_hWnd, "File not found", "Error", MB_ICONERROR);
      return E_FAIL;
   }
   m_scenestate.InitFromFile(fp, false);
   fclose(fp);
   m_scenestate.Set(m_pd3dDevice, m_pEffect);
   return S_OK;
}

//-----------------------------------------------------------------------------
// Name: LoadFullState()
// Desc: Load state w/ mesh from disk
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::LoadFullState()
{
   D3DXMATRIXA16 matView;
   D3DXMATRIXA16 matViewTrans;
   D3DXMATRIXA16 matViewRot;
   D3DXMATRIXA16 matWorld;
   D3DXMATRIXA16 matProj;
   D3DXMATRIXA16 matArcBall;
   FILE *fp = fopen(m_strStateFilename, "rb");
   if(fp == NULL)
   {
      MessageBox(m_hWnd, "File not found", "Error", MB_ICONERROR);
      return E_FAIL;
   }
   m_scenestate.InitFromFile(fp, true, &matWorld, &matView, &matProj, 
      &matViewTrans, &matViewRot, &m_ArcBall, &m_fTime, m_strMeshFilename);
   fclose(fp);
   m_scenestate.Set(m_pd3dDevice, m_pEffect);
   InvalidateDeviceObjects();
   DeleteDeviceObjects();
   InitDeviceObjects();
   RestoreDeviceObjects();
   m_matView = matView;
   m_matViewTrans = matViewTrans;
   m_matViewRot = matViewRot;
   m_matWorld = matWorld;
   m_matProj = matProj;
   m_pd3dDevice->SetTransform(D3DTS_WORLD, &m_matWorld);
   m_pd3dDevice->SetTransform(D3DTS_PROJECTION, &m_matProj);
   m_pd3dDevice->SetTransform(D3DTS_VIEW, &m_matView);
   m_fTimeOld = -1.f;
   if(m_bFrameMoving == true)
   {
      m_bFrameMoving = false;
      DXUtil_Timer(TIMER_STOP);
   }
   return S_OK;
}

//-----------------------------------------------------------------------------
// Name: SaveState()
// Desc: Save state to disk
//-----------------------------------------------------------------------------
void CMyD3DApplication::SaveState()
{
   FILE *fp = fopen(m_strStateFilename, "wb");
   m_scenestate.SaveToFile(fp, &m_matWorld, &m_matView, &m_matProj, 
      &m_matViewTrans, &m_matViewRot, &m_ArcBall, &m_fTime, m_strMeshFilename);
   fclose(fp);
}



//-----------------------------------------------------------------------------
// Name: RenderQuad()
// Desc: Simple global function to render quads
//-----------------------------------------------------------------------------
void RenderQuad(LPDIRECT3DDEVICE9 pd3dDevice, float x0, float y0, float x1, float y1, D3DCOLOR c)
{
   D3DVERTEX QuadVerts[] =
   {
      { 0,0,0, 0,0,0, 0xFFFFFFFF, 0.f, 0.f}, //px, py, pz, nx, ny, nz, col, tu, tv
      { 0,0,0, 0,0,0, 0xFFFFFFFF, 0.f, 0.f},
      { 0,0,0, 0,0,0, 0xFFFFFFFF, 0.f, 0.f},
      { 0,0,0, 0,0,0, 0xFFFFFFFF, 0.f, 0.f}
   };
   QuadVerts[0].px = x0;
   QuadVerts[0].py = y0;
   QuadVerts[0].c = c;
   QuadVerts[1].px = x0;
   QuadVerts[1].py = y1;
   QuadVerts[1].c = c;
   QuadVerts[2].px = x1;
   QuadVerts[2].py = y0;
   QuadVerts[2].c = c;
   QuadVerts[3].px = x1;
   QuadVerts[3].py = y1;
   QuadVerts[3].c = c;
   pd3dDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, QuadVerts, sizeof(D3DVERTEX));
}