cdxapp.cpp

一个Direct3DRM的包装类的例子

    {
        ErrHandler( "CDXApp::InitialiseD3DRM()","SetCooperativeLevel Failed",err );
        return( FALSE );
    }

    /*  Set the video mode if full screen  */

    if ( IsFullScreen() )
    {
        if ( (err=m_pDD2->SetDisplayMode(m_sizeScreen.cx,m_sizeScreen.cy,GetBitDepth(),0,0))!=DD_OK )
        {
            ErrHandler( "CDXApp::InitialiseD3DRM()","SetDisplayMode Failed",err );
            return( FALSE );
        }

        /*  Output some debug stuff  */

#ifdef _DEBUG
        DDSCAPS     ddsCaps;
        DWORD       dwAvail, dwFree;

        ddsCaps.dwCaps=DDSCAPS_VIDEOMEMORY;
        err=m_pDD2->GetAvailableVidMem(&ddsCaps,&dwAvail,&dwFree);
        TRACE( "Video RAM Available = %dK, Free=%dK",dwAvail/1024,dwFree/1024 );
#endif  //_DEBUG


        /*  Full screen uses page flipping  */

        DDSURFACEDESC       ddsd;

        ZeroMemory( &ddsd,sizeof(ddsd) );
        ddsd.dwSize         = sizeof(ddsd);
        ddsd.dwFlags        = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
        ddsd.ddsCaps.dwCaps = DDSCAPS_COMPLEX | DDSCAPS_FLIP | DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE;
        ddsd.dwBackBufferCount = 1;

        if ( (err=m_pDD2->CreateSurface(&ddsd,(LPDIRECTDRAWSURFACE *)&m_pPrimarySurface,NULL))!=DD_OK || m_pPrimarySurface==NULL )
        {
            ErrHandler( "CDXApp::InitialiseD3DRM()","Create Primary Surface Failed",err );
            return( FALSE );
        }

        /*  Get pointer to back buffer  */

        DDSCAPS             ddscaps;

        ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
        if ( (err=m_pPrimarySurface->GetAttachedSurface(&ddscaps,&m_pBackBuffer))!=DD_OK )
        {
            ErrHandler( "CDXApp::InitialiseD3DRM()","GetAttachedSurface Failed for back buffer",err );
            return( FALSE );
        }
    }

    /*  Create the D3DRM object and window  */

    m_pD3DRM = NULL;
    m_pD3DRM2= NULL;
    if ( (err=::Direct3DRMCreate(&m_pD3DRM))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp::InitialiseD3DRM()","D3DRMCreate() Failed",err );
        return( FALSE );
    }

    /*  We need a Direct3DRM2 interface so query for it  */

    if ( (err=m_pD3DRM->QueryInterface(IID_IDirect3DRM2,(void **)&m_pD3DRM2))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp::InitialiseD3DRM()","QueryInterface for IDIRECT3DRM2 Failed",err );
        return( FALSE );
    }

    /*  Create the master scene and camera frames  */

    if ( (err=m_pD3DRM2->CreateFrame(NULL,&m_pD3DScene))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp::InitialiseD3DRM()","CreateFrame (scene) Failed",err );
        return( FALSE );
    }

    if ( (err=m_pD3DRM2->CreateFrame(m_pD3DScene,&m_pD3DCamera))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp::InitialiseD3DRM()","CreateFrame (camera) Failed",err );
        return( FALSE );
    }

    /*  Set the camera position  */

    if ( (err=m_pD3DCamera->SetPosition(m_pD3DScene,D3DVAL(0.0),D3DVAL(0.0),D3DVAL(0.0)))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp::InitialiseD3DRM()","SetPosition Failed",err );
        return( FALSE );
    }

    /*  Create a DirectDraw clipper and attach it to the window  */

    if ( (err=::DirectDrawCreateClipper(0,&m_pDDClipper,NULL))!=DD_OK )
    {
        ErrHandler( "CDXApp::InitialiseD3DRM()","Failed to create Clipper",err );
        return( FALSE );
    }

    if ( (err=m_pDDClipper->SetHWnd(0,GetHWnd()))!=DD_OK )
    {
        ErrHandler( "CDXApp::InitialiseD3DRM()","Failed to attach HWnd to clipper",err );
        return( FALSE );
    }

    /*  Create D3DRM device by using the selected driver  */

    if ( !CreateDeviceAndViewport() ) return( FALSE );

    /*  Create the scene using the app specific hook  */

    if ( !::AppCreateScene() ) return( FALSE );

    /*  Flag as initialised  */

    m_bIsInitialised = TRUE;

    return( TRUE );
}

