application.cpp

load .x file to application

			break;
		case WA_INACTIVE:   
            m_bActive = false;            
			break;
		}
		break;

	case WM_DESTROY:
		PostQuitMessage(0);
		break;

	case WM_SIZE:
		switch(wParam)
		{
		case SIZE_MINIMIZED:    
            m_bActive = false;
			break;
		case SIZE_RESTORED:  
			m_bActive = true;

            if( s_wasMax )
            {
                if( !WindowSizeChange() )
                    PostQuitMessage(0);

                s_wasMax = false;
            }

			break;
		case SIZE_MAXIMIZED:  
			m_bActive = true;
            WindowSizeChange();
            s_wasMax = true;
			break;
		}
		break;

	case WM_KEYDOWN:
        m_bKey[wParam] = true;    
		switch(wParam)
		{
		case VK_ESCAPE:
			PostQuitMessage(0);
			break;
		case VK_PAUSE:
			m_bPaused = !m_bPaused;
            break;
        case VK_F12:    
            if( !ToggleFullscreen() )
			{
                Error("Could not toggle between fullscreen and windowed");
				PostQuitMessage(0);
			}
            break;
        case VK_F11:    
            m_bShowStats = !m_bShowStats;
            break;  
		}	
		break;

    case WM_KEYUP:
        m_bKey[wParam] = false; 
		break;

    case WM_EXITSIZEMOVE:
        if( !WindowSizeChange() )
            PostQuitMessage(0);
        break;

	default: return DefWindowProc(hWnd, iMsg, wParam, lParam);
	}

	return DefWindowProc(hWnd, iMsg, wParam, lParam);
}

bool CApplication::WindowSizeChange()
{
    RECT clientRect;

    if(!InvalidateObjects())
    {
        Error("Failed to change window size");
        return false;
    }

    if( m_bWindowed )
    {
        GetClientRect(m_hWnd, &clientRect);
        m_iWndWidth = m_d3dpp.BackBufferWidth = clientRect.right - clientRect.left; 
        m_iWndHeight = m_d3dpp.BackBufferHeight = clientRect.bottom - clientRect.top;  
    }

    if( !ResetDevice() )
    {
        Error("Failed to change window size");
        return false;
    }

    if( !RestoreObjects() )
    {
        Error("Failed to change window size");
        return false;
    }

    SetPerspective();
    PauseTimer();

    return true;
}

bool CApplication::SetPerspective()
{
    D3DXMatrixPerspectiveFovLH( &m_matProjection, D3DX_PI/4.0f, 
        float(m_d3dpp.BackBufferWidth/m_d3dpp.BackBufferHeight), 1.0f, 1000.0f );

    if( FAILED( m_pD3DDevice->SetTransform(D3DTS_PROJECTION, &m_matProjection ) ) )
        return Error("SetTransform() failed in SetPerspective()"); 

    return true;
}

