InfoVid Es una clase que permite enumerar los adaptadores gráficos
y modos de video soportados por éstos de una manera sencilla.
Tambien recupera información acerca de drivers. En el caso
de nVidia, se recupera la versión de sus drivers Detonator.
Se requiere el SDK de DirectX 9.0 para compilar el código fuente,
aunque he incluido un binario de demostración.
Para ejecutar el binario se requiere DirectX9.0, of course.
(No sé si la versión 9.0b será necesaria, ya que es la versión que
he utilizado para compilar).
// InfoVid.h;
--------------------------------------------------------------------
#include "d3dx9.h";
#define VENDORID_NVIDIA 0x000010de
namespace ivid
{
struct sVideoMode
{
UINT uWidth;
UINT uHeight;
UINT uRefreshRate;
UINT uFormat;
char szModeDesc[32];
};
struct sVideoAdapter
{
char szDescription[MAX_DEVICE_IDENTIFIER_STRING];
char szDriverName[MAX_DEVICE_IDENTIFIER_STRING];
DWORD dwDriverVersionLo;
DWORD dwDriverVersionHi;
UINT uModeCount;
sVideoMode* pModes;
};
class InfoVid
{
public:
int Init();
int GetAdapterCount() const;
const sVideoAdapter* GetAdapterInfo() const;
InfoVid();
~InfoVid();
private:
virtual void FormatMode(sVideoMode* pMode);
UINT m_uAdapterCount;
sVideoAdapter* m_pInfo;
};
}
//--------------------------------------------------------------------
La función miembro FormatMode() se encarga de crear una cadena describiendo
cada modo de vídeo, p.ej. "800x600, 32bpp, 85hz".
FormatMode() crea las cadenas de una manera por defecto, pero podeis cambiar
el formato predefinido derivando de InfoVid...
// InfoVid.cpp
--------------------------------------------------------------------
#include "InfoVid.h"
#include "Safe.h"
#include "d3dx9.h";
#include "cstdio";
#pragma comment(lib,"d3d9.lib")
using namespace ivid;
InfoVid::InfoVid()
: m_uAdapterCount(0),m_pInfo(0)
{
}
int InfoVid::Init()
{
HMODULE D3DLibrary = LoadLibrary("d3d9.dll");
IDirect3D9 *pID3D;
if (!D3DLibrary)
{
OutputDebugString("Error, could not load D3D9.DLL");
return 0;
}
typedef IDirect3D9 * (__stdcall *D3DCREATETYPE)(UINT);
D3DCREATETYPE d3dCreate = (D3DCREATETYPE) GetProcAddress(D3DLibrary, "Direct3DCreate9");
if(!d3dCreate)
{
OutputDebugString("Error, could not get proc adress of Direct3DCreate9");
FreeLibrary(D3DLibrary);
return 0;
}
// Like pID3D = Direct3DCreate9(D3D_SDK_VERSION);
pID3D = (*d3dCreate)(D3D_SDK_VERSION);
if (!pID3D)
{
OutputDebugString("Error initializing D3D.");
FreeLibrary(D3DLibrary);
return 0;
}
//Return number of available devices
m_uAdapterCount = pID3D->GetAdapterCount();
D3DADAPTER_IDENTIFIER9* pAdapterId=0;
m_pInfo = new sVideoAdapter[m_uAdapterCount];
pAdapterId = new D3DADAPTER_IDENTIFIER9[m_uAdapterCount];
for(UINT i=0; i < m_uAdapterCount ; i++)
{
pID3D->GetAdapterIdentifier(i,0,&pAdapterId[i]);
strcpy(m_pInfo[i].szDescription,pAdapterId[i].Description);
strcpy(m_pInfo[i].szDriverName,pAdapterId[i].Driver);
m_pInfo[i].dwDriverVersionHi = pAdapterId[i].DriverVersion.HighPart;
m_pInfo[i].dwDriverVersionLo = pAdapterId[i].DriverVersion.LowPart;
// Si es NVIDIA sabemos sacar los números de versión
if(pAdapterId[i].VendorId == VENDORID_NVIDIA)
{
int iNVversion = m_pInfo[i].dwDriverVersionLo & 0x0000FFFF;
m_pInfo[i].dwDriverVersionHi = iNVversion/100;
m_pInfo[i].dwDriverVersionLo = iNVversion - (iNVversion/100)*100;
}
}
SafeDeleteArray(pAdapterId);
// Allowed formats in DX9 are:
D3DFORMAT lstFormat[]= { D3DFMT_X8R8G8B8, D3DFMT_A8R8G8B8, D3DFMT_A2B10G10R10,
D3DFMT_X1R5G5B5, D3DFMT_A1R5G5B5, D3DFMT_R5G6B5};
D3DDISPLAYMODE mode;
for(UINT i=0; i < m_uAdapterCount ; i++)
{
UINT uTotalModes = 0;
for(UINT h=0; h < 6; h++)
{
uTotalModes += pID3D->GetAdapterModeCount(i,lstFormat[h]);
}
m_pInfo[i].uModeCount = uTotalModes;
m_pInfo[i].pModes = new sVideoMode[uTotalModes];
UINT k=0;
for(UINT h=0; h < 6; h++)
{
UINT uModeCount = pID3D->GetAdapterModeCount(i,lstFormat[h]);
for(UINT j=0;j<uModeCount;j++)
{
pID3D->EnumAdapterModes(i,lstFormat[h],j,&mode);
m_pInfo[i].pModes[k].uWidth = mode.Width;
m_pInfo[i].pModes[k].uHeight = mode.Height;
m_pInfo[i].pModes[k].uRefreshRate = mode.RefreshRate;
m_pInfo[i].pModes[k].uFormat = (UINT)lstFormat[h];
FormatMode(&(m_pInfo[i].pModes[k]));
k++;
}
}
}
pID3D->Release();
FreeLibrary(D3DLibrary);
return m_uAdapterCount ;
}
InfoVid::~InfoVid()
{
if(m_pInfo)
{
for(UINT i=0;i<m_uAdapterCount;i++)
{
for(UINT k=0;k<m_pInfo[i].uModeCount;k++)
{
SafeDeleteArray(m_pInfo[i].pModes);
}
}
SafeDeleteArray(m_pInfo);
}
}
int InfoVid::GetAdapterCount() const
{
return m_uAdapterCount;
}
const sVideoAdapter* InfoVid::GetAdapterInfo() const
{
return (const sVideoAdapter*)m_pInfo;
}
void InfoVid::FormatMode(sVideoMode* pMode)
{
sprintf((char*)&(pMode->szModeDesc),"%dx%d %dhz",
pMode->uWidth,pMode->uHeight,pMode->uRefreshRate);
}
--------------------------------------------------------------------
Y Ahora un ejemplo de utilización:
--------------------------------------------------------------------
#include "iostream.h"
#include "InfoVid.h"
#include "d3dx9.h";
using namespace ivid;
int main(int argc, char* argv[])
{
InfoVid iv;
int iAdapters = iv.Init();
if(iAdapters)
{
const sVideoAdapter* pInfo = iv.GetAdapterInfo();
// Recorremos tarjetas gráficas instaladas
for(UINT i=0;i< iAdapters; i++)
{
cout << pInfo[i].szDescription << endl
<< pInfo[i].szDriverName << " \nDriver version: "
<< pInfo[i].dwDriverVersionHi << "."
<< pInfo[i].dwDriverVersionLo << endl;
cout << "Pulsa una tecla para ver los modos...\n";
cin.get();
// Recorremos modos de vídeo disponibles
for(UINT k=0; k<pInfo[i].uModeCount;k++)
{
cout << pInfo[i].pModes[k].uFormat << " "
<< pInfo[i].pModes[k].szModeDesc << endl;
}
}
}
else
cerr << "No se pudo obtener la informacion de video\n";
cout << "Pulsa una tecla para salir...\n";
cin.get();
return 0;
}
Autor: Julio Gorgé, a.k.a. Zaelsius
Web: http://www.zsgames.tk
Código: http://www.alu.ua.es/j/jgf8/code/InfoVid.zip
Si quieres enviar tu propio código hazlo a eth_cotd@lycos.es
[/list]