游戏开发论坛

 找回密码
 立即注册
搜索
查看: 2891|回复: 3

【源代码】游戏初始判断机器显卡适合模式的算法,嘎嘎

[复制链接]

21

主题

61

帖子

68

积分

注册会员

Rank: 2

积分
68
发表于 2006-12-14 23:40:00 | 显示全部楼层 |阅读模式
main.cpp:


#include &quotreInclude.h"



const char            g_szClassName[]           = "My Window Class";
const char            g_szWindowName[]          = "大航海时代";

IDirect3D9*                      g_pD3D9                            = NULL;
IDirect3DDevice9*     g_pD3DDevice              = NULL;
IDirect3DVertexBuffer9*  g_pVB2D                                = NULL;
IDirect3DIndexBuffer9*   g_Index                                = NULL;

HWND                  g_hWnd                    = NULL;



int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE
                                   hPrevInstance, LPSTR lpCmdLine,
                                   int nCmdShow )
{
        WNDCLASS sWndClass = { NULL };

        sWndClass.hInstance                        = hInstance;  
        sWndClass.lpszClassName                = g_szClassName;  
        sWndClass.style                                = CS_CLASSDC;
        sWndClass.lpfnWndProc                = WindowProc;
        sWndClass.hbrBackground     = GetSysColorBrush( 0 );

        if( NULL == RegisterClass( &sWndClass ) )
                return -1;

        g_hWnd = CreateWindow( g_szClassName, g_szWindowName,
                WS_OVERLAPPEDWINDOW,
                0, 0, 700, 600, NULL, NULL, hInstance, NULL );
        if( g_hWnd == NULL )
                return -1;

        MSG sMsg = { NULL };

       
        if( !InitializeD3D( true ) )
        {
                goto Exit;
        }
       
       
        ShowWindow( g_hWnd, SW_NORMAL );
        UpdateWindow( g_hWnd );

        //进入游戏主循环

        //如果不是退出消息
        while( sMsg.message != WM_QUIT )
        {
                //如果有消息
                if( PeekMessage( &sMsg, NULL, 0, 0, PM_REMOVE ) )
                {
                        //处理消息
                        TranslateMessage( &sMsg );
                        DispatchMessage( &sMsg);
                }
                //如果没有消息
                else
                {
                        UpdateFrame();
                }
        }


Exit:
        ReleaseD3D();

        UnregisterClass( g_szClassName, hInstance );

        return 0;
}


//消息处理函数

LRESULT CALLBACK WindowProc(
                                                        HWND g_hWnd,
                                                        UINT uMsg,
                                                        WPARAM wParam,
                                                        LPARAM lParam
                                                        )
{
        switch (uMsg)
        {
        case WM_KEYUP:
                {
                    if( wParam == VK_ESCAPE )
                        {
                           DestroyWindow( g_hWnd );
                        }
                        break;
                }
        case WM_DESTROY:
                {
                        PostQuitMessage( 0 );
                        break;
                }
        }

        return DefWindowProc( g_hWnd, uMsg, wParam, lParam );
}