bool CApplication::ToggleFullscreen()
{
    m_bWindowed = !m_bWindowed;
    RECT wr, cr;

    if( m_bWindowed )
    {
        SetWindowLong(m_hWnd, GWL_STYLE, WS_OVERLAPPEDWINDOW);
    }
    else
    {
        SetWindowLong(m_hWnd, GWL_STYLE, WS_POPUP|WS_SYSMENU|WS_VISIBLE);
    }

    D3DDISPLAYMODE d3ddm;
    if(FAILED(m_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
        return Error("Could not get the adapter display mode in fullscreen toggle");

    m_d3dpp.BackBufferCount = 1; 
    m_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    m_d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
    m_d3dpp.EnableAutoDepthStencil = TRUE; 
    m_d3dpp.AutoDepthStencilFormat = D3DFMT_D16; 
	m_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

    if(m_bWindowed)
    {
        m_d3dpp.BackBufferWidth = m_iWndWidth; 
        m_d3dpp.BackBufferHeight = m_iWndHeight;
        m_d3dpp.BackBufferFormat = d3ddm.Format; 
        m_d3dpp.Windowed = true;  
    }
    else
    {
        m_d3dpp.BackBufferWidth = d3ddm.Width;
        m_d3dpp.BackBufferHeight = d3ddm.Height;
        m_d3dpp.BackBufferFormat = d3ddm.Format;
        m_d3dpp.Windowed = false;  
        m_d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
    }

    if( !InvalidateObjects() )
        return false;

    if( !ResetDevice() )
        return false;    
    
    if( m_bWindowed )
    {
        // Change size then adjust frame.
        SetWindowPos(m_hWnd, 
            HWND_TOP, 
            0,         
            0,    
            m_iWndWidth,  
            m_iWndHeight, 
            SWP_SHOWWINDOW);

        GetClientRect( m_hWnd, &cr );
        GetWindowRect( m_hWnd, &wr );

        SetWindowPos(m_hWnd, 
            HWND_TOP, 
            0,         
            0,    
            m_iWndWidth + (cr.left - wr.left) + (wr.right - cr.right),  
            m_iWndHeight + (cr.top - wr.top) + (wr.bottom - cr.bottom), 
            SWP_SHOWWINDOW);
    }

    if( !RestoreObjects() )
        return false;

    SetPerspective();
    
    return true;
}

void CApplication::InitializeTimer()
{
	m_dwTotalFrames = 0L;

    ZeroMemory(&m_llTime, sizeof(LARGE_INTEGER));
	m_llLastTime = 0L;
	m_llStartTime = 0L;
	m_llTicksPerSec = 0L;

	m_ulStartTime = 0;
	m_ulTime = 0;
	m_ulLastTime = 0;

	if(QueryPerformanceFrequency(&m_llTime))
	{
		m_bUseQPC = true;

		m_llTicksPerSec = m_llTime.QuadPart;

		QueryPerformanceCounter(&m_llTime);
		m_llStartTime = m_llTime.QuadPart;	
		m_llLastTime = m_llStartTime;
	}
	else
	{
		m_ulStartTime = timeGetTime();
		m_ulLastTime = m_ulStartTime;
	}

    m_fTimeForFrame = 0;
    m_fElapsedTime = 0;
    m_iAbsoluteTime = 0;
    m_fFPS = 0;
    m_fAvgFPS = 0;
    
    m_statsFont.InitializeFont(m_pD3DDevice, "Tahoma", 14);
    m_statsFont.SetFontColor(D3DCOLOR_XRGB(255,255,255));
}

void CApplication::ProcessTimer()
{
	m_dwTotalFrames++;

	if( m_bUseQPC )
	{
		QueryPerformanceCounter(&m_llTime);
		m_fTimeForFrame = (float)(m_llTime.QuadPart - m_llLastTime) / (float)m_llTicksPerSec;
		m_llLastTime = m_llTime.QuadPart;
        m_iAbsoluteTime = (int)(m_llTime.QuadPart - m_llStartTime)/(int)m_llTicksPerSec;
	}
	else
	{
		m_ulTime = timeGetTime();
		m_fElapsedTime = (float)(m_ulTime - m_ulStartTime)/1000.0f;
		m_ulLastTime = m_ulTime;
        m_iAbsoluteTime = (m_ulTime - m_ulStartTime)/1000;
	}
    
	m_fElapsedTime += m_fTimeForFrame;

    static float seconds = 0;
    static DWORD dwNumFrames = 0;
    dwNumFrames++;
    seconds += m_fTimeForFrame;

    if( seconds >= 1.0f )
    {
        m_fFPS = float( dwNumFrames / seconds );
        seconds = 0; 
        dwNumFrames = 0;
        m_fAvgFPS = (float)m_dwTotalFrames/(float)m_fElapsedTime;
    }
}

void CApplication::PauseTimer()
{

	if(m_bUseQPC)
	{
		QueryPerformanceCounter(&m_llTime);
		m_llLastTime = m_llTime.QuadPart;
		
	}
	else
	{
		m_ulTime = timeGetTime();
		m_ulLastTime = m_ulTime;
	}
}

bool CApplication::Error(const char* strErrorText)
{
    MessageBox(m_hWnd, strErrorText, "Error", MB_OK|MB_ICONSTOP);
    return false;
}

bool CApplication::RenderStats()
{
    if( m_bShowStats )
    {
        m_statsFont.Begin();

        char str[512];
        char tmp[64];

        strcpy( str, "- Frames/Second = " );
        strcat( str, _gcvt(m_fFPS, 10, tmp) );

        strcat( str, "\n- Elapsed time = " );
        strcat( str, _gcvt(m_fElapsedTime, 10, tmp) );
        strcat( str, " seconds");

        strcat( str, "\n- Absolute time = " );
        strcat( str, itoa(m_iAbsoluteTime, tmp, 10) );
        strcat( str, " seconds");

        strcat( str, m_strVertexProcessing );
        

        m_statsFont.Print(str, 0, 0);

        m_statsFont.End();
    }

    return true;
}


//////////////////////////////////////////////////////////////////////////////////////////////
// This file is copyright