bool OpenGL::initContext() { if (contextInitialized) return true; if (!gladLoadGLLoader(LOVEGetProcAddress)) return false; initOpenGLFunctions(); initVendor(); initMatrices(); bugs = {}; #if defined(LOVE_WINDOWS) || defined(LOVE_LINUX) // See the comments in OpenGL.h. if (getVendor() == VENDOR_AMD) { bugs.clearRequiresDriverTextureStateUpdate = true; bugs.generateMipmapsRequiresTexture2DEnable = true; } #endif contextInitialized = true; return true; }
const std::string OpenNI2Device::getStringID() const { std::string ID_str = getName() + "_" + getVendor(); boost::replace_all(ID_str, "/", ""); boost::replace_all(ID_str, ".", ""); boost::replace_all(ID_str, "@", ""); return ID_str; }
void SE_RenderSystemCapabilities::createHardwareInfo() { //get gpu vendor const char* vendorName = (const char*)glGetString(GL_VENDOR); setVendor(vendorFromString(vendorName)); if(getVendor() == 11) { SE_Application::getInstance()->getSceneManager()->setSceneManagerStatus(ENABLELIGHT,false); SE_Application::getInstance()->getSceneManager()->setSceneManagerStatus(ENABLEMIRROR,false); SE_Application::getInstance()->getSceneManager()->setSceneManagerStatus(ENABLEGROUNDSHADOW,false); } if(SE_Application::getInstance()->SEHomeDebug) LOGI("vendorName = %s\n",vendorName); //get compressed texture type num glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS,&mTextureCompressedTypeNum); //get compressed texture supported type int* compressTextureTypes = new int[mTextureCompressedTypeNum]; glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS,compressTextureTypes); for(int i = 0; i < mTextureCompressedTypeNum; ++i) { mTextureCompressTypes.push_back(compressTextureTypes[i]); } delete compressTextureTypes; //get maxium texture image unit number glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS,&mMaxTextureImageUnitNum); if(SE_Application::getInstance()->SEHomeDebug) LOGI("GL_MAX_TEXTURE_IMAGE_UNITS = %d\n",mMaxTextureImageUnitNum); glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS,&mMaxCombinedTextureImageUnitNum); if(SE_Application::getInstance()->SEHomeDebug) LOGI("GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS = %d\n",mMaxCombinedTextureImageUnitNum); glGetIntegerv(GL_STENCIL_BITS,&mMaxStencilBufferNum); if(SE_Application::getInstance()->SEHomeDebug) LOGI("\n\nGL_STENCIL_BITS = %d\n\n",mMaxStencilBufferNum); }
//----------------------------------------------------------------------- void RenderSystemCapabilities::log(Log* pLog) { #if OGRE_PLATFORM != OGRE_PLATFORM_WINRT pLog->logMessage("RenderSystem capabilities"); pLog->logMessage("-------------------------"); pLog->logMessage("RenderSystem Name: " + getRenderSystemName()); pLog->logMessage("GPU Vendor: " + vendorToString(getVendor())); pLog->logMessage("Device Name: " + getDeviceName()); pLog->logMessage("Driver Version: " + getDriverVersion().toString()); pLog->logMessage(" * Fixed function pipeline: " + StringConverter::toString(hasCapability(RSC_FIXED_FUNCTION), true)); pLog->logMessage( " * Hardware generation of mipmaps: " + StringConverter::toString(hasCapability(RSC_AUTOMIPMAP), true)); pLog->logMessage( " * Texture blending: " + StringConverter::toString(hasCapability(RSC_BLENDING), true)); pLog->logMessage( " * Anisotropic texture filtering: " + StringConverter::toString(hasCapability(RSC_ANISOTROPY), true)); pLog->logMessage( " * Dot product texture operation: " + StringConverter::toString(hasCapability(RSC_DOT3), true)); pLog->logMessage( " * Cube mapping: " + StringConverter::toString(hasCapability(RSC_CUBEMAPPING), true)); pLog->logMessage( " * Hardware stencil buffer: " + StringConverter::toString(hasCapability(RSC_HWSTENCIL), true)); if (hasCapability(RSC_HWSTENCIL)) { pLog->logMessage( " - Stencil depth: " + StringConverter::toString(getStencilBufferBitDepth())); pLog->logMessage( " - Two sided stencil support: " + StringConverter::toString(hasCapability(RSC_TWO_SIDED_STENCIL), true)); pLog->logMessage( " - Wrap stencil values: " + StringConverter::toString(hasCapability(RSC_STENCIL_WRAP), true)); } pLog->logMessage( " * Hardware vertex / index buffers: " + StringConverter::toString(hasCapability(RSC_VBO), true)); if(hasCapability(RSC_VBO)) { pLog->logMessage( " * 32-bit index buffers: " + StringConverter::toString(hasCapability(RSC_32BIT_INDEX), true)); } pLog->logMessage( " * Vertex programs: " + StringConverter::toString(hasCapability(RSC_VERTEX_PROGRAM), true)); pLog->logMessage( " * Number of floating-point constants for vertex programs: " + StringConverter::toString(mVertexProgramConstantFloatCount)); pLog->logMessage( " * Number of integer constants for vertex programs: " + StringConverter::toString(mVertexProgramConstantIntCount)); pLog->logMessage( " * Number of boolean constants for vertex programs: " + StringConverter::toString(mVertexProgramConstantBoolCount)); pLog->logMessage( " * Fragment programs: " + StringConverter::toString(hasCapability(RSC_FRAGMENT_PROGRAM), true)); pLog->logMessage( " * Number of floating-point constants for fragment programs: " + StringConverter::toString(mFragmentProgramConstantFloatCount)); pLog->logMessage( " * Number of integer constants for fragment programs: " + StringConverter::toString(mFragmentProgramConstantIntCount)); pLog->logMessage( " * Number of boolean constants for fragment programs: " + StringConverter::toString(mFragmentProgramConstantBoolCount)); pLog->logMessage( " * Geometry programs: " + StringConverter::toString(hasCapability(RSC_GEOMETRY_PROGRAM), true)); pLog->logMessage( " * Number of floating-point constants for geometry programs: " + StringConverter::toString(mGeometryProgramConstantFloatCount)); pLog->logMessage( " * Number of integer constants for geometry programs: " + StringConverter::toString(mGeometryProgramConstantIntCount)); pLog->logMessage( " * Number of boolean constants for geometry programs: " + StringConverter::toString(mGeometryProgramConstantBoolCount)); pLog->logMessage( " * Tessellation Hull programs: " + StringConverter::toString(hasCapability(RSC_TESSELLATION_HULL_PROGRAM), true)); pLog->logMessage( " * Number of floating-point constants for tessellation hull programs: " + StringConverter::toString(mTessellationHullProgramConstantFloatCount)); pLog->logMessage( " * Number of integer constants for tessellation hull programs: " + StringConverter::toString(mTessellationHullProgramConstantIntCount)); pLog->logMessage( " * Number of boolean constants for tessellation hull programs: " + StringConverter::toString(mTessellationHullProgramConstantBoolCount)); pLog->logMessage( " * Tessellation Domain programs: " + StringConverter::toString(hasCapability(RSC_TESSELLATION_DOMAIN_PROGRAM), true)); pLog->logMessage( " * Number of floating-point constants for tessellation domain programs: " + StringConverter::toString(mTessellationDomainProgramConstantFloatCount)); pLog->logMessage( " * Number of integer constants for tessellation domain programs: " + StringConverter::toString(mTessellationDomainProgramConstantIntCount)); pLog->logMessage( " * Number of boolean constants for tessellation domain programs: " + StringConverter::toString(mTessellationDomainProgramConstantBoolCount)); pLog->logMessage( " * Compute programs: " + StringConverter::toString(hasCapability(RSC_COMPUTE_PROGRAM), true)); pLog->logMessage( " * Number of floating-point constants for compute programs: " + StringConverter::toString(mComputeProgramConstantFloatCount)); pLog->logMessage( " * Number of integer constants for compute programs: " + StringConverter::toString(mComputeProgramConstantIntCount)); pLog->logMessage( " * Number of boolean constants for compute programs: " + StringConverter::toString(mComputeProgramConstantBoolCount)); String profileList = ""; for(ShaderProfiles::iterator iter = mSupportedShaderProfiles.begin(), end = mSupportedShaderProfiles.end(); iter != end; ++iter) { profileList += " " + *iter; } pLog->logMessage(" * Supported Shader Profiles:" + profileList); pLog->logMessage( " * Texture Compression: " + StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION), true)); if (hasCapability(RSC_TEXTURE_COMPRESSION)) { pLog->logMessage( " - DXT: " + StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_DXT), true)); pLog->logMessage( " - VTC: " + StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_VTC), true)); pLog->logMessage( " - PVRTC: " + StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_PVRTC), true)); pLog->logMessage( " - ATC: " + StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_ATC), true)); pLog->logMessage( " - ETC1: " + StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_ETC1), true)); pLog->logMessage( " - ETC2: " + StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_ETC2), true)); pLog->logMessage( " - BC4/BC5: " + StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_BC4_BC5), true)); pLog->logMessage( " - BC6H/BC7: " + StringConverter::toString(hasCapability(RSC_TEXTURE_COMPRESSION_BC6H_BC7), true)); } pLog->logMessage( " * Scissor Rectangle: " + StringConverter::toString(hasCapability(RSC_SCISSOR_TEST), true)); pLog->logMessage( " * Hardware Occlusion Query: " + StringConverter::toString(hasCapability(RSC_HWOCCLUSION), true)); pLog->logMessage( " * User clip planes: " + StringConverter::toString(hasCapability(RSC_USER_CLIP_PLANES), true)); pLog->logMessage( " * VET_UBYTE4 vertex element type: " + StringConverter::toString(hasCapability(RSC_VERTEX_FORMAT_UBYTE4), true)); pLog->logMessage( " * Infinite far plane projection: " + StringConverter::toString(hasCapability(RSC_INFINITE_FAR_PLANE), true)); pLog->logMessage( " * Hardware render-to-texture: " + StringConverter::toString(hasCapability(RSC_HWRENDER_TO_TEXTURE), true)); pLog->logMessage( " * Floating point textures: " + StringConverter::toString(hasCapability(RSC_TEXTURE_FLOAT), true)); pLog->logMessage( " * Non-power-of-two textures: " + StringConverter::toString(hasCapability(RSC_NON_POWER_OF_2_TEXTURES), true) + (mNonPOW2TexturesLimited ? " (limited)" : "")); pLog->logMessage( " * 1d textures: " + StringConverter::toString(hasCapability(RSC_TEXTURE_1D), true)); pLog->logMessage( " * Volume textures: " + StringConverter::toString(hasCapability(RSC_TEXTURE_3D), true)); pLog->logMessage( " * Multiple Render Targets: " + StringConverter::toString(mNumMultiRenderTargets)); pLog->logMessage( " - With different bit depths: " + StringConverter::toString(hasCapability(RSC_MRT_DIFFERENT_BIT_DEPTHS), true)); pLog->logMessage( " * Point Sprites: " + StringConverter::toString(hasCapability(RSC_POINT_SPRITES), true)); pLog->logMessage( " * Extended point parameters: " + StringConverter::toString(hasCapability(RSC_POINT_EXTENDED_PARAMETERS), true)); if(hasCapability(RSC_POINT_SPRITES)) { pLog->logMessage( " * Max Point Size: " + StringConverter::toString(mMaxPointSize)); } pLog->logMessage( " * Vertex texture fetch: " + StringConverter::toString(hasCapability(RSC_VERTEX_TEXTURE_FETCH), true)); pLog->logMessage( " * Number of world matrices: " + StringConverter::toString(mNumWorldMatrices)); pLog->logMessage( " * Number of texture units: " + StringConverter::toString(mNumTextureUnits)); pLog->logMessage( " * Stencil buffer depth: " + StringConverter::toString(mStencilBufferBitDepth)); pLog->logMessage( " * Number of vertex blend matrices: " + StringConverter::toString(mNumVertexBlendMatrices)); if (hasCapability(RSC_VERTEX_TEXTURE_FETCH)) { pLog->logMessage( " - Max vertex textures: " + StringConverter::toString(mNumVertexTextureUnits)); pLog->logMessage( " - Vertex textures shared: " + StringConverter::toString(mVertexTextureUnitsShared, true)); } pLog->logMessage( " * Render to Vertex Buffer : " + StringConverter::toString(hasCapability(RSC_HWRENDER_TO_VERTEX_BUFFER), true)); pLog->logMessage( " * Hardware Atomic Counters: " + StringConverter::toString(hasCapability(RSC_ATOMIC_COUNTERS), true)); if (mCategoryRelevant[CAPS_CATEGORY_GL]) { pLog->logMessage( " * GL 1.5 without VBO workaround: " + StringConverter::toString(hasCapability(RSC_GL1_5_NOVBO), true)); pLog->logMessage( " * Frame Buffer objects: " + StringConverter::toString(hasCapability(RSC_FBO), true)); pLog->logMessage( " * Frame Buffer objects (ARB extension): " + StringConverter::toString(hasCapability(RSC_FBO_ARB), true)); pLog->logMessage( " * Frame Buffer objects (ATI extension): " + StringConverter::toString(hasCapability(RSC_FBO_ATI), true)); pLog->logMessage( " * PBuffer support: " + StringConverter::toString(hasCapability(RSC_PBUFFER), true)); pLog->logMessage( " * GL 1.5 without HW-occlusion workaround: " + StringConverter::toString(hasCapability(RSC_GL1_5_NOHWOCCLUSION), true)); pLog->logMessage( " * Vertex Array Objects: " + StringConverter::toString(hasCapability(RSC_VAO), true)); pLog->logMessage( " * Separate shader objects: " + StringConverter::toString(hasCapability(RSC_SEPARATE_SHADER_OBJECTS), true)); } if (mCategoryRelevant[CAPS_CATEGORY_D3D9]) { pLog->logMessage( " * DirectX per stage constants: " + StringConverter::toString(hasCapability(RSC_PERSTAGECONSTANT), true)); } #endif }
void DiGfxCaps::LogCaps() { DI_INFO("-------------------------"); DI_INFO("--Graphics capabilities--"); DI_INFO("-------------------------"); DI_INFO("GfxDriver: %s", getRenderSystemName().c_str()); DI_INFO("GPU Vendor: %s", vendorToString(getVendor()).c_str()); DI_INFO("Device Name: %s", getDeviceName().c_str()); DI_INFO("Driver Version: %s", getDriverVersion().toString().c_str()); DI_INFO(" * Hardware generation of mipmaps: %s", _BoolToStr(hasCapability(RSC_AUTOMIPMAP))); DI_INFO(" * Anisotropic texture filtering: %s", _BoolToStr(hasCapability(RSC_ANISOTROPY))); DI_INFO(" * Hardware stencil buffer: %s", _BoolToStr(hasCapability(RSC_HWSTENCIL))); if (hasCapability(RSC_HWSTENCIL)) { DI_INFO(" - Stencil depth: %d", getStencilBufferBitDepth()); DI_INFO(" - Two sided stencil support: %s", _BoolToStr(hasCapability(RSC_TWO_SIDED_STENCIL))); DI_INFO(" - Wrap stencil values: %s", _BoolToStr(hasCapability(RSC_STENCIL_WRAP))); } DI_INFO(" * 32-bit index buffers: %s", +_BoolToStr(hasCapability(RSC_32BIT_INDEX))); DI_INFO(" * Vertex shader: %s", _BoolToStr(hasCapability(RSC_VERTEX_PROGRAM))); DI_INFO(" * Number of float constants for vertex shader: %d", mVertexProgramConstantFloatCount); DI_INFO(" * Number of int constants for vertex shader: %d", mVertexProgramConstantIntCount); DI_INFO(" * Number of bool constants for vertex shader: %d", mVertexProgramConstantBoolCount); DI_INFO(" * Fragment shader: %s", _BoolToStr(hasCapability(RSC_FRAGMENT_PROGRAM))); DI_INFO(" * Number of float constants for fragment shader: %d", mFragmentProgramConstantFloatCount); DI_INFO(" * Number of int constants for fragment shader: %d", mFragmentProgramConstantIntCount); DI_INFO(" * Number of bool constants for fragment shader: %d", mFragmentProgramConstantBoolCount); DiString profileList = ""; for(ShaderProfiles::iterator iter = mSupportedShaderProfiles.begin(), end = mSupportedShaderProfiles.end(); iter != end; ++iter) { profileList += " " + *iter; } DI_INFO(" * Supported Shader Profiles: %s", profileList.c_str()); DI_INFO(" * Texture Compression: ", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION))); if (hasCapability(RSC_TEXTURE_COMPRESSION)) { DI_INFO(" - DXT: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_DXT))); DI_INFO(" - VTC: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_VTC))); DI_INFO(" - PVRTC: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_PVRTC))); DI_INFO(" - ATC: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_ATC))); DI_INFO(" - ETC1: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_ETC1))); DI_INFO(" - ETC2: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_ETC2))); DI_INFO(" - BC4/BC5: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_BC4_BC5))); DI_INFO(" - BC6H/BC7: %s", _BoolToStr(hasCapability(RSC_TEXTURE_COMPRESSION_BC6H_BC7))); } DI_INFO(" * Scissor Rectangle: %s", _BoolToStr(hasCapability(RSC_SCISSOR_TEST))); DI_INFO(" * Hardware Occlusion Query: %s", _BoolToStr(hasCapability(RSC_HWOCCLUSION))); DI_INFO(" * User clip planes: %s", _BoolToStr(hasCapability(RSC_USER_CLIP_PLANES))); DI_INFO(" * VET_UBYTE4 vertex element type: %s", _BoolToStr(hasCapability(RSC_VERTEX_FORMAT_UBYTE4))); DI_INFO(" * Infinite far plane projection: %s", _BoolToStr(hasCapability(RSC_INFINITE_FAR_PLANE))); DI_INFO(" * Hardware render-to-texture: %s", _BoolToStr(hasCapability(RSC_HWRENDER_TO_TEXTURE))); DI_INFO(" * Floating point textures: %s", _BoolToStr(hasCapability(RSC_TEXTURE_FLOAT))); DI_INFO(" * Non-power-of-two textures: %s %s", _BoolToStr(hasCapability(RSC_NON_POWER_OF_2_TEXTURES)),(mNonPOW2TexturesLimited ? " (limited)" : "")); DI_INFO(" * 1D textures: %s", _BoolToStr(hasCapability(RSC_TEXTURE_1D))); DI_INFO(" * 3D textures: %s", _BoolToStr(hasCapability(RSC_TEXTURE_3D))); DI_INFO(" * Multiple Render Targets: %d", mNumMultiRenderTargets); DI_INFO(" - With different bit depths: %s", _BoolToStr(hasCapability(RSC_MRT_DIFFERENT_BIT_DEPTHS))); DI_INFO(" * Vertex texture fetch: %s", _BoolToStr(hasCapability(RSC_VERTEX_TEXTURE_FETCH))); DI_INFO(" * Number of world matrices: %d", mNumWorldMatrices); DI_INFO(" * Number of texture units: %d", mNumTextureUnits); DI_INFO(" * Stencil buffer depth: %d", mStencilBufferBitDepth); DI_INFO(" * Number of vertex blend matrices: %d", mNumVertexBlendMatrices); DI_INFO(" * Render to Vertex Buffer : %s", _BoolToStr(hasCapability(RSC_HWRENDER_TO_VERTEX_BUFFER))); DI_INFO(" * Hardware Atomic Counters: %s", _BoolToStr(hasCapability(RSC_ATOMIC_COUNTERS))); if (mCategoryRelevant[CAPS_CATEGORY_GL]) { DI_INFO(" * GL 1.5 without VBO workaround: %s" , _BoolToStr(hasCapability(RSC_GL1_5_NOVBO))); DI_INFO(" * Frame Buffer objects: %s" , _BoolToStr(hasCapability(RSC_FBO))); DI_INFO(" * Frame Buffer objects (ARB extension): %s" , _BoolToStr(hasCapability(RSC_FBO_ARB))); DI_INFO(" * Frame Buffer objects (ATI extension): %s" , _BoolToStr(hasCapability(RSC_FBO_ATI))); DI_INFO(" * PBuffer support: %s" , _BoolToStr(hasCapability(RSC_PBUFFER))); DI_INFO(" * GL 1.5 without HW-occlusion workaround: %s" , _BoolToStr(hasCapability(RSC_GL1_5_NOHWOCCLUSION))); DI_INFO(" * Vertex Array Objects: %s" , _BoolToStr(hasCapability(RSC_VAO))); DI_INFO(" * Separate shader objects: %s" , _BoolToStr(hasCapability(RSC_SEPARATE_SHADER_OBJECTS))); } if (mCategoryRelevant[CAPS_CATEGORY_D3D9]) { DI_INFO(" * DirectX per stage constants: %s", _BoolToStr(hasCapability(RSC_PERSTAGECONSTANT))); } }
GpuCapabilitiesWindows::FileVersion GpuCapabilitiesWindows::getDriverVersion() { FileVersion fileVersion; fileVersion.versionString = ""; // Try to get driver file version if ( GpuCapabilities::getVendor() == GPU_VENDOR_NVIDIA ) { // Get fileversion of NVIDIA OpenGL dll LDEBUG("Reading file version of NVIDIA driver dll ... "); FileVersion fileVersion; //TODO: windows vista stores the name of the dll in the registry. // its better to get the name from there (cdoer) if (getOSVersion() == OS_WIN_VISTA) fileVersion = getFileVersion("nvoglv32.dll"); else fileVersion = getFileVersion(DRIVER_DLL_NVIDIA); if (fileVersion.versionString.length() == 0) { LDEBUG("Reading NVIDIA driver version failed."); } else { LDEBUG("Reading driver version successful."); return fileVersion; } } else if (getVendor() == GPU_VENDOR_ATI) { // Get fileversion of ATI OpenGL dll LDEBUG("Reading file version of ATI driver dll ... "); FileVersion fileVersion = getFileVersion(DRIVER_DLL_ATI); if ( fileVersion.versionString.length() == 0 ) { LDEBUG("Reading ATI driver version failed."); } else { LDEBUG("Reading driver version successful."); return fileVersion; } } #ifdef CGT_WITH_WMI // unknown graphics board vendor or reading NVIDIA/Ati driver version failed: // get driver version from WMI LDEBUG("Reading driver version from WMI ..."); // Win32_VideoController class: http://msdn2.microsoft.com/en-us/library/aa394512.aspx std::string version = WMIqueryStr("Win32_VideoController", "DriverVersion"); if (version.length() == 0) { LDEBUG("Failed to retrieve driver version from WMI."); LWARNING("Failed to detect driver version."); } else { fileVersion.versionString = version; // do not parse driver version string since it is not necessarily a file version string fileVersion.d1 = 0; fileVersion.d2 = 0; fileVersion.d3 = 0; fileVersion.d4 = 0; fileVersion.version = 0; LDEBUG("Successfully read driver version from WMI"); } return fileVersion; #else LDEBUG("Compiled without WMI support."); LWARNING("Failed to detect driver version."); return fileVersion; #endif }
std::string GpuCapabilitiesWindows::getDriverDate() { LDEBUG("Retrieving driver date ..."); if ( getVendor() == GPU_VENDOR_NVIDIA ) { LDEBUG("Retrieving driver date by querying file date of NVIDIA driver dll ..."); std::string result; //TODO: windows vista stores the name of the dll in the registry. // its better to get the name from there (cdoer) if (getOSVersion() == OS_WIN_VISTA) result = getFileDate("nvoglv32.dll"); else result = getFileDate(DRIVER_DLL_NVIDIA); if (result.length() == 0) { LDEBUG("Failed reading driver date from NVIDIA driver dll."); } else { LDEBUG("Reading driver date successful."); return result; } } else if (getVendor() == GPU_VENDOR_ATI) { LDEBUG("Retrieving driver date by querying file date of ATI driver dll ..."); std::string result = getFileDate(DRIVER_DLL_ATI); if (result.length() == 0) { LDEBUG("Failed reading driver date from ATI driver dll."); } else { LDEBUG("Reading driver date successful."); return result; } } #ifdef CGT_WITH_WMI // unknown vendor or reading driver date from vendor dll failed: // read driver date from WMI LDEBUG("Reading driver date from WMI ..."); if (isWMIinited()) { // Win32_VideoController class: http://msdn2.microsoft.com/en-us/library/aa394512.aspx std::string date = WMIqueryStr("Win32_VideoController", "DriverDate"); if (date.length() > 0) { LDEBUG("Reading driver date successful."); // convert to yyyy-mm-dd format. // see http://msdn2.microsoft.com/en-us/library/aa387237.aspx for specification of CIM_DATETIME std::string dateformat = ""; dateformat.append(date.substr(0,4)); dateformat.append("-"); dateformat.append(date.substr(4,2)); dateformat.append("-"); dateformat.append(date.substr(6,2)); return dateformat; } else { LDEBUG("Failed reading driver date."); LWARNING("Failed to detect driver date"); return ""; } } else { LDEBUG("Unable to read DriverDate from WMI: not inited"); } #else LDEBUG("Compiled without WMI support."); LWARNING("Failed to detect driver date"); #endif return ""; }
DeviceItem * PlatformUdisks::getNewDevice(QString devicePath) { QString path, model, vendor; DeviceItem *devItem = new DeviceItem; path = getPath(devicePath); if (path == "") return(NULL); if (!getIsDrive(devicePath)) return(NULL); model = getModel(devicePath); vendor = getVendor(devicePath); devItem->setUDI(devicePath); devItem->setPath(path); devItem->setIsRemovable(getIsRemovable(devicePath)); devItem->setSize(getSize(devicePath)); devItem->setModelString(model); if (vendor == "") { if (mKioskMode) devItem->setVendorString("SUSE Studio USB Key"); else devItem->setVendorString("Unknown Device"); } else { devItem->setVendorString(vendor); } QString newDisplayString = QString("%1 %2 - %3 (%4 MB)") .arg(devItem->getVendorString()) .arg(devItem->getModelString()) .arg(devItem->getPath()) .arg(devItem->getSize() / 1048576); devItem->setDisplayString(newDisplayString); if (mKioskMode) { if((devItem->getSize() / 1048576) > 200000) { delete devItem; return(NULL); } } // If a device is 0 megs we might as well just not list it if ((devItem->getSize() / 1048576) > 0) { itemList << devItem; } else { delete devItem; devItem = NULL; } return(devItem); }
void oglx_caps_t::report(oglx_caps_t& self) { auto& renderer = Ego::Renderer::get(); Log::Entry e(Log::Level::Info, __FILE__, __LINE__); { const auto info = renderer.getInfo(); e << "OpenGL" << Log::EndOfLine << " version = " << info.getVersion() << Log::EndOfLine << " vendor = " << info.getVendor() << Log::EndOfLine << " renderer = " << info.getRenderer() << Log::EndOfLine; e << " extensions ="; for (const auto& extension : self.gl_extensions) { e << " " << extension; } e << Log::EndOfLine; } #if 0 Log::get().message("\tGL_MAX_MODELVIEW_STACK_DEPTH == %d\n", self.max_modelview_stack_depth); Log::get().message("\tGL_MAX_PROJECTION_STACK_DEPTH == %d\n", self.max_projection_stack_depth); Log::get().message("\tGL_MAX_TEXTURE_STACK_DEPTH == %d\n", self.max_texture_stack_depth); Log::get().message("\tGL_MAX_NAME_STACK_DEPTH == %d\n", self.max_name_stack_depth); Log::get().message("\tGL_MAX_ATTRIB_STACK_DEPTH == %d\n", self.max_attrib_stack_depth); Log::get().message("\tGL_MAX_CLIENT_ATTRIB_STACK_DEPTH == %d\n\n", self.max_client_attrib_stack_depth); #endif #if 0 Log::get().message("\tGL_SUBPIXEL_BITS == %d\n", self.subpixel_bits); Log::get().message("\tGL_POINT_SIZE_RANGE == %f - %f\n", self.point_size_range[0], self.point_size_range[1]); Log::get().message("\tGL_POINT_SIZE_GRANULARITY == %f\n", self.point_size_granularity); Log::get().message("\tGL_LINE_WIDTH_RANGE == %f - %f\n", self.line_width_range[0], self.line_width_range[1]); Log::get().message("\tGL_LINE_WIDTH_GRANULARITY == %f\n\n", self.line_width_granularity); #endif #if 0 Log::get().message("\tGL_MAX_VIEWPORT_DIMS == %d, %d\n", self.max_viewport_dims[0], self.max_viewport_dims[1]); Log::get().message("\tGL_AUX_BUFFERS == %d\n", self.aux_buffers); Log::get().message("\tGL_RGBA_MODE == %s\n", self.rgba_mode ? "TRUE" : "FALSE"); Log::get().message("\tGL_INDEX_MODE == %s\n", self.index_mode ? "TRUE" : "FALSE"); Log::get().message("\tGL_DOUBLEBUFFER == %s\n", self.doublebuffer ? "TRUE" : "FALSE"); Log::get().message("\tGL_STEREO == %s\n", self.stereo ? "TRUE" : "FALSE"); #endif { // Print the colour buffer colour depth. const auto colourDepth = renderer.getColourBuffer().getColourDepth(); e << " Colour Buffer Colour Depth:" << Log::EndOfLine << " " << "red bits = " << colourDepth.getRedDepth() << Log::EndOfLine << " " << "green bits = " << colourDepth.getGreenDepth() << Log::EndOfLine << " " << "blue bits = " << colourDepth.getBlueDepth() << Log::EndOfLine << " " << "alpha bits = " << colourDepth.getAlphaDepth() << Log::EndOfLine; } { // Print the accumulation buffer colour depth. const auto colourDepth = renderer.getAccumulationBuffer().getColourDepth(); e << " Accumulation Buffer Colour Depth:" << Log::EndOfLine << " " << "red bits = " << colourDepth.getRedDepth() << Log::EndOfLine << " " << "green bits = " << colourDepth.getGreenDepth() << Log::EndOfLine << " " << "blue bits = " << colourDepth.getBlueDepth() << Log::EndOfLine << " " << "alpha bits = " << colourDepth.getAlphaDepth() << Log::EndOfLine; } { // Print depth buffer and stencil buffer depth. e << " Depth Buffer Depth:" << renderer.getDepthBuffer().getDepth() << Log::EndOfLine; e << " Stencil Buffer Depth:" << renderer.getStencilBuffer().getDepth() << Log::EndOfLine; } #if 0 Log::get().message("\tGL_INDEX_BITS == %d\n", self.index_bits); #endif #if 0 Log::get().message("\tGL_MAX_LIGHTS == %d\n", self.max_lights); Log::get().message("\tGL_MAX_CLIP_PLANES == %d\n", self.max_clip_planes); Log::get().message("\tGL_MAX_TEXTURE_SIZE == %d\n\n", self.max_texture_size); Log::get().message("\tGL_MAX_PIXEL_MAP_TABLE == %d\n", self.max_pixel_map_table); Log::get().message("\tGL_MAX_LIST_NESTING == %d\n", self.max_list_nesting); Log::get().message("\tGL_MAX_EVAL_ORDER == %d\n\n", self.max_eval_order); if (self.anisotropic_supported) { Log::get().message("\tGL_MAX_TEXTURE_MAX_ANISOTROPY_EXT == %f\n", self.maxAnisotropy); } Log::get().message("==============================================================\n"); #endif e << Log::EndOfEntry; Log::get() << e; }
QString DeviceInfo::getDescription() const { return getUART() + ':' + QString::number(getID()) + '(' + getVendor() + '.' + getProduct() + '.' + getVersion() + ')'; }