ryzom/tools/client/client_config_qt/src/system.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stdpch.h"
  18 #include "system.h"
  19
  20 #include <nel/3d/driver.h>
  21 #include <nel/3d/dru.h>
  22 #include <QtOpenGL/QGLWidget>
  23
  24 CSystem::CSystem()
  25 {
  26         GatherSysInfo();
  27 #ifdef Q_OS_WIN32
  28         GatherD3DInfo();
  29 #endif
  30         GatherOpenGLInfo();
  31 }
  32
  33 CSystem::~CSystem()
  34 {
  35 }
  36
  37 bool CSystem::parseDriverVersion(const std::string &device, uint64 driver, std::string &version)
  38 {
  39         // file version
  40         uint32 version1 = driver >> 48;
  41         uint32 version2 = (driver >> 32) & 0xffff;
  42         uint32 version3 = (driver >> 16) & 0xffff;
  43         uint32 version4 = driver & 0xffff;
  44
  45         if (device.find("NVIDIA") != std::string::npos)
  46         {
  47                 // nvidia should be something like 9.18.13.2018 and 9.18.13.1422
  48                 // which respectively corresponds to drivers 320.18 and 314.22
  49                 uint32 nvVersionMajor = (version3 % 10) * 100 + (version4 / 100);
  50                 uint32 nvVersionMinor = version4 % 100;
  51
  52                 version = NLMISC::toString("%u.%u", nvVersionMajor, nvVersionMinor);
  53         }
  54         else
  55         {
  56                 version = NLMISC::toString("%u.%u.%u.%u", version1, version2, version3, version4);
  57         }
  58
  59         return true;
  60 }
  61
  62 void CSystem::GatherSysInfo()
  63 {
  64         std::string device;
  65         uint64 driver;
  66
  67         if( NLMISC::CSystemInfo::getVideoInfo( device, driver ) )
  68         {
  69                 sysInfo.videoDevice = device;
  70
  71                 CSystem::parseDriverVersion(device, driver, sysInfo.videoDriverVersion);
  72         }
  73         else
  74         {
  75                 sysInfo.videoDevice = "video card";
  76                 sysInfo.videoDriverVersion = "0.0.0.0";
  77         }
  78
  79         sysInfo.osName   = NLMISC::CSystemInfo::getOS();
  80         sysInfo.cpuName  = NLMISC::CSystemInfo::getProc();
  81         sysInfo.totalRAM = NLMISC::CSystemInfo::totalPhysicalMemory();
  82         sysInfo.totalRAM /= ( 1024 * 1024 );
  83 }
  84
  85 #ifdef Q_OS_WIN32
  86 void CSystem::GatherD3DInfo()
  87 {
  88         NL3D::IDriver *driver = NULL;
  89         try
  90         {
  91                 driver = NL3D::CDRU::createD3DDriver();
  92
  93                 NL3D::IDriver::CAdapter adapter;
  94
  95                 if( driver->getAdapter( 0xffffffff, adapter ) )
  96                 {
  97                         d3dInfo.device        = adapter.Description;
  98                         d3dInfo.driver        = adapter.Driver;
  99
 100                         CSystem::parseDriverVersion(d3dInfo.device, adapter.DriverVersion, d3dInfo.driverVersion);
 101                 }
 102
 103                 GetVideoModes( d3dInfo.modes, driver );
 104
 105                 driver->release();
 106         }
 107
 108         catch(const NLMISC::Exception &e)
 109         {
 110                 nlwarning( e.what() );
 111         }
 112 }
 113 #endif
 114
 115 void CSystem::GatherOpenGLInfo()
 116 {
 117         QGLWidget *gl = new QGLWidget();
 118
 119         gl->makeCurrent();
 120
 121         const char *s = NULL;
 122         s = reinterpret_cast< const char * >( glGetString( GL_VENDOR ) );
 123         if( s != NULL )
 124                 openglInfo.vendor.assign( s );
 125
 126         s = reinterpret_cast< const char * >( glGetString( GL_RENDERER ) );
 127         if( s != NULL )
 128                 openglInfo.renderer.assign( s );
 129
 130         s = reinterpret_cast< const char * >( glGetString( GL_VERSION ) );
 131         if( s != NULL )
 132                 openglInfo.driverVersion.assign( s );
 133
 134         s = reinterpret_cast< const char * >( glGetString( GL_EXTENSIONS ) );
 135         if( s != NULL )
 136         {
 137                 openglInfo.extensions.assign( s );
 138                 for( std::string::iterator itr = openglInfo.extensions.begin(); itr != openglInfo.extensions.end(); ++itr )
 139                         if( *itr == ' ' )
 140                                 *itr = '\n';
 141         }
 142
 143         delete gl;
 144
 145         try
 146         {
 147                 NL3D::IDriver *driver = NL3D::CDRU::createGlDriver();
 148                 driver->init(0);
 149                 GetVideoModes( openglInfo.modes, driver );
 150                 driver->release();
 151         }
 152         catch(const NLMISC::Exception &e)
 153         {
 154                 nlwarning( e.what() );
 155         }
 156 }
 157
 158 void CSystem::GetVideoModes( std::vector< CVideoMode > &dst, NL3D::IDriver *driver ) const
 159 {
 160         std::vector< NL3D::GfxMode > modes;
 161         driver->getModes( modes );
 162
 163         {
 164                 // auto mode
 165                 CVideoMode mode;
 166                 mode.depth = 0;
 167                 mode.width = 0;
 168                 mode.height = 0;
 169                 mode.frequency = 0;
 170                 dst.push_back( mode );
 171         }
 172
 173         for( std::vector< NL3D::GfxMode >::iterator itr = modes.begin(); itr != modes.end(); ++itr )
 174         {
 175                 if( ( itr->Width >= 800 ) && ( itr->Height >= 600 ) && ( itr->Depth >= 16 ) )
 176                 {
 177                         CVideoMode mode;
 178                         mode.depth = itr->Depth;
 179                         mode.width = itr->Width;
 180                         mode.height = itr->Height;
 181                         mode.frequency = itr->Frequency;
 182
 183                         dst.push_back( mode );
 184                 }
 185         }
 186 }