//初始化硬件接口
bool InitializeD3D( bool bWindowed )
{
    g_pD3D9 = Direct3DCreate9( D3D_SDK_VERSION );
        if( g_pD3D9==NULL )
            return false;
       
        const UINT iNumAdapter = g_pD3D9->GetAdapterCount ();

        for( UINT i=0; i<iNumAdapter; ++i )
        {   
                D3DADAPTER_IDENTIFIER9 sIdent = { NULL };
                if( FAILED( g_pD3D9->GetAdapterIdentifier( i, 0, &sIdent ) ) )
                  
                        return false;

               

    }

        D3DFORMAT pPixelFormat [] =
        {
        D3DFMT_A1R5G5B5,
            D3DFMT_X8R8G8B8,
            D3DFMT_R5G6B5
         };

        UINT iUseMode = 0xFFFFFFFF;

        //显示模式
       
        D3DDISPLAYMODE pModes [] =
        {
                { 1024,768,90,D3DFMT_X8R8G8B8 },
                { 2048,1096,85,D3DFMT_X8R8G8B8 },
                { 1024, 768, 85, D3DFMT_X8R8G8B8 },
                { 1280,800,85,D3DFMT_X8R8G8B8 },
                { 800, 600, 100, D3DFMT_X8R8G8B8 },
                { 800, 600, 75, D3DFMT_X8R8G8B8 },
                { 640, 480, 60, D3DFMT_X8R8G8B8 },
        };

        //寻找适合模式算法
        for( UINT i=0; i<sizeof(pPixelFormat)/sizeof(D3DFORMAT); ++i )
           {
            const UINT iModes = g_pD3D9->GetAdapterModeCount ( 0 , pPixelFormat );

            for( UINT j=0; j<iModes; ++j )
               {
                           D3DDISPLAYMODE  sMode       = { NULL };
                   if( FAILED(g_pD3D9->EnumAdapterModes ( 0, pPixelFormat, j, &sMode) ) )
                                   return false;

                           for( UINT k=0; k<sizeof(pModes)/sizeof(D3DDISPLAYMODE); ++k )
                           {
                                   const D3DDISPLAYMODE& rMode = pModes[k];
                               if( memcmp( &rMode, &sMode, sizeof(D3DDISPLAYMODE) )==0 )
                                   {
                                      if( k< iUseMode )
                                          {
                                             iUseMode = k;
                                          }
                                          if( k==0 )
                                          {
                                             goto FoundMode;
                                          }
                                   }
                           }
                }

            }

FoundMode:
           if( iUseMode==0xFFFFFFFF )
                  {
                     DebugBreak();
                         return false;
                  }

          
                  //绘制结构
                D3DPRESENT_PARAMETERS sD3Dpp = { NULL };

           D3DDISPLAYMODE& rUseMode = pModes[ iUseMode ];

           if( bWindowed )//是否全屏
           {
                  sD3Dpp.BackBufferWidth            = 700;
          sD3Dpp.BackBufferHeight           = 600;
              sD3Dpp.BackBufferFormat           = D3DFMT_UNKNOWN;//缓冲可用模式
              sD3Dpp.BackBufferCount            = 1;
                  sD3Dpp.SwapEffect                 = D3DSWAPEFFECT_COPY;//翻页方法
                  sD3Dpp.Windowed                   = TRUE;
                  sD3Dpp.FullScreen_RefreshRateInHz = 0;
           }
           else
           {
              sD3Dpp.BackBufferWidth            = rUseMode.Width;
              sD3Dpp.BackBufferHeight           = rUseMode.Height;
              sD3Dpp.BackBufferFormat           = rUseMode.Format;
          sD3Dpp.BackBufferCount            = 2;
          sD3Dpp.SwapEffect                 = D3DSWAPEFFECT_DISCARD;
              sD3Dpp.Windowed                   = FALSE;
              sD3Dpp.FullScreen_RefreshRateInHz = rUseMode.RefreshRate;
           }
                //公用属性
           sD3Dpp.MultiSampleType               = D3DMULTISAMPLE_NONE;//混合采样类型
           sD3Dpp.MultiSampleQuality            = 0; //纹理层数
           sD3Dpp.hDeviceWindow                 = g_hWnd; //窗口句柄
           sD3Dpp.EnableAutoDepthStencil        = TRUE;  //自动填充深度摸版
           sD3Dpp.AutoDepthStencilFormat        = D3DFMT_D16;//深度缓存类型
           sD3Dpp.Flags                         = 0;
           sD3Dpp.PresentationInterval          = D3DPRESENT_INTERVAL_ONE;//翻页速度

           //创建设备
           if( FAILED(g_pD3D9->CreateDevice ( 0, D3DDEVTYPE_HAL, g_hWnd,
                                                  D3DCREATE_MIXED_VERTEXPROCESSING,
                                                                                  &sD3Dpp,&g_pD3DDevice) ) )
           {
                        return false;
           };
               
          
           Vertex2D pVertex [] =
           {
                  
                   {50.0f,250.0f,0.5f,1.0f,0xFFFF0000},
                   {200.0f,50.0f,0.5f,1.0f,0xFF00FF00},
                   {350.0f,250.0f,0.5f,1.0f,0xFF0000FF},
                   {350.0f,250.0f,0.5f,1.0f,0xFF0000FF},
                   {200.0f,450.0f,0.5f,1.0f,0xFF00FF00},
                   {50.0f,250.0f,0.5f,1.0f,0xFF00FF00},
                  
       
           };
          

           //创建顶点缓存

           if(FAILED(g_pD3DDevice->CreateVertexBuffer(sizeof(pVertex),D3DUSAGE_WRITEONLY,D3DFVF_Vertex2D,D3DPOOL_DEFAULT,&g_pVB2D,NULL)))
           {
                   return false;
           }

          Vertex2D *pVerDst = NULL;
           if(FAILED(g_pVB2D->Lock(0,0,(void**)&pVerDst,0)))
           {
                        return false;
           }

           memcpy( pVerDst,pVertex,sizeof(pVertex) );

           g_pVB2D->Unlock();
          
                        //        //索引顶点绘制说明
                        //1。实际绘制使用顶点(以顶点缓存起始位置为基准)=索引缓存中索引值+顶点数据偏移量
                        //2。绘制顶点数量 = 绘制中实际使用的顶点缓存中的顶点数量- 顶点数据偏移量
                        //3。当前绘制所使用的索引缓存中的所有索引值都不允许小于使用最小索引值
                        //4。索引数据偏移量的值不会影响实际的顶点索引值
                        //----------------------------------------------------------------------
                        //DSDPRIMITIVETYPE D3DPT = D3D9TypeGet::GetprimitiveType(ePrimType);
                        //HRESULT result = mpD3D9Device-> DrawIndexedPrimitive(
                        //        D3DPT, //绘制图原类型
                        //        nVerOffset //顶点数据偏移量
                        //        nMinIndex //使用最小索引值
                        //        nNumVer  //绘制顶点数量
                        //        nIndexOffset //索引数据偏移量
                        //        nPrimCount);  //绘制图元数量
                        //   
          

                if(FAILED(g_pD3DDevice->CreateIndexBuffer(sizeof(pVertex),
                                                                                0,
                                                                                D3DFMT_INDEX16,
                                                                                D3DPOOL_DEFAULT,
                                                                                &g_Index,NULL) ) )
                {
                        return false;
                }

                //设置索引
                WORD wIndeces[] ={0,1,2,0,2,3};
               
                //锁定
                void *pIndeces;
                if(FAILED(g_Index->Lock(0,sizeof(wIndeces),&pIndeces,0) ) )
                {
                        return false;
                }
                memcpy(pIndeces,wIndeces,sizeof(wIndeces));
                g_Index->Unlock();



           //生成设备结束后进行清屏
           g_pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xFF0000FF, 0.0f, 0 );
          
           return true;

}