void CDXApp::CleanUp()
{
    /*  Tidy up display  */

    if ( IsInitialised() && IsFullScreen() )
    {
        HRESULT     err;

        if ( (err=m_pDD2->RestoreDisplayMode())!=DD_OK )
        {
            ErrHandler( "CDXApp::CleanUp","RestoreDisplayMode Failed",err );
        }
    }

    /*  Release all of the necessaries  */

    m_bIsInitialised = FALSE;

#ifdef _DEBUG
    RELEASE( m_pStatsSurface );
    RELEASE( m_pInfoSurface );
    if ( gStats.hFont!=NULL )
    {
        ::DeleteObject( gStats.hFont );
        gStats.hFont = NULL;
    }
#endif  //_DEBUG

    RELEASE( m_pD3DScene );
    RELEASE( m_pD3DCamera );
    RELEASE( m_pD3DViewport );
    RELEASE( m_pD3DIDevice2 );
    RELEASE( m_pD3DDevice );
    RELEASE( m_pPrimarySurface );
    RELEASE( m_pD3DRM2 );
    RELEASE( m_pD3DRM );
    RELEASE( m_pDDClipper );
    RELEASE( m_pD3D );
    RELEASE( m_pDD2 );
    RELEASE( m_pDD );
}

BOOL CDXApp::CreateDeviceAndViewport()
{
    /*  Create a D3D Device using the clipper and the specified D3D driver  */

    HRESULT     err;

    /*  Full screen apps need to create device from surface  */

    if ( IsFullScreen() )
    {
        if ( (err=m_pD3DRM2->CreateDeviceFromSurface(m_DriverGUID+m_nCurrDriver,m_pDD,(LPDIRECTDRAWSURFACE)m_pBackBuffer,&m_pD3DDevice))!=D3DRM_OK )
        {
            ErrHandler( "CDXApp::CreateDeviceAndViewport()","Error creating device from surface",err );
            return( FALSE );
        }

        /*  Ensure device is double buffered  */

        if ( (err=m_pD3DDevice->SetBufferCount(1))!=D3DRM_OK )
        {
            ErrHandler( "CDXApp::CreateDeviceAndViewport()","Error setting buffer count",err );
            return( FALSE );
        }
    }
    else
    {
        if ( (err=m_pD3DRM2->CreateDeviceFromClipper(m_pDDClipper,m_DriverGUID+m_nCurrDriver,m_sizeScreen.cx,m_sizeScreen.cy,&m_pD3DDevice))!=D3DRM_OK )
        {
            ErrHandler( "CDXApp::CreateDeviceAndViewport()","Error creating device from clipper",err );
            return( FALSE );
        }
    }

    /*  Get a handle to D3DIM device  */

    if ( (err=m_pD3DDevice->GetDirect3DDevice2(&m_pD3DIDevice2))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp::CreateDeviceAndViewport()","Error getting handle to D3DIM device",err );
        return( FALSE );
    }

    /*  Create the D3DRM viewport from the camera frame. Set the background depth to  */
    /*  a large number. Also, reset the width and height 'cos they may have been      */
    /*  changed slightly.                                                             */

    m_sizeScreen.cx = m_pD3DDevice->GetWidth();
    m_sizeScreen.cy = m_pD3DDevice->GetHeight();

    if ( (err=m_pD3DRM2->CreateViewport(m_pD3DDevice,m_pD3DCamera,0,0,m_sizeScreen.cx,m_sizeScreen.cy,&m_pD3DViewport))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp::CreateDeviceAndViewport()","Error creating the viewport",err );
        return( FALSE );
    }

    if ( (err=m_pD3DViewport->SetBack(D3DVAL(5000.0f)))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp::CreateDeviceAndViewport()","Error setting back value",err );
        return( FALSE );
    }

    if ( (err=m_pD3DViewport->SetFront(D3DVAL(0.5f)))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp::CreateDeviceAndViewport()","Error setting front value",err );
        return( FALSE );
    }

    /*  Finish off by setting the render state  */

    if ( !SetRenderState() ) return( FALSE );

    return( TRUE );
}

