void NvAPI::Initialize()
{
NvAPI_Status r = NvAPI_Initialize();
if (r == NVAPI_OK)
{
}
}
//-----------------------------------------------------------------------------
D3D9StereoDriverBridge::D3D9StereoDriverBridge(StereoModeType stereoMode)
{
mPimpl = NULL;
mIsNvapiInitialized = false;
mStereoMode = stereoMode;
if (SMT_FRAME_SEQUENTIAL != mStereoMode)
return;
// Both initialize and set driver mode need to be called to determine whether NVIDIA stereo is available
NvAPI_Status nvStatus = NvAPI_Initialize();
if (NVAPI_OK == nvStatus)
nvStatus = NvAPI_Stereo_SetDriverMode(NVAPI_STEREO_DRIVER_MODE_DIRECT);
if (NVAPI_OK == nvStatus)
{
NvAPI_ShortString nvapiStatusMessage;
NvAPI_GetErrorMessage(nvStatus, nvapiStatusMessage);
mIsNvapiInitialized = true;
mPimpl = new D3D9StereoDriverNVIDIA();
}
else
{
// Assume the AMD implementation, since the device must be created before verifying AMD QBS
mPimpl = new D3D9StereoDriverAMD();
}
}
BEGIN_NAMESPACE_XEVOL3D
xNvRenderer::xNvRenderer()
{
NvAPI_Status ret = NvAPI_Initialize();
if(NVAPI_OK != ret)
{
XEVOL_LOG(eXL_ERROR_NORMAL , L"Initialize NvApi Failed\n");
return ;
}
NvAPI_Status nvapiStatus;
m_nvDisplayCount = 0;
// Enumerate all display handles
for(int i=0,nvapiStatus=NVAPI_OK; nvapiStatus == NVAPI_OK; i++)
{
nvapiStatus = NvAPI_EnumNvidiaDisplayHandle(i, &m_hDisplay[i]);
if (nvapiStatus == NVAPI_OK) m_nvDisplayCount++;
}
for(int i=0; i< m_nvDisplayCount; i++)
{
NvAPI_GetDisplayDriverVersion(m_hDisplay[i] , &m_DrvVersion);
}
}
void EnumerateProfilesOnSystem()
{
NvAPI_Status status;
status = NvAPI_Initialize();
if(status != NVAPI_OK)
PrintError(status);
NvDRSSessionHandle hSession = 0;
status = NvAPI_DRS_CreateSession(&hSession);
if(status != NVAPI_OK)
PrintError(status);
status = NvAPI_DRS_LoadSettings(hSession);
if(status != NVAPI_OK)
PrintError(status);
NvDRSProfileHandle hProfile = 0;
unsigned int index = 0;
while((status = NvAPI_DRS_EnumProfiles(hSession, index, &hProfile)) == NVAPI_OK)
{
printf("Profile in position %d:\n", index);
DisplayProfileContents(hSession, hProfile);
index++;
}
if(status == NVAPI_END_ENUMERATION)
{
// this is expected at the end of the enumeration
}
else
if(status != NVAPI_OK)
PrintError(status);
NvAPI_DRS_DestroySession(hSession);
hSession = 0;
}
PStateNV::PStateNV(void)
{
NvAPI_Status status = NvAPI_Initialize();
if(status != NVAPI_OK)
throw "NVAPI cannot be initialized!";
NvAPI_EnumPhysicalGPUs(m_hPhysicalGPU, &m_gpuCount);
m_DynamicPStateInfo.version = NV_GPU_DYNAMIC_PSTATES_INFO_EX_VER;
m_nNumPState = 0;
GetPStateInfo();
}
void MemoryMonitor::Init()
{
NvAPI_Status Status = NvAPI_Initialize();
assert(Status == NVAPI_OK);
NvPhysicalGpuHandle NvGpuHandles[NVAPI_MAX_PHYSICAL_GPUS] = { 0 };
NvU32 NvGpuCount = 0;
Status = NvAPI_EnumPhysicalGPUs(NvGpuHandles, &NvGpuCount);
assert(Status == NVAPI_OK);
assert(NvGpuCount != 0);
m_GpuHandle = NvGpuHandles[0];
}
//////////////////////////////////////////////////////////
//
// NvOptimusDetect
//
// Try detecting optimus via NvAPI
//
//////////////////////////////////////////////////////////
bool NvOptimusDetect( void )
{
if( NvAPI_Initialize() != NVAPI_OK )
{
return false;
}
// Get and log driver info
NvAPI_ShortString szDesc = "-";
NvU32 uiDriverVersion = -1;
NvAPI_ShortString szBuildBranchString = "-";
NvAPI_GetInterfaceVersionString( szDesc );
NvAPI_SYS_GetDriverAndBranchVersion( &uiDriverVersion, szBuildBranchString );
WriteDebugEventAndReport( 7460, SString( "NvAPI - InterfaceVersion:'%s' DriverVersion:%d.%d Branch:'%s'", szDesc, uiDriverVersion / 100, uiDriverVersion % 100, szBuildBranchString ) );
// Get all the Physical GPU Handles
NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS] = {0};
NvU32 uiGpuCount = 0;
if( NvAPI_EnumPhysicalGPUs( nvGPUHandle, &uiGpuCount ) != NVAPI_OK )
{
return false;
}
bool bFoundOptimus = false;
for( NvU32 i = 0; i < uiGpuCount; i++ )
{
NV_SYSTEM_TYPE SystemType = (NV_SYSTEM_TYPE)-1; // 1-Laptop 2-Desktop
NV_GPU_TYPE GpuType = (NV_GPU_TYPE)-1; // 1-Integrated 2-Discrete
NvAPI_ShortString szName = "-";
NvAPI_GPU_GetSystemType( nvGPUHandle[i], &SystemType );
NvAPI_GPU_GetGPUType( nvGPUHandle[i], &GpuType );
NvAPI_GPU_GetFullName( nvGPUHandle[i], szName );
SString strStatus( "NvAPI - GPU %d/%d - SystemType:%d GpuType:%d (%s)", i, uiGpuCount, SystemType, GpuType, szName );
if ( SystemType == NV_SYSTEM_TYPE_LAPTOP && GpuType == NV_SYSTEM_TYPE_DGPU )
{
bFoundOptimus = true;
strStatus += " FoundOptimus";
}
WriteDebugEventAndReport( 7461, strStatus );
}
return bFoundOptimus;
}
CNvidia::CNvidia(void)
{
// NVAPI initialize
NvAPI_Status nvResult = NVAPI_OK;
nvResult = NvAPI_Initialize();
if (nvResult != NVAPI_OK)
AfxMessageBox(_T("Error Initialize NVAPI."));
// Physical gpu enumeration
nvResult = NvAPI_EnumPhysicalGPUs(&m_nvGPUHandle, &m_gpuCount);
if (nvResult != NVAPI_OK)
AfxMessageBox(_T("Error Get PhysicalGPU."));
// version
m_settings.version = NV_GPU_THERMAL_SETTINGS_VER_1;
m_clkFreqs.version = NV_GPU_CLOCK_FREQUENCIES_VER;
m_clkFreqs.ClockType = NV_GPU_CLOCK_FREQUENCIES_CURRENT_FREQ;
}
int _tmain(int argc, _TCHAR* argv[])
{
NvAPI_Status ret = NVAPI_OK;
ret = NvAPI_Initialize();
if(ret != NVAPI_OK)
{
printf("NvAPI_Initialize() failed = 0x%x", ret);
return 1; // Initialization failed
}
ret = SetMode();//to get the current mode, set to single view and then apply clone mode
if(ret != NVAPI_OK)
{
printf("Failed to Set Mode... return code = 0x%x", ret);
return 1;//Failed to Set Mode
}
printf("\nDisplay Configuration Successful!\n");
printf("\nPress any key to exit...");
getchar();
return 0;
}
//--------------------------------------------------------------------------------------
DepthTexture::DepthTexture(const LPDIRECT3D9 d3d) {
D3DDISPLAYMODE currentDisplayMode;
d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, ¤tDisplayMode);
// determine if RESZ is supported
m_isRESZ = d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
currentDisplayMode.Format, D3DUSAGE_RENDERTARGET, D3DRTYPE_SURFACE, FOURCC_RESZ) == D3D_OK;
SDLOG(-1, "[DepthTexture] RESZ: %s\n", m_isRESZ?"true":"false");
// determine if INTZ is supported
m_isINTZ = d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
currentDisplayMode.Format, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, FOURCC_INTZ) == D3D_OK;
SDLOG(-1, "[DepthTexture] INTZ: %s\n", m_isINTZ ? "true" : "false");
// determine if RAWZ is supported, used in GeForce 6-7 series.
m_isRAWZ = d3d->CheckDeviceFormat(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
currentDisplayMode.Format, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, FOURCC_RAWZ) == D3D_OK;
SDLOG(-1, "[DepthTexture] RAWZ: %s\n", m_isRAWZ ? "true" : "false");
// determine if RESZ or NVAPI supported
m_isSupported = (NvAPI_Initialize() == NVAPI_OK || m_isRESZ) && (m_isRAWZ || m_isINTZ);
}
//---------------------------------------------------------------------
D3D11StereoDriverBridge::D3D11StereoDriverBridge(StereoModeType stereoMode)
{
mPimpl = NULL;
mIsNvapiInitialized = false;
mStereoMode = stereoMode;
if (SMT_FRAME_SEQUENTIAL != mStereoMode)
return;
NvAPI_Status nvStatus = NvAPI_Initialize();
if (NVAPI_OK == nvStatus)
{
NvAPI_ShortString nvapiStatusMessage;
NvAPI_GetErrorMessage(nvStatus, nvapiStatusMessage);
mIsNvapiInitialized = true;
mPimpl = new D3D11StereoDriverNVIDIA();
}
else
{
// Assume the AMD implementation, since the device must be created before verifying AMD QBS
mPimpl = new D3D11StereoDriverAMD();
}
}
int main()
{
if (NvAPI_Initialize() != NVAPI_OK)
throw std::runtime_error("NVIDIA Api not initialized");
if (NvAPI_DRS_CreateSession(&_session) != NVAPI_OK)
throw std::runtime_error("can't create session");
if (NvAPI_DRS_LoadSettings(_session) != NVAPI_OK)
throw std::runtime_error("can't load system settings");
if (NvAPI_DRS_GetCurrentGlobalProfile(_session, &_profile) != NVAPI_OK)
throw std::runtime_error("can't get current global profile");
NvPhysicalGpuHandle nvGPUHandle[NVAPI_MAX_PHYSICAL_GPUS];
NvAPI_Status status;
NvU32 GpuCount;
NvU32 DeviceId;
NvU32 SubSystemId;
NvU32 RevisionId;
NvU32 ExtDeviceId;
NvU32 BusId;
NvU32 BiosRevision;
NvU32 BiosRevisionOEM;
NV_BOARD_INFO BoardInfo;
BoardInfo.version = NV_BOARD_INFO_VER;
NvU32 ConfiguredFeatureMask;
NvU32 ConsistentFeatureMask;
NvU32 CoreCount;
NvAPI_EnumPhysicalGPUs(nvGPUHandle, &GpuCount);
NvAPI_ShortString str;
NvAPI_GPU_GetFullName(nvGPUHandle[0], str);
NvAPI_GPU_GetPCIIdentifiers(nvGPUHandle[0], &DeviceId, &SubSystemId, &RevisionId, &ExtDeviceId);
NvAPI_GPU_GetBusId(nvGPUHandle[0], &BusId);
NvAPI_GPU_GetVbiosRevision(nvGPUHandle[0], &BiosRevision);
NvAPI_GPU_GetVbiosOEMRevision(nvGPUHandle[0], &BiosRevisionOEM);
NvAPI_GPU_GetVbiosVersionString(nvGPUHandle[0], str);
status = NvAPI_GPU_GetBoardInfo(nvGPUHandle[0], &BoardInfo);
status = NvAPI_GPU_WorkstationFeatureQuery(nvGPUHandle[0], &ConfiguredFeatureMask, &ConsistentFeatureMask);
status = NvAPI_GPU_GetGpuCoreCount(nvGPUHandle[0], &CoreCount);
NV_CHIPSET_INFO info;
info.version = NV_CHIPSET_INFO_VER_4;
status =NvAPI_SYS_GetChipSetInfo(&info);
NvAPI_GetInterfaceVersionString(str);
unsigned int test= (unsigned int) -0x68;
unsigned int index = 0;
while ((status = NvAPI_DRS_EnumProfiles(_session, index, &_profile)) == NVAPI_OK)
{
_profInfo.version = NVDRS_PROFILE_VER;
if (NvAPI_DRS_GetProfileInfo(_session, _profile, &_profInfo) != NVAPI_OK)
throw std::runtime_error("can't get current global profile info");
index++;
}
EnumerateProfilesOnSystem();
NvAPI_DRS_DestroySession(_session);
return 0;
}
int APIENTRY WINMAIN(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
const S32 MAX_HEAPS = 255;
DWORD heap_enable_lfh_error[MAX_HEAPS];
S32 num_heaps = 0;
#if WINDOWS_CRT_MEM_CHECKS && !INCLUDE_VLD
_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); // dump memory leaks on exit
#elif 1
// Experimental - enable the low fragmentation heap
// This results in a 2-3x improvement in opening a new Inventory window (which uses a large numebr of allocations)
// Note: This won't work when running from the debugger unless the _NO_DEBUG_HEAP environment variable is set to 1
_CrtSetDbgFlag(0); // default, just making explicit
ULONG ulEnableLFH = 2;
HANDLE* hHeaps = new HANDLE[MAX_HEAPS];
num_heaps = GetProcessHeaps(MAX_HEAPS, hHeaps);
for(S32 i = 0; i < num_heaps; i++)
{
bool success = HeapSetInformation(hHeaps[i], HeapCompatibilityInformation, &ulEnableLFH, sizeof(ulEnableLFH));
if (success)
heap_enable_lfh_error[i] = 0;
else
heap_enable_lfh_error[i] = GetLastError();
}
#endif
// *FIX: global
gIconResource = MAKEINTRESOURCE(IDI_LL_ICON);
LLAppViewerWin32* viewer_app_ptr = new LLAppViewerWin32(lpCmdLine);
viewer_app_ptr->setErrorHandler(LLAppViewer::handleViewerCrash);
// Set a debug info flag to indicate if multiple instances are running.
bool found_other_instance = !create_app_mutex();
gDebugInfo["FoundOtherInstanceAtStartup"] = LLSD::Boolean(found_other_instance);
bool ok = viewer_app_ptr->init();
if(!ok)
{
LL_WARNS() << "Application init failed." << LL_ENDL;
return -1;
}
#ifdef USE_NVAPI
NvAPI_Status status;
// Initialize NVAPI
status = NvAPI_Initialize();
NvDRSSessionHandle hSession = 0;
if (status == NVAPI_OK)
{
// Create the session handle to access driver settings
status = NvAPI_DRS_CreateSession(&hSession);
if (status != NVAPI_OK)
{
nvapi_error(status);
}
else
{
//override driver setting as needed
ll_nvapi_init(hSession);
}
}
#endif
// Have to wait until after logging is initialized to display LFH info
if (num_heaps > 0)
{
LL_INFOS() << "Attempted to enable LFH for " << num_heaps << " heaps." << LL_ENDL;
for(S32 i = 0; i < num_heaps; i++)
{
if (heap_enable_lfh_error[i])
{
LL_INFOS() << " Failed to enable LFH for heap: " << i << " Error: " << heap_enable_lfh_error[i] << LL_ENDL;
}
}
}
// Run the application main loop
if(!LLApp::isQuitting())
{
viewer_app_ptr->mainLoop();
}
if (!LLApp::isError())
{
//
// We don't want to do cleanup here if the error handler got called -
// the assumption is that the error handler is responsible for doing
// app cleanup if there was a problem.
//
#if WINDOWS_CRT_MEM_CHECKS
LL_INFOS() << "CRT Checking memory:" << LL_ENDL;
if (!_CrtCheckMemory())
{
LL_WARNS() << "_CrtCheckMemory() failed at prior to cleanup!" << LL_ENDL;
}
else
{
LL_INFOS() << " No corruption detected." << LL_ENDL;
}
#endif
gGLActive = TRUE;
viewer_app_ptr->cleanup();
#if WINDOWS_CRT_MEM_CHECKS
LL_INFOS() << "CRT Checking memory:" << LL_ENDL;
if (!_CrtCheckMemory())
{
LL_WARNS() << "_CrtCheckMemory() failed after cleanup!" << LL_ENDL;
}
else
{
LL_INFOS() << " No corruption detected." << LL_ENDL;
}
#endif
}
delete viewer_app_ptr;
viewer_app_ptr = NULL;
//start updater
if(LLAppViewer::sUpdaterInfo)
{
_spawnl(_P_NOWAIT, LLAppViewer::sUpdaterInfo->mUpdateExePath.c_str(), LLAppViewer::sUpdaterInfo->mUpdateExePath.c_str(), LLAppViewer::sUpdaterInfo->mParams.str().c_str(), NULL);
delete LLAppViewer::sUpdaterInfo ;
LLAppViewer::sUpdaterInfo = NULL ;
}
#ifdef USE_NVAPI
// (NVAPI) (6) We clean up. This is analogous to doing a free()
if (hSession)
{
NvAPI_DRS_DestroySession(hSession);
hSession = 0;
}
#endif
return 0;
}
BOOLEAN InitializeNvApi(VOID)
{
NvGpuPhysicalHandleList = PhCreateList(1);
NvGpuDisplayHandleList = PhCreateList(1);
#ifdef _M_IX86
if (!(NvApiLibrary = LoadLibrary(L"nvapi.dll")))
return FALSE;
#else
if (!(NvApiLibrary = LoadLibrary(L"nvapi64.dll")))
return FALSE;
#endif
if (!(NvAPI_QueryInterface = PhGetProcedureAddress(NvApiLibrary, "nvapi_QueryInterface", 0)))
return FALSE;
if (!(NvAPI_Initialize = NvAPI_QueryInterface(0x150E828UL)))
return FALSE;
if (!(NvAPI_Unload = NvAPI_QueryInterface(0xD22BDD7EUL)))
return FALSE;
if (!(NvAPI_GetErrorMessage = NvAPI_QueryInterface(0x6C2D048CUL)))
return FALSE;
if (!(NvAPI_EnumPhysicalGPUs = NvAPI_QueryInterface(0xE5AC921FUL)))
return FALSE;
if (!(NvAPI_EnumNvidiaDisplayHandle = NvAPI_QueryInterface(0x9ABDD40DUL)))
return FALSE;
// Information functions
NvAPI_SYS_GetDriverAndBranchVersion = NvAPI_QueryInterface(0x2926AAADUL);
NvAPI_GPU_GetFullName = NvAPI_QueryInterface(0xCEEE8E9FUL);
// Query functions
NvAPI_GPU_GetMemoryInfo = NvAPI_QueryInterface(0x774AA982UL);
NvAPI_GPU_GetThermalSettings = NvAPI_QueryInterface(0xE3640A56UL);
NvAPI_GPU_GetCoolerSettings = NvAPI_QueryInterface(0xDA141340UL);
NvAPI_GPU_GetPerfDecreaseInfo = NvAPI_QueryInterface(0x7F7F4600UL);
NvAPI_GPU_GetTachReading = NvAPI_QueryInterface(0x5F608315UL);
NvAPI_GPU_GetAllClockFrequencies = NvAPI_QueryInterface(0xDCB616C3UL);
// Undocumented Query functions
NvAPI_GPU_GetUsages = NvAPI_QueryInterface(0x189A1FDFUL);
NvAPI_GPU_GetAllClocks = NvAPI_QueryInterface(0x1BD69F49UL);
NvAPI_GPU_GetVoltageDomainsStatus = NvAPI_QueryInterface(0xC16C7E2CUL);
//NvAPI_GPU_GetPerfClocks = NvAPI_QueryInterface(0x1EA54A3B);
//NvAPI_GPU_GetVoltages = NvAPI_QueryInterface(0x7D656244);
//NvAPI_GPU_QueryActiveApps = NvAPI_QueryInterface(0x65B1C5F5);
//NvAPI_GPU_GetShaderPipeCount = NvAPI_QueryInterface(0x63E2F56F);
//NvAPI_GPU_GetShaderSubPipeCount = NvAPI_QueryInterface(0x0BE17923);
NvAPI_GPU_GetRamBusWidth = NvAPI_QueryInterface(0x7975C581); // ADD ME
NvAPI_GPU_GetRamBankCount = NvAPI_QueryInterface(0x17073A3CUL);
NvAPI_GPU_GetRamType = NvAPI_QueryInterface(0x57F7CAACUL);
NvAPI_GPU_GetRamMaker = NvAPI_QueryInterface(0x42AEA16AUL);
NvAPI_GPU_GetFoundry = NvAPI_QueryInterface(0x5D857A00UL);
//NvAPI_GetDisplayDriverMemoryInfo = NvAPI_QueryInterface(0x774AA982);
//NvAPI_GetPhysicalGPUsFromDisplay = NvAPI_QueryInterface(0x34EF9506);
NvAPI_GetDisplayDriverVersion = NvAPI_QueryInterface(0xF951A4D1UL);
NvAPI_GetDisplayDriverRegistryPath = NvAPI_QueryInterface(0x0E24CEEEUL);
//NvAPI_RestartDisplayDriver = NvAPI_QueryInterface(0xB4B26B65UL);
//NvAPI_GPU_GetBoardInfo = NvAPI_QueryInterface(0x22D54523);
//NvAPI_GPU_GetBusType = NvAPI_QueryInterface(0x1BB18724);
//NvAPI_GPU_GetIRQ = NvAPI_QueryInterface(0xE4715417);
NvAPI_GPU_GetVbiosVersionString = NvAPI_QueryInterface(0xA561FD7DUL);
NvAPI_GPU_GetShortName = NvAPI_QueryInterface(0xD988F0F3UL);
NvAPI_GPU_GetArchInfo = NvAPI_QueryInterface(0xD8265D24UL);
NvAPI_GPU_GetPCIIdentifiers = NvAPI_QueryInterface(0x2DDFB66EUL);
NvAPI_GPU_GetPartitionCount = NvAPI_QueryInterface(0x86F05D7AUL);
NvAPI_GPU_GetGpuCoreCount = NvAPI_QueryInterface(0xC7026A87UL);
NvAPI_GPU_GetPCIEInfo = NvAPI_QueryInterface(0xE3795199UL);
NvAPI_GPU_GetFBWidthAndLocation = NvAPI_QueryInterface(0x11104158UL);
NvAPI_GPU_ClientPowerTopologyGetStatus = NvAPI_QueryInterface(0x0EDCF624EUL);
//typedef NvAPI_Status (WINAPIV *_NvAPI_GetDisplayDriverBuildTitle)(_In_ NvDisplayHandle hNvDisplay, NvAPI_ShortString pDriverBuildTitle);
//typedef NvAPI_Status (WINAPIV *_NvAPI_GetDisplayDriverCompileType)(_In_ NvDisplayHandle hNvDisplay, NvU32* pDriverCompileType);
//typedef NvAPI_Status (WINAPIV *_NvAPI_GetDisplayDriverSecurityLevel)(_In_ NvDisplayHandle hNvDisplay, NvU32* pDriverSecurityLevel);
//typedef NvAPI_Status (WINAPIV *_NvAPI_GPU_GetVPECount)(_In_ NvPhysicalGpuHandle hPhysicalGPU, NvU32* pVPECount);
//typedef NvAPI_Status (WINAPIV *_NvAPI_GPU_GetSerialNumber)(_In_ NvPhysicalGpuHandle hPhysicalGPU, NvU32* serialnumber);
//typedef NvAPI_Status (WINAPIV *_NvAPI_GPU_GetExtendedMinorRevision)(_In_ NvPhysicalGpuHandle hPhysicalGPU, NvU32* revision);
//typedef NvAPI_Status (WINAPIV *_NvAPI_GPU_GetTargetID)(_In_ NvPhysicalGpuHandle hPhysicalGPU, NvU32* target);
//_NvAPI_GPU_GetExtendedMinorRevision NvAPI_GPU_GetExtendedMinorRevision;
//_NvAPI_GPU_GetTargetID NvAPI_GPU_GetTargetID;
//_NvAPI_GPU_GetSerialNumber NvAPI_GPU_GetSerialNumber;
//_NvAPI_GPU_GetVPECount NvAPI_GPU_GetVPECount;
//_NvAPI_GetDisplayDriverBuildTitle NvAPI_GetDisplayDriverBuildTitle;
//_NvAPI_GetDisplayDriverCompileType NvAPI_GetDisplayDriverCompileType;
//_NvAPI_GetDisplayDriverSecurityLevel NvAPI_GetDisplayDriverSecurityLevel;
//NvAPI_GPU_GetExtendedMinorRevision = NvAPI_QueryInterface(0x025F17421);
//NvAPI_GPU_GetTargetID = NvAPI_QueryInterface(0x35B5FD2F);
//NvAPI_GPU_GetSerialNumber = NvAPI_QueryInterface(0x14B83A5F);
//NvAPI_GPU_GetVPECount = NvAPI_QueryInterface(0xD8CBF37B);
//NvAPI_GetDisplayDriverBuildTitle = NvAPI_QueryInterface(0x7562E947);
//NvAPI_GetDisplayDriverCompileType = NvAPI_QueryInterface(0x988AEA78);
//NvAPI_GetDisplayDriverSecurityLevel = NvAPI_QueryInterface(0x9D772BBA);
if (NvAPI_Initialize() == NVAPI_OK)
{
NvGpuEnumPhysicalHandles();
NvGpuEnumDisplayHandles();
return TRUE;
}
return FALSE;
}
VOID InitGfx(VOID)
{
HMODULE module;
// Specify the nVidia Library to load.
#ifdef _M_IX86
module = LoadLibrary(L"nvapi.dll");
#else
module = LoadLibrary(L"nvapi64.dll");
#endif
if (module == NULL)
{
// Specify the Ati Library to load.
#ifdef _M_IX86
module = LoadLibrary(L"atiadlxy.dll");
#else
module = LoadLibrary(L"atiadlxx.dll");
#endif
if (module != NULL)
{
GraphicsType = AtiGraphics;
}
}
else
{
GraphicsType = NvidiaGraphics;
}
switch (GraphicsType)
{
case NvidiaGraphics:
{
// Find our QueryInterface API
NvAPI_QueryInterface = (P_NvAPI_QueryInterface)GetProcAddress(module, "nvapi_QueryInterface");
// Check if QueryInterface was found.
if (NvAPI_QueryInterface != NULL)
{
// 50/50 these ID's and API defs are correct.
// Library initialization functions
NvAPI_Initialize = (P_NvAPI_Initialize)NvAPI_QueryInterface(0x150E828);
NvAPI_Unload = (P_NvAPI_Unload)NvAPI_QueryInterface(0xD22BDD7E);
// Error Functions
NvAPI_GetErrorMessage = (P_NvAPI_GetErrorMessage)NvAPI_QueryInterface(0x6C2D048Cu);
// Handle Functions
NvAPI_EnumPhysicalGPUs = (P_NvAPI_EnumPhysicalGPUs)NvAPI_QueryInterface(0xE5AC921F);
NvAPI_EnumNvidiaDisplayHandle = (P_NvAPI_EnumNvidiaDisplayHandle)NvAPI_QueryInterface(0x9ABDD40D);
// Query Functions
NvAPI_GetUsages = (P_NvAPI_GPU_GetUsages)NvAPI_QueryInterface(0x189A1FDF);
NvAPI_GetMemoryInfo = (P_NvAPI_GetMemoryInfo)NvAPI_QueryInterface(0x774AA982);
NvAPI_GetPhysicalGPUsFromDisplay = (P_NvAPI_GetPhysicalGPUsFromDisplay)NvAPI_QueryInterface(0x34EF9506);
NvAPI_GetInterfaceVersionString = (P_NvAPI_GetInterfaceVersionString)NvAPI_QueryInterface(0x1053FA5);
NvAPI_GetFullName = (P_NvAPI_GPU_GetFullName)NvAPI_QueryInterface(0xCEEE8E9F);
NvAPI_GetAllClocks = (P_NvAPI_GPU_GetAllClocks)NvAPI_QueryInterface(0x1BD69F49);
NvAPI_GetThermalSettings = (P_NvAPI_GPU_GetThermalSettings)NvAPI_QueryInterface(0xE3640A56);
NvAPI_GetCoolerSettings = (P_NvAPI_GPU_GetCoolerSettings)NvAPI_QueryInterface(0xDA141340);
NvAPI_GetDisplayDriverVersion = (P_NvAPI_GetDisplayDriverVersion)NvAPI_QueryInterface(0xF951A4D1);
NvAPI_GetPerfDecreaseInfo = (P_NvAPI_GPU_GetPerfDecreaseInfo)NvAPI_QueryInterface(0x7F7F4600);
{
NvStatus status = NvAPI_Initialize();
if (NV_SUCCESS(status))
{
physHandle = EnumNvidiaGpuHandles();
dispHandle = EnumNvidiaDisplayHandles();
}
else
{
LogEvent(L"gfxinfo: (InitGfx) NvAPI_Initialize failed (%s)", status);
}
}
}
}
break;
case AtiGraphics:
{
//ADL_MAIN_CONTROL_DESTROY ADL_Main_Control_Destroy = NULL;
//ADL_ADAPTER_NUMBEROFADAPTERS_GET ADL_Adapter_NumberOfAdapters_Get = NULL;
//ADL_ADAPTER_ADAPTERINFO_GET ADL_Adapter_AdapterInfo_Get = NULL;
//ADL_Main_Control_Create = (ADL_MAIN_CONTROL_CREATE)GetProcAddress(module, "ADL_Main_Control_Create");
//ADL_Main_Control_Destroy = (ADL_MAIN_CONTROL_DESTROY)GetProcAddress(module, "ADL_Main_Control_Destroy");
//ADL_Adapter_NumberOfAdapters_Get = (ADL_ADAPTER_NUMBEROFADAPTERS_GET)GetProcAddress(module, "ADL_Adapter_NumberOfAdapters_Get");
//ADL_Adapter_AdapterInfo_Get = (ADL_ADAPTER_ADAPTERINFO_GET)GetProcAddress(module, "ADL_Adapter_AdapterInfo_Get");
//ADL_Display_DisplayInfo_Get = (ADL_DISPLAY_DISPLAYINFO_GET)GetProcAddress(module, "ADL_Display_DisplayInfo_Get");
//ADL_Display_ColorCaps_Get = (ADL_DISPLAY_COLORCAPS_GET)GetProcAddress(module, "ADL_Display_ColorCaps_Get");
//ADL_Display_Color_Get = (ADL_DISPLAY_COLOR_GET)GetProcAddress(module, "ADL_Display_Color_Get");
//ADL_Display_Color_Set = (ADL_DISPLAY_COLOR_SET)GetProcAddress(module, "ADL_Display_Color_Set");
//Adl_GetCurrentActivity = (P_Adl_OVERDRIVE_CURRENTACTIVITY_Get)GetProcAddress(module, "ADL_Overdrive5_CurrentActivity_Get");
}
break;
default:
{
}
break;
}
}
RF_Type::Bool NvidiaGPUService::IsAvailable()
{
NvAPI_Status ret = NVAPI_OK;
ret = NvAPI_Initialize();
return ret == NVAPI_OK;
}
VOID NvApiInitialize(VOID)
{
ULONG sampleCount;
if (!PhGetIntegerSetting(SETTING_NAME_ENABLE_GPU))
return;
sampleCount = PhGetIntegerSetting(L"SampleCount");
PhInitializeCircularBuffer_FLOAT(&GpuUtilizationHistory, sampleCount);
PhInitializeCircularBuffer_ULONG(&GpuMemoryHistory, sampleCount);
PhInitializeCircularBuffer_FLOAT(&GpuBoardHistory, sampleCount);
PhInitializeCircularBuffer_FLOAT(&GpuBusHistory, sampleCount);
NvGpuPhysicalHandleList = PhCreateList(1);
NvGpuDisplayHandleList = PhCreateList(1);
#ifdef _M_IX86
if (!(NvApiLibrary = LoadLibrary(L"nvapi.dll")))
return;
#else
if (!(NvApiLibrary = LoadLibrary(L"nvapi64.dll")))
return;
#endif
// Retrieve the NvAPI_QueryInterface function address
if (!(NvAPI_QueryInterface = PhGetProcedureAddress(NvApiLibrary, "nvapi_QueryInterface", 0)))
return;
// Initialization functions
if (!(NvAPI_Initialize = NvAPI_QueryInterface(0x150E828UL)))
return;
if (!(NvAPI_Unload = NvAPI_QueryInterface(0xD22BDD7EUL)))
return;
// Error functions
NvAPI_GetErrorMessage = NvAPI_QueryInterface(0x6C2D048CUL);
// Handle functions
NvAPI_EnumPhysicalGPUs = NvAPI_QueryInterface(0xE5AC921FUL);
NvAPI_EnumNvidiaDisplayHandle = NvAPI_QueryInterface(0x9ABDD40DUL);
// Information functions
NvAPI_SYS_GetDriverAndBranchVersion = NvAPI_QueryInterface(0x2926AAADUL);
NvAPI_GPU_GetFullName = NvAPI_QueryInterface(0xCEEE8E9FUL);
// Query functions
NvAPI_GPU_GetMemoryInfo = NvAPI_QueryInterface(0x774AA982UL);
NvAPI_GPU_GetThermalSettings = NvAPI_QueryInterface(0xE3640A56UL);
NvAPI_GPU_GetCoolerSettings = NvAPI_QueryInterface(0xDA141340UL);
NvAPI_GPU_GetPerfDecreaseInfo = NvAPI_QueryInterface(0x7F7F4600UL);
NvAPI_GPU_GetTachReading = NvAPI_QueryInterface(0x5F608315UL);
NvAPI_GPU_GetAllClockFrequencies = NvAPI_QueryInterface(0xDCB616C3UL);
// Undocumented functions below
NvAPI_GPU_GetUsages = NvAPI_QueryInterface(0x189A1FDFUL);
NvAPI_GPU_GetAllClocks = NvAPI_QueryInterface(0x1BD69F49UL);
NvAPI_GPU_GetVoltageDomainsStatus = NvAPI_QueryInterface(0xC16C7E2CUL);
NvAPI_GPU_GetPerfClocks = NvAPI_QueryInterface(0x1EA54A3B);
NvAPI_GPU_GetVoltages = NvAPI_QueryInterface(0x7D656244);
NvAPI_GPU_QueryActiveApps = NvAPI_QueryInterface(0x65B1C5F5);
NvAPI_GPU_GetShaderPipeCount = NvAPI_QueryInterface(0x63E2F56F);
NvAPI_GPU_GetShaderSubPipeCount = NvAPI_QueryInterface(0x0BE17923);
NvAPI_GPU_GetRamBusWidth = NvAPI_QueryInterface(0x7975C581);
NvAPI_GPU_GetRamBankCount = NvAPI_QueryInterface(0x17073A3CUL);
NvAPI_GPU_GetRamType = NvAPI_QueryInterface(0x57F7CAACUL);
NvAPI_GPU_GetRamMaker = NvAPI_QueryInterface(0x42AEA16AUL);
NvAPI_GPU_GetFoundry = NvAPI_QueryInterface(0x5D857A00UL);
//NvAPI_GetDisplayDriverMemoryInfo = NvAPI_QueryInterface(0x774AA982);
//NvAPI_GetPhysicalGPUsFromDisplay = NvAPI_QueryInterface(0x34EF9506);
NvAPI_GetDisplayDriverVersion = NvAPI_QueryInterface(0xF951A4D1UL);
NvAPI_GetDisplayDriverRegistryPath = NvAPI_QueryInterface(0x0E24CEEEUL);
//NvAPI_RestartDisplayDriver = NvAPI_QueryInterface(0xB4B26B65UL);
//NvAPI_GPU_GetBoardInfo = NvAPI_QueryInterface(0x22D54523);
//NvAPI_GPU_GetBusType = NvAPI_QueryInterface(0x1BB18724);
//NvAPI_GPU_GetIRQ = NvAPI_QueryInterface(0xE4715417);
NvAPI_GPU_GetVbiosVersionString = NvAPI_QueryInterface(0xA561FD7DUL);
NvAPI_GPU_GetShortName = NvAPI_QueryInterface(0xD988F0F3UL);
NvAPI_GPU_GetArchInfo = NvAPI_QueryInterface(0xD8265D24UL);
NvAPI_GPU_GetPCIIdentifiers = NvAPI_QueryInterface(0x2DDFB66EUL);
NvAPI_GPU_GetPartitionCount = NvAPI_QueryInterface(0x86F05D7AUL);
NvAPI_GPU_GetGpuCoreCount = NvAPI_QueryInterface(0xC7026A87UL);
NvAPI_GPU_GetPCIEInfo = NvAPI_QueryInterface(0xE3795199UL);
NvAPI_GPU_GetFBWidthAndLocation = NvAPI_QueryInterface(0x11104158UL);
NvAPI_GPU_ClientPowerTopologyGetStatus = NvAPI_QueryInterface(0x0EDCF624EUL);
NvAPI_GetDisplayDriverBuildTitle = NvAPI_QueryInterface(0x7562E947);
NvAPI_GetDisplayDriverCompileType = NvAPI_QueryInterface(0x988AEA78);
NvAPI_GetDisplayDriverSecurityLevel = NvAPI_QueryInterface(0x9D772BBA);
NvAPI_GPU_GetVPECount = NvAPI_QueryInterface(0xD8CBF37B);
NvAPI_GPU_GetTargetID = NvAPI_QueryInterface(0x35B5FD2F);
//NvAPI_GPU_GetExtendedMinorRevision = NvAPI_QueryInterface(0x025F17421);
//NvAPI_GPU_GetSerialNumber = NvAPI_QueryInterface(0x14B83A5F);
if (NvAPI_Initialize() == NVAPI_OK)
{
NvGpuEnumPhysicalHandles();
NvGpuEnumDisplayHandles();
NvApiInitialized = TRUE;
}
}
HRESULT CGPUUsage::Init(CString DeviceName)
{
Clean();
{
// ATI OverDrive
ATIData.hAtiADL = LoadLibrary(L"atiadlxx.dll");
if (ATIData.hAtiADL == NULL) {
ATIData.hAtiADL = LoadLibrary(L"atiadlxy.dll");
}
if (ATIData.hAtiADL) {
ADL_MAIN_CONTROL_CREATE ADL_Main_Control_Create;
ADL_ADAPTER_NUMBEROFADAPTERS_GET ADL_Adapter_NumberOfAdapters_Get;
ADL_ADAPTER_ADAPTERINFO_GET ADL_Adapter_AdapterInfo_Get;
ADL_ADAPTER_ACTIVE_GET ADL_Adapter_Active_Get;
ADL_OVERDRIVE_CAPS ADL_Overdrive_Caps;
ADL_Main_Control_Create = (ADL_MAIN_CONTROL_CREATE)GetProcAddress(ATIData.hAtiADL,"ADL_Main_Control_Create");
ATIData.ADL_Main_Control_Destroy = (ADL_MAIN_CONTROL_DESTROY)GetProcAddress(ATIData.hAtiADL,"ADL_Main_Control_Destroy");
ADL_Adapter_NumberOfAdapters_Get = (ADL_ADAPTER_NUMBEROFADAPTERS_GET)GetProcAddress(ATIData.hAtiADL,"ADL_Adapter_NumberOfAdapters_Get");
ADL_Adapter_AdapterInfo_Get = (ADL_ADAPTER_ADAPTERINFO_GET)GetProcAddress(ATIData.hAtiADL,"ADL_Adapter_AdapterInfo_Get");
ADL_Adapter_Active_Get = (ADL_ADAPTER_ACTIVE_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Adapter_Active_Get");
ADL_Overdrive_Caps = (ADL_OVERDRIVE_CAPS)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive_Caps");
if (NULL == ADL_Main_Control_Create ||
NULL == ATIData.ADL_Main_Control_Destroy ||
NULL == ADL_Adapter_NumberOfAdapters_Get ||
NULL == ADL_Adapter_AdapterInfo_Get ||
NULL == ADL_Adapter_Active_Get ||
NULL == ADL_Overdrive_Caps) {
Clean();
}
if (ATIData.hAtiADL) {
int iNumberAdapters = 0;
if (ADL_OK == ADL_Main_Control_Create(ADL_Main_Memory_Alloc, 1) && ADL_OK == ADL_Adapter_NumberOfAdapters_Get(&iNumberAdapters) && iNumberAdapters) {
LPAdapterInfo lpAdapterInfo = DNew AdapterInfo[iNumberAdapters];
if (lpAdapterInfo) {
memset(lpAdapterInfo, 0, sizeof(AdapterInfo) * iNumberAdapters);
// Get the AdapterInfo structure for all adapters in the system
ADL_Adapter_AdapterInfo_Get(lpAdapterInfo, sizeof(AdapterInfo) * iNumberAdapters);
for (int i = 0; i < iNumberAdapters; i++ ) {
int adapterActive = 0;
AdapterInfo adapterInfo = lpAdapterInfo[i];
ADL_Adapter_Active_Get(adapterInfo.iAdapterIndex, &adapterActive);
if (adapterActive && adapterInfo.iAdapterIndex >= 0 && adapterInfo.iVendorID == 1002) {
if (DeviceName.GetLength() && DeviceName != CString(adapterInfo.strDisplayName)) {
continue;
}
int iOverdriveSupported = 0;
int iOverdriveEnabled = 0;
if (ADL_OK != ADL_Overdrive_Caps(adapterInfo.iAdapterIndex, &iOverdriveSupported, &iOverdriveEnabled, &ATIData.iOverdriveVersion) || !iOverdriveSupported) {
break;
}
if (ATIData.iOverdriveVersion == 5) {
ADL_OVERDRIVE5_ODPARAMETERS_GET ADL_Overdrive5_ODParameters_Get;
ADL_Overdrive5_ODParameters_Get = (ADL_OVERDRIVE5_ODPARAMETERS_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive5_ODParameters_Get");
ATIData.ADL_Overdrive5_CurrentActivity_Get = (ADL_OVERDRIVE5_CURRENTACTIVITY_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive5_CurrentActivity_Get");
if (NULL == ADL_Overdrive5_ODParameters_Get || NULL == ATIData.ADL_Overdrive5_CurrentActivity_Get) {
break;
}
ADLODParameters overdriveParameters = {0};
overdriveParameters.iSize = sizeof (ADLODParameters);
if (ADL_OK != ADL_Overdrive5_ODParameters_Get(adapterInfo.iAdapterIndex, &overdriveParameters) || !overdriveParameters.iActivityReportingSupported) {
break;
}
ATIData.iAdapterId = adapterInfo.iAdapterIndex;
} else if (ATIData.iOverdriveVersion == 6) {
ADL_OVERDRIVE6_CAPABILITIES_GET ADL_Overdrive6_Capabilities_Get;
ADL_Overdrive6_Capabilities_Get = (ADL_OVERDRIVE6_CAPABILITIES_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive6_Capabilities_Get");
ATIData.ADL_Overdrive6_CurrentStatus_Get = (ADL_OVERDRIVE6_CURRENTSTATUS_GET)GetProcAddress(ATIData.hAtiADL, "ADL_Overdrive6_CurrentStatus_Get");
if (NULL == ADL_Overdrive6_Capabilities_Get || NULL == ATIData.ADL_Overdrive6_CurrentStatus_Get) {
break;
}
ADLOD6Capabilities od6Capabilities = {0};
if (ADL_OK != ADL_Overdrive6_Capabilities_Get(adapterInfo.iAdapterIndex, &od6Capabilities) || (od6Capabilities.iCapabilities & ADL_OD6_CAPABILITY_GPU_ACTIVITY_MONITOR) != ADL_OD6_CAPABILITY_GPU_ACTIVITY_MONITOR) {
break;
}
ATIData.iAdapterId = adapterInfo.iAdapterIndex;
}
break;
}
}
delete [] lpAdapterInfo;
}
}
}
}
if (ATIData.iAdapterId == -1 && ATIData.hAtiADL) {
Clean();
}
if (ATIData.iAdapterId >= 0 && ATIData.hAtiADL) {
m_GPUType = ATI_GPU;
}
}
if (m_GPUType == UNKNOWN_GPU) {
// NVApi
NVData.hNVApi = LoadLibrary(L"nvapi64.dll");
if (NVData.hNVApi == NULL) {
NVData.hNVApi = LoadLibrary(L"nvapi.dll");
}
if (NVData.hNVApi) {
NvAPI_QueryInterface_t NvAPI_QueryInterface = (NvAPI_QueryInterface_t)GetProcAddress(NVData.hNVApi, "nvapi_QueryInterface");
NvAPI_Initialize_t NvAPI_Initialize = NULL;
NvAPI_EnumPhysicalGPUs_t NvAPI_EnumPhysicalGPUs = NULL;
if (NvAPI_QueryInterface) {
NvAPI_Initialize = (NvAPI_Initialize_t)(NvAPI_QueryInterface)(0x0150E828);
NvAPI_EnumPhysicalGPUs = (NvAPI_EnumPhysicalGPUs_t)(NvAPI_QueryInterface)(0xE5AC921F);
NVData.NvAPI_GPU_GetUsages = (NvAPI_GPU_GetUsages_t)(NvAPI_QueryInterface)(0x189A1FDF);
}
if (NULL == NvAPI_QueryInterface ||
NULL == NvAPI_Initialize ||
NULL == NvAPI_EnumPhysicalGPUs ||
NULL == NVData.NvAPI_GPU_GetUsages) {
Clean();
}
if (NVData.hNVApi) {
NvAPI_Initialize();
int gpuCount = 0;
NvAPI_EnumPhysicalGPUs(NVData.gpuHandles, &gpuCount);
if (!gpuCount) {
Clean();
}
}
}
if (NVData.hNVApi && NVData.NvAPI_GPU_GetUsages) {
m_GPUType = NVIDIA_GPU;
}
}
return m_GPUType == UNKNOWN_GPU ? E_FAIL : S_OK;
}
bool StDXManager::getInfo(StDXInfo& theInfo,
const bool theForced) {
if(!theForced) {
if(ST_DX_HAS_CACHED_INFO) {
theInfo = ST_DX_CACHED_INFO;
return true;
}
}
const StStringUtfWide AQBS_TEST_CLASS = L"StTESTAqbsWin";
HINSTANCE anAppInst = GetModuleHandle(NULL);
WNDCLASSW aWinClass;
aWinClass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
aWinClass.lpfnWndProc = (WNDPROC )aDummyWinProc;
aWinClass.cbClsExtra = 0;
aWinClass.cbWndExtra = 0;
aWinClass.hInstance = anAppInst;
aWinClass.hIcon = LoadIcon(anAppInst, L"A");
aWinClass.hCursor = LoadCursor(NULL, IDC_ARROW);
aWinClass.hbrBackground = NULL;
aWinClass.lpszMenuName = NULL;
aWinClass.lpszClassName = AQBS_TEST_CLASS.toCString(); // class name
if(RegisterClassW(&aWinClass) == 0) {
ST_DEBUG_LOG("Failed to RegisterClass '" + AQBS_TEST_CLASS.toUtf8() + "'");
return false;
}
HWND aWinHandle = CreateWindowExW(WS_EX_TOOLWINDOW | WS_EX_WINDOWEDGE | WS_EX_NOACTIVATE,
AQBS_TEST_CLASS.toCString(), L"StTESTAqbs Window",
WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
32, 32, 32, 32, NULL, NULL, anAppInst, NULL);
if(aWinHandle == NULL) {
ST_DEBUG_LOG("Failed to create 'StTESTAqbsWin' window (" + int(GetLastError()) + ")");
UnregisterClassW(AQBS_TEST_CLASS.toCString(), anAppInst);
return false;
}
StHandle<StDXManager> aDXManager = new StDXManager();
// test AQBS support
theInfo.hasAqbsSupport = aDXManager->checkAqbsSupport(aWinHandle);
// enumerate available adapters
if(aDXManager->myD3dLib != NULL) {
const UINT aD3dAdaptersNb = aDXManager->getAdapterCount();
D3DADAPTER_IDENTIFIER9 anAdapterInfo;
for(UINT anAdapterIter = 0; anAdapterIter < aD3dAdaptersNb; ++anAdapterIter) {
aDXManager->getAdapterIdentifier(anAdapterIter, 0, &anAdapterInfo);
if(anAdapterInfo.VendorId == ST_DX_VENDOR_AMD) {
theInfo.hasAmdAdapter = true;
} else if(anAdapterInfo.VendorId == ST_DX_VENDOR_NVIDIA) {
theInfo.hasNvAdapter = true;
}
}
}
// release resources
aDXManager.nullify();
DestroyWindow(aWinHandle);
UnregisterClass(AQBS_TEST_CLASS.toCString(), anAppInst);
// check NVIDIA Stereo enabled state
if(NvAPI_Initialize() == NVAPI_OK) {
NvU8 isStereoEnabled = FALSE;
NvAPI_Stereo_IsEnabled(&isStereoEnabled);
theInfo.hasNvStereoSupport = isStereoEnabled == TRUE;
}
//ST_DEBUG_LOG("DXInfo, AMD(" + int(theInfo.hasAmdAdapter) + "), AQBS(" + int(theInfo.hasAqbsSupport)
// + "); NVIDIA(" + int(theInfo.hasNvAdapter) + "), NvStereo(" + int(theInfo.hasNvStereoSupport) + ")");
// cache the state to avoid unnecessary calls
ST_DX_CACHED_INFO = theInfo;
ST_DX_HAS_CACHED_INFO = true;
return true;
}