void ReleaseD3D()
{

        SafeRelease( g_pVB2D );
        SafeRelease( g_pD3DDevice );
    SafeRelease( g_pD3D9 );
}



void UpdateState()
{
}

void UpdateScene()
{
}

void UpdateFrame()
{
       
        UpdateState();//更新逻辑
        UpdateScene();//更新场景
        RenderFrame();//绘制

}

void RenderFrame()
{
        g_pD3DDevice->Present( NULL, NULL, NULL, NULL );//翻页函数
       
        g_pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0x00000000, 1.0f, 0 );//清屏的颜色

       
       
        g_pD3DDevice->SetStreamSource(0,g_pVB2D,0,sizeof(Vertex2D));//设置流的参数
       
       
        g_pD3DDevice->SetFVF(D3DFVF_Vertex2D); //设置灵活顶点格式
       
       
        g_pD3DDevice->BeginScene();//开始对显卡下命令

        g_pD3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST,0,2); //绘制三角型列

        g_pD3DDevice->EndScene();//命令下达完毕

       

       
}




[em3]

35

主题

1735

帖子

1739

积分

金牌会员

Rank: 6Rank: 6

积分
1739
QQ
发表于 2006-12-15 08:56:00 | 显示全部楼层

Re:【源代码】游戏初始判断机器显卡适合模式的算法,嘎嘎

嘎嘎,果然很长。

18

主题

573

帖子

573

积分

高级会员

Rank: 4

积分
573
发表于 2006-12-15 12:50:00 | 显示全部楼层

Re:【源代码】游戏初始判断机器显卡适合模式的算法,嘎嘎

如果不是很大的工程,使用DX9提供的那个Framework就可以了,何必重复发明轮子呢?我们的任务是编写游戏,把精力放在游戏开发伤比较好!纯属个人之见。

16

主题

83

帖子

103

积分

注册会员

Rank: 2

积分
103
QQ
发表于 2006-12-25 18:26:00 | 显示全部楼层

Re: 【源代码】游戏初始判断机器显卡适合模式的算法,嘎

没看到判断代码啊,发一个我常用的方法。见笑了
typedef std::vector<std::pair<u32, String> > BehaviorType;
BehaviorType behavior;
#ifndef _DEBUG
        behavior.push_back(std::make_pair(D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE, String("D3D9设备创建:硬件设备->纯硬件处理顶点")));
        behavior.push_back(std::make_pair(D3DCREATE_HARDWARE_VERTEXPROCESSING, String("D3D9设备创建:硬件设备->硬件处理顶点")));
        behavior.push_back(std::make_pair(D3DCREATE_MIXED_VERTEXPROCESSING, String("D3D9设备创建:硬件设备->混合方式处理顶点")));
#endif
        behavior.push_back(std::make_pair(D3DCREATE_SOFTWARE_VERTEXPROCESSING, String("D3D9设备创建:硬件设备->软件处理顶点")));

        for (u32 i =0; i < behavior.size(); i++)
        {
          if (SUCCEEDED(mpID3D->CreateDevice(D3DADAPTER_DEFAULT, devType, hwnd,                                D3DCREATE_MULTITHREADED | behavior.first, &mPresent, &mpD3DDevice)))
         {
           Core:rinter:ogInfo(behavior.second);
            break;
         }
        }
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

作品发布|文章投稿|广告合作|关于本站|游戏开发论坛 ( 闽ICP备17032699号-3 )

GMT+8, 2026-1-26 03:13

Powered by Discuz! X3.4

Copyright © 2001-2021, Tencent Cloud.

快速回复 返回顶部 返回列表