BOOL CDXApp::EnumerateDrivers()
{
    HRESULT             err;

    /*  Create a DirectDraw object and query for the Direct3D2 interface to  */
    /*  enumerate the drivers                                                */

    if ( (err=::DirectDrawCreate(NULL,&m_pDD,NULL))!=DD_OK )
    {
        ErrHandler( "CDXApp::EnumerateDrivers()","DirectDrawCreate Failed",err );
        return( FALSE );
    }

    if ( (err=m_pDD->QueryInterface(IID_IDirectDraw2,(void **)&m_pDD2))!=DD_OK )
    {
        ErrHandler( "CDXApp::EnumerateDrivers()","QueryInterface(IDirectDraw2) Failed",err );
        return( FALSE );
    }

    if ( (err=m_pDD2->QueryInterface(IID_IDirect3D2,(void **)&m_pD3D))!=DD_OK )
    {
        ErrHandler( "CDXApp::EnumerateDrivers()","QueryInterface(IDirect3D2) Failed",err );
        return( FALSE );
    }

    /*  Enumerate the current drivers  */

    m_nCurrDriver = -1;
    m_nNumDrivers = 0;
    bHardware     = FALSE;
    bMono         = TRUE;

    m_pD3D->EnumDevices( enumDeviceFunc,&m_nCurrDriver );

    /*  Ensure at least one device available  */

    if ( !m_nNumDrivers ) return( FALSE );

    return( TRUE );
}

void CDXApp::SetQuit()
{
    /*  Set flag to quit  */

    if ( !IsQuitting() )
    {
        m_bIsQuitting = TRUE;

        /*  Detach menu from window  */

        HMENU   hMenu=::GetMenu( GetHWnd() );

        if ( hMenu==NULL && GetHMenu()!=NULL )
        {
            ::DestroyMenu( GetHMenu() );
            m_hMenu=NULL;
        }

        /*  Ensure buffers are correctly adjusted  */

        if ( IsInitialised() && IsFullScreen() && !IsMinimised() )
        {
            HRESULT     err;

            RenderFrame();
            if ( (err=m_pDD2->FlipToGDISurface())!=DD_OK )
            {
                ErrHandler( "CDXApp::SetQuit()","FlipToGDISurface Failed",err );
            }
            if ( (err=m_pDD2->RestoreDisplayMode())!=DD_OK )
            {
                ErrHandler( "CDXApp::SetQuit()","RestoreDisplayMode Failed",err );
            }

            m_bIsFullScreen = FALSE;
        }

        if ( ::IsWindow(GetHWnd()) ) ::SendMessage( GetHWnd(),WM_CLOSE,0,0 );

        CleanUp();
    }
}

BOOL CDXApp::AddEnumDevice( LPGUID lpGUID, LPCSTR lpszDeviceName )
{
    /*  Add device to array if possible  */

    if ( GetNumDrivers()>=MAX_DRIVERS ) return( FALSE );

    memcpy( m_DriverGUID+m_nNumDrivers,lpGUID,sizeof(GUID) );
    ZeroMemory( m_szDriverName[m_nNumDrivers],sizeof(m_szDriverName[m_nNumDrivers]) );
    lstrcpyn( m_szDriverName[m_nNumDrivers],lpszDeviceName,sizeof(m_szDriverName[m_nNumDrivers])-1 );
    m_nNumDrivers++;

    return( TRUE );
}

BOOL CDXApp::SetRenderState()
{
    HRESULT     err;

    /*  Set the render quality  */

    if ( (err=Get3DDevice()->SetQuality(GetRenderFlags()))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp()::SetRenderState()","Set Render Quality Failed",err );
        return( FALSE );
    }

    /*  Assign the dither state  */

    if ( (err=Get3DDevice()->SetDither(GetDither()))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp()::SetRenderState()","Set Dither Failed",err );
        return( FALSE );
    }

    /*  Set the texture quality  */

    if ( (err=Get3DDevice()->SetTextureQuality(GetTextureFlags()))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp()::SetRenderState()","Set Texture Quality Failed",err );
        return( FALSE );
    }

    /*  Set the render mode  */

    if ( (err=Get3DDevice()->SetRenderMode(D3DRMRENDERMODE_BLENDEDTRANSPARENCY|D3DRMRENDERMODE_SORTEDTRANSPARENCY))!=D3DRM_OK )
    {
        ErrHandler( "CDXApp()::SetRenderState()","SetRenderMode Failed",err );
        return( FALSE );
    }