mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-02-02 08:54:15 +00:00
53beda526b
bSupports2DTextureStorageMultisample is completely unused, while bSupports3DTextureStorageMultisample is practically unused. In the past, these were checked and fell back to sampler2DMS instead of sampler2DMSArray on GLES 3.1, but this path was removed in f039149198657c1891e1c6462ed30c31ed4b8486 and Dolphin always uses array textures now.
627 lines
26 KiB
C++
627 lines
26 KiB
C++
// Copyright 2023 Dolphin Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "VideoBackends/OGL/OGLConfig.h"
|
|
|
|
#include "Common/GL/GLContext.h"
|
|
#include "Common/GL/GLExtensions/GLExtensions.h"
|
|
#include "Common/Logging/LogManager.h"
|
|
#include "Common/MsgHandler.h"
|
|
|
|
#include "Core/Config/GraphicsSettings.h"
|
|
|
|
#include "VideoCommon/DriverDetails.h"
|
|
#include "VideoCommon/OnScreenDisplay.h"
|
|
#include "VideoCommon/VideoConfig.h"
|
|
|
|
#include <cstdio>
|
|
#include <string>
|
|
#include <string_view>
|
|
|
|
namespace OGL
|
|
{
|
|
void InitDriverInfo()
|
|
{
|
|
const std::string_view svendor(g_ogl_config.gl_vendor);
|
|
const std::string_view srenderer(g_ogl_config.gl_renderer);
|
|
const std::string_view sversion(g_ogl_config.gl_version);
|
|
DriverDetails::Vendor vendor = DriverDetails::VENDOR_UNKNOWN;
|
|
DriverDetails::Driver driver = DriverDetails::DRIVER_UNKNOWN;
|
|
DriverDetails::Family family = DriverDetails::Family::UNKNOWN;
|
|
double version = 0.0;
|
|
|
|
// Get the vendor first
|
|
if (svendor == "NVIDIA Corporation")
|
|
{
|
|
if (srenderer != "NVIDIA Tegra")
|
|
{
|
|
vendor = DriverDetails::VENDOR_NVIDIA;
|
|
}
|
|
else
|
|
{
|
|
vendor = DriverDetails::VENDOR_TEGRA;
|
|
}
|
|
}
|
|
else if (svendor == "ATI Technologies Inc." || svendor == "Advanced Micro Devices, Inc.")
|
|
{
|
|
vendor = DriverDetails::VENDOR_ATI;
|
|
}
|
|
else if (sversion.find("Mesa") != std::string::npos)
|
|
{
|
|
vendor = DriverDetails::VENDOR_MESA;
|
|
}
|
|
else if (svendor.find("Intel") != std::string::npos)
|
|
{
|
|
vendor = DriverDetails::VENDOR_INTEL;
|
|
}
|
|
else if (svendor == "ARM")
|
|
{
|
|
vendor = DriverDetails::VENDOR_ARM;
|
|
}
|
|
else if (svendor == "http://limadriver.org/")
|
|
{
|
|
vendor = DriverDetails::VENDOR_ARM;
|
|
driver = DriverDetails::DRIVER_LIMA;
|
|
}
|
|
else if (svendor == "Qualcomm")
|
|
{
|
|
vendor = DriverDetails::VENDOR_QUALCOMM;
|
|
}
|
|
else if (svendor == "Imagination Technologies")
|
|
{
|
|
vendor = DriverDetails::VENDOR_IMGTEC;
|
|
}
|
|
else if (svendor == "Vivante Corporation")
|
|
{
|
|
vendor = DriverDetails::VENDOR_VIVANTE;
|
|
}
|
|
|
|
// Get device family and driver version...if we care about it
|
|
switch (vendor)
|
|
{
|
|
case DriverDetails::VENDOR_QUALCOMM:
|
|
{
|
|
driver = DriverDetails::DRIVER_QUALCOMM;
|
|
double glVersion;
|
|
sscanf(g_ogl_config.gl_version, "OpenGL ES %lg V@%lg", &glVersion, &version);
|
|
}
|
|
break;
|
|
case DriverDetails::VENDOR_ARM:
|
|
// Currently the Mali-T line has two families in it.
|
|
// Mali-T6xx and Mali-T7xx
|
|
// These two families are similar enough that they share bugs in their drivers.
|
|
//
|
|
// Mali drivers provide no way to explicitly find out what video driver is running.
|
|
// This is similar to how we can't find the Nvidia driver version in Windows.
|
|
// Good thing is that ARM introduces a new video driver about once every two years so we can
|
|
// find the driver version by the features it exposes.
|
|
// r2p0 - No OpenGL ES 3.0 support (We don't support this)
|
|
// r3p0 - OpenGL ES 3.0 support
|
|
// r4p0 - Supports 'GL_EXT_shader_pixel_local_storage' extension.
|
|
|
|
driver = DriverDetails::DRIVER_ARM;
|
|
if (GLExtensions::Supports("GL_EXT_shader_pixel_local_storage"))
|
|
version = 400;
|
|
else
|
|
version = 300;
|
|
break;
|
|
case DriverDetails::VENDOR_MESA:
|
|
{
|
|
if (svendor == "nouveau")
|
|
{
|
|
driver = DriverDetails::DRIVER_NOUVEAU;
|
|
}
|
|
else if (svendor == "Intel Open Source Technology Center")
|
|
{
|
|
driver = DriverDetails::DRIVER_I965;
|
|
if (srenderer.find("Sandybridge") != std::string::npos)
|
|
family = DriverDetails::Family::INTEL_SANDY;
|
|
else if (srenderer.find("Ivybridge") != std::string::npos)
|
|
family = DriverDetails::Family::INTEL_IVY;
|
|
}
|
|
else if (srenderer.find("AMD") != std::string::npos ||
|
|
srenderer.find("ATI") != std::string::npos)
|
|
{
|
|
driver = DriverDetails::DRIVER_R600;
|
|
}
|
|
|
|
int major = 0;
|
|
int minor = 0;
|
|
int release = 0;
|
|
sscanf(g_ogl_config.gl_version, "%*s (Core Profile) Mesa %d.%d.%d", &major, &minor, &release);
|
|
version = 100 * major + 10 * minor + release;
|
|
}
|
|
break;
|
|
case DriverDetails::VENDOR_INTEL: // Happens in OS X/Windows
|
|
{
|
|
u32 market_name;
|
|
sscanf(g_ogl_config.gl_renderer, "Intel HD Graphics %d", &market_name);
|
|
switch (market_name)
|
|
{
|
|
case 2000:
|
|
case 3000:
|
|
family = DriverDetails::Family::INTEL_SANDY;
|
|
break;
|
|
case 2500:
|
|
case 4000:
|
|
family = DriverDetails::Family::INTEL_IVY;
|
|
break;
|
|
default:
|
|
family = DriverDetails::Family::UNKNOWN;
|
|
break;
|
|
};
|
|
#ifdef _WIN32
|
|
int glmajor = 0;
|
|
int glminor = 0;
|
|
int major = 0;
|
|
int minor = 0;
|
|
int release = 0;
|
|
int revision = 0;
|
|
// Example version string: '4.3.0 - Build 10.18.10.3907'
|
|
sscanf(g_ogl_config.gl_version, "%d.%d.0 - Build %d.%d.%d.%d", &glmajor, &glminor, &major,
|
|
&minor, &release, &revision);
|
|
version = 100000000 * major + 1000000 * minor + 10000 * release + revision;
|
|
version /= 10000;
|
|
#endif
|
|
}
|
|
break;
|
|
case DriverDetails::VENDOR_NVIDIA:
|
|
{
|
|
int glmajor = 0;
|
|
int glminor = 0;
|
|
int glrelease = 0;
|
|
int major = 0;
|
|
int minor = 0;
|
|
// TODO: this is known to be broken on Windows
|
|
// Nvidia seems to have removed their driver version from this string, so we can't get it.
|
|
// hopefully we'll never have to workaround Nvidia bugs
|
|
sscanf(g_ogl_config.gl_version, "%d.%d.%d NVIDIA %d.%d", &glmajor, &glminor, &glrelease, &major,
|
|
&minor);
|
|
version = 100 * major + minor;
|
|
}
|
|
break;
|
|
case DriverDetails::VENDOR_IMGTEC:
|
|
{
|
|
// Example version string:
|
|
// "OpenGL ES 3.2 build 1.9@4850625"
|
|
// Ends up as "109.4850625" - "1.9" being the branch, "4850625" being the build's change ID
|
|
// The change ID only makes sense to compare within a branch
|
|
driver = DriverDetails::DRIVER_IMGTEC;
|
|
double gl_version;
|
|
int major, minor, change;
|
|
constexpr double change_scale = 10000000;
|
|
sscanf(g_ogl_config.gl_version, "OpenGL ES %lg build %d.%d@%d", &gl_version, &major, &minor,
|
|
&change);
|
|
version = 100 * major + minor;
|
|
if (change >= change_scale)
|
|
{
|
|
ERROR_LOG_FMT(VIDEO, "Version changeID overflow - change:{} scale:{}", change, change_scale);
|
|
}
|
|
else
|
|
{
|
|
version += static_cast<double>(change) / change_scale;
|
|
}
|
|
}
|
|
break;
|
|
// We don't care about these
|
|
default:
|
|
break;
|
|
}
|
|
DriverDetails::Init(DriverDetails::API_OPENGL, vendor, driver, version, family);
|
|
}
|
|
|
|
bool PopulateConfig(GLContext* m_main_gl_context)
|
|
{
|
|
bool bSuccess = true;
|
|
bool supports_glsl_cache = false;
|
|
|
|
g_ogl_config.gl_vendor = (const char*)glGetString(GL_VENDOR);
|
|
g_ogl_config.gl_renderer = (const char*)glGetString(GL_RENDERER);
|
|
g_ogl_config.gl_version = (const char*)glGetString(GL_VERSION);
|
|
|
|
if (!m_main_gl_context->IsGLES())
|
|
{
|
|
if (!GLExtensions::Supports("GL_ARB_framebuffer_object"))
|
|
{
|
|
// We want the ogl3 framebuffer instead of the ogl2 one for better blitting support.
|
|
// It's also compatible with the gles3 one.
|
|
PanicAlertFmtT("GPU: ERROR: Need GL_ARB_framebuffer_object for multiple render targets.\n"
|
|
"GPU: Does your video card support OpenGL 3.0?");
|
|
bSuccess = false;
|
|
}
|
|
|
|
if (!GLExtensions::Supports("GL_ARB_vertex_array_object"))
|
|
{
|
|
// This extension is used to replace lots of pointer setting function.
|
|
// Also gles3 requires to use it.
|
|
PanicAlertFmtT("GPU: OGL ERROR: Need GL_ARB_vertex_array_object.\n"
|
|
"GPU: Does your video card support OpenGL 3.0?");
|
|
bSuccess = false;
|
|
}
|
|
|
|
if (!GLExtensions::Supports("GL_ARB_map_buffer_range"))
|
|
{
|
|
// ogl3 buffer mapping for better streaming support.
|
|
// The ogl2 one also isn't in gles3.
|
|
PanicAlertFmtT("GPU: OGL ERROR: Need GL_ARB_map_buffer_range.\n"
|
|
"GPU: Does your video card support OpenGL 3.0?");
|
|
bSuccess = false;
|
|
}
|
|
|
|
if (!GLExtensions::Supports("GL_ARB_uniform_buffer_object"))
|
|
{
|
|
// ubo allow us to keep the current constants on shader switches
|
|
// we also can stream them much nicer and pack into it whatever we want to
|
|
PanicAlertFmtT("GPU: OGL ERROR: Need GL_ARB_uniform_buffer_object.\n"
|
|
"GPU: Does your video card support OpenGL 3.1?");
|
|
bSuccess = false;
|
|
}
|
|
else if (DriverDetails::HasBug(DriverDetails::BUG_BROKEN_UBO))
|
|
{
|
|
PanicAlertFmtT(
|
|
"Buggy GPU driver detected.\n"
|
|
"Please either install the closed-source GPU driver or update your Mesa 3D version.");
|
|
bSuccess = false;
|
|
}
|
|
|
|
if (!GLExtensions::Supports("GL_ARB_sampler_objects"))
|
|
{
|
|
// Our sampler cache uses this extension. It could easyly be workaround and it's by far the
|
|
// highest requirement, but it seems that no driver lacks support for it.
|
|
PanicAlertFmtT("GPU: OGL ERROR: Need GL_ARB_sampler_objects.\n"
|
|
"GPU: Does your video card support OpenGL 3.3?");
|
|
bSuccess = false;
|
|
}
|
|
}
|
|
|
|
// Copy the GPU name to g_Config, so Analytics can see it.
|
|
g_Config.backend_info.AdapterName = g_ogl_config.gl_renderer;
|
|
|
|
g_Config.backend_info.bSupportsDualSourceBlend =
|
|
(GLExtensions::Supports("GL_ARB_blend_func_extended") ||
|
|
GLExtensions::Supports("GL_EXT_blend_func_extended"));
|
|
g_Config.backend_info.bSupportsPrimitiveRestart =
|
|
!DriverDetails::HasBug(DriverDetails::BUG_PRIMITIVE_RESTART) &&
|
|
((GLExtensions::Version() >= 310) || GLExtensions::Supports("GL_NV_primitive_restart"));
|
|
g_Config.backend_info.bSupportsFragmentStoresAndAtomics =
|
|
GLExtensions::Supports("GL_ARB_shader_storage_buffer_object");
|
|
g_Config.backend_info.bSupportsVSLinePointExpand =
|
|
GLExtensions::Supports("GL_ARB_shader_storage_buffer_object");
|
|
g_Config.backend_info.bSupportsGSInstancing = GLExtensions::Supports("GL_ARB_gpu_shader5");
|
|
g_Config.backend_info.bSupportsSSAA = GLExtensions::Supports("GL_ARB_gpu_shader5") &&
|
|
GLExtensions::Supports("GL_ARB_sample_shading");
|
|
g_Config.backend_info.bSupportsGeometryShaders =
|
|
GLExtensions::Version() >= 320 &&
|
|
!DriverDetails::HasBug(DriverDetails::BUG_BROKEN_GEOMETRY_SHADERS);
|
|
g_Config.backend_info.bSupportsPaletteConversion =
|
|
GLExtensions::Supports("GL_ARB_texture_buffer_object") ||
|
|
GLExtensions::Supports("GL_OES_texture_buffer") ||
|
|
GLExtensions::Supports("GL_EXT_texture_buffer");
|
|
g_Config.backend_info.bSupportsClipControl = GLExtensions::Supports("GL_ARB_clip_control");
|
|
g_ogl_config.bSupportsCopySubImage =
|
|
(GLExtensions::Supports("GL_ARB_copy_image") || GLExtensions::Supports("GL_NV_copy_image") ||
|
|
GLExtensions::Supports("GL_EXT_copy_image") ||
|
|
GLExtensions::Supports("GL_OES_copy_image")) &&
|
|
!DriverDetails::HasBug(DriverDetails::BUG_BROKEN_COPYIMAGE);
|
|
g_ogl_config.bSupportsTextureSubImage = GLExtensions::Supports("ARB_get_texture_sub_image");
|
|
|
|
// Desktop OpenGL supports the binding layout if it supports 420pack
|
|
// OpenGL ES 3.1 supports it implicitly without an extension
|
|
g_Config.backend_info.bSupportsBindingLayout =
|
|
GLExtensions::Supports("GL_ARB_shading_language_420pack");
|
|
|
|
// Clip distance support is useless without a method to clamp the depth range
|
|
g_Config.backend_info.bSupportsDepthClamp = GLExtensions::Supports("GL_ARB_depth_clamp");
|
|
|
|
// Desktop OpenGL supports bitfield manulipation and dynamic sampler indexing if it supports
|
|
// shader5. OpenGL ES 3.1 supports it implicitly without an extension
|
|
g_Config.backend_info.bSupportsBitfield = GLExtensions::Supports("GL_ARB_gpu_shader5");
|
|
g_Config.backend_info.bSupportsDynamicSamplerIndexing =
|
|
GLExtensions::Supports("GL_ARB_gpu_shader5");
|
|
|
|
g_ogl_config.bIsES = m_main_gl_context->IsGLES();
|
|
supports_glsl_cache = GLExtensions::Supports("GL_ARB_get_program_binary");
|
|
g_ogl_config.bSupportsGLPinnedMemory = GLExtensions::Supports("GL_AMD_pinned_memory");
|
|
g_ogl_config.bSupportsGLSync = GLExtensions::Supports("GL_ARB_sync");
|
|
g_ogl_config.bSupportsGLBaseVertex = GLExtensions::Supports("GL_ARB_draw_elements_base_vertex") ||
|
|
GLExtensions::Supports("GL_EXT_draw_elements_base_vertex") ||
|
|
GLExtensions::Supports("GL_OES_draw_elements_base_vertex");
|
|
g_ogl_config.bSupportsGLBufferStorage = GLExtensions::Supports("GL_ARB_buffer_storage") ||
|
|
GLExtensions::Supports("GL_EXT_buffer_storage");
|
|
g_ogl_config.bSupportsMSAA = GLExtensions::Supports("GL_ARB_texture_multisample");
|
|
g_ogl_config.bSupportViewportFloat = GLExtensions::Supports("GL_ARB_viewport_array");
|
|
g_ogl_config.bSupportsDebug =
|
|
GLExtensions::Supports("GL_KHR_debug") || GLExtensions::Supports("GL_ARB_debug_output");
|
|
g_ogl_config.bSupportsTextureStorage = GLExtensions::Supports("GL_ARB_texture_storage");
|
|
g_ogl_config.bSupportsImageLoadStore = GLExtensions::Supports("GL_ARB_shader_image_load_store");
|
|
g_ogl_config.bSupportsConservativeDepth = GLExtensions::Supports("GL_ARB_conservative_depth");
|
|
g_ogl_config.bSupportsAniso = GLExtensions::Supports("GL_EXT_texture_filter_anisotropic");
|
|
g_Config.backend_info.bSupportsComputeShaders = GLExtensions::Supports("GL_ARB_compute_shader");
|
|
g_Config.backend_info.bSupportsST3CTextures =
|
|
GLExtensions::Supports("GL_EXT_texture_compression_s3tc");
|
|
g_Config.backend_info.bSupportsBPTCTextures =
|
|
GLExtensions::Supports("GL_ARB_texture_compression_bptc");
|
|
g_Config.backend_info.bSupportsCoarseDerivatives =
|
|
GLExtensions::Supports("GL_ARB_derivative_control") || GLExtensions::Version() >= 450;
|
|
g_Config.backend_info.bSupportsTextureQueryLevels =
|
|
GLExtensions::Supports("GL_ARB_texture_query_levels") || GLExtensions::Version() >= 430;
|
|
|
|
if (GLExtensions::Supports("GL_EXT_shader_framebuffer_fetch"))
|
|
{
|
|
g_ogl_config.SupportedFramebufferFetch = EsFbFetchType::FbFetchExt;
|
|
}
|
|
else if (GLExtensions::Supports("GL_ARM_shader_framebuffer_fetch"))
|
|
{
|
|
g_ogl_config.SupportedFramebufferFetch = EsFbFetchType::FbFetchArm;
|
|
}
|
|
else
|
|
{
|
|
g_ogl_config.SupportedFramebufferFetch = EsFbFetchType::FbFetchNone;
|
|
}
|
|
g_Config.backend_info.bSupportsFramebufferFetch =
|
|
g_ogl_config.SupportedFramebufferFetch != EsFbFetchType::FbFetchNone;
|
|
|
|
if (m_main_gl_context->IsGLES())
|
|
{
|
|
g_ogl_config.SupportedESPointSize =
|
|
GLExtensions::Supports("GL_OES_geometry_point_size") ? EsPointSizeType::PointSizeOes :
|
|
GLExtensions::Supports("GL_EXT_geometry_point_size") ? EsPointSizeType::PointSizeExt :
|
|
EsPointSizeType::PointSizeNone;
|
|
g_ogl_config.SupportedESTextureBuffer =
|
|
GLExtensions::Supports("VERSION_GLES_3_2") ? EsTexbufType::TexbufCore :
|
|
GLExtensions::Supports("GL_OES_texture_buffer") ? EsTexbufType::TexbufOes :
|
|
GLExtensions::Supports("GL_EXT_texture_buffer") ? EsTexbufType::TexbufExt :
|
|
EsTexbufType::TexbufNone;
|
|
|
|
supports_glsl_cache = true;
|
|
g_ogl_config.bSupportsGLSync = true;
|
|
|
|
// TODO: Implement support for GL_EXT_clip_cull_distance when there is an extension for
|
|
// depth clamping.
|
|
g_Config.backend_info.bSupportsDepthClamp = false;
|
|
|
|
// GLES does not support logic op.
|
|
g_Config.backend_info.bSupportsLogicOp = false;
|
|
|
|
// glReadPixels() can't be used with non-color formats. But, if we support
|
|
// ARB_get_texture_sub_image (unlikely, except maybe on NVIDIA), we can use that instead.
|
|
g_Config.backend_info.bSupportsDepthReadback = g_ogl_config.bSupportsTextureSubImage;
|
|
|
|
// GL_TEXTURE_LOD_BIAS is not supported on GLES.
|
|
g_Config.backend_info.bSupportsLodBiasInSampler = false;
|
|
|
|
if (GLExtensions::Version() == 300)
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = GlslEs300;
|
|
g_ogl_config.bSupportsAEP = false;
|
|
g_ogl_config.bSupportsTextureStorage = true;
|
|
g_Config.backend_info.bSupportsGeometryShaders = false;
|
|
}
|
|
else if (GLExtensions::Version() == 310)
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = GlslEs310;
|
|
g_ogl_config.bSupportsAEP = GLExtensions::Supports("GL_ANDROID_extension_pack_es31a");
|
|
g_Config.backend_info.bSupportsBindingLayout = true;
|
|
g_ogl_config.bSupportsImageLoadStore = true;
|
|
g_Config.backend_info.bSupportsGeometryShaders = g_ogl_config.bSupportsAEP;
|
|
g_Config.backend_info.bSupportsComputeShaders = true;
|
|
g_Config.backend_info.bSupportsGSInstancing =
|
|
g_Config.backend_info.bSupportsGeometryShaders &&
|
|
g_ogl_config.SupportedESPointSize != EsPointSizeType::PointSizeNone;
|
|
g_Config.backend_info.bSupportsSSAA = g_ogl_config.bSupportsAEP;
|
|
g_Config.backend_info.bSupportsFragmentStoresAndAtomics = true;
|
|
g_ogl_config.bSupportsMSAA = true;
|
|
g_ogl_config.bSupportsTextureStorage = true;
|
|
g_Config.backend_info.bSupportsBitfield = true;
|
|
g_Config.backend_info.bSupportsDynamicSamplerIndexing = g_ogl_config.bSupportsAEP;
|
|
}
|
|
else
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = GlslEs320;
|
|
g_ogl_config.bSupportsAEP = GLExtensions::Supports("GL_ANDROID_extension_pack_es31a");
|
|
g_Config.backend_info.bSupportsBindingLayout = true;
|
|
g_ogl_config.bSupportsImageLoadStore = true;
|
|
g_Config.backend_info.bSupportsGeometryShaders = true;
|
|
g_Config.backend_info.bSupportsComputeShaders = true;
|
|
g_Config.backend_info.bSupportsGSInstancing =
|
|
g_ogl_config.SupportedESPointSize != EsPointSizeType::PointSizeNone;
|
|
g_Config.backend_info.bSupportsPaletteConversion = true;
|
|
g_Config.backend_info.bSupportsSSAA = true;
|
|
g_Config.backend_info.bSupportsFragmentStoresAndAtomics = true;
|
|
g_ogl_config.bSupportsCopySubImage = true;
|
|
g_ogl_config.bSupportsGLBaseVertex = true;
|
|
g_ogl_config.bSupportsDebug = true;
|
|
g_ogl_config.bSupportsMSAA = true;
|
|
g_ogl_config.bSupportsTextureStorage = true;
|
|
g_Config.backend_info.bSupportsBitfield = true;
|
|
g_Config.backend_info.bSupportsDynamicSamplerIndexing = true;
|
|
g_Config.backend_info.bSupportsSettingObjectNames = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (GLExtensions::Version() < 300)
|
|
{
|
|
PanicAlertFmtT("GPU: OGL ERROR: Need at least GLSL 1.30\n"
|
|
"GPU: Does your video card support OpenGL 3.0?\n"
|
|
"GPU: Your driver supports GLSL {0}",
|
|
reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION)));
|
|
bSuccess = false;
|
|
}
|
|
else if (GLExtensions::Version() == 300)
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = Glsl130;
|
|
g_ogl_config.bSupportsImageLoadStore = false; // layout keyword is only supported on glsl150+
|
|
g_ogl_config.bSupportsConservativeDepth =
|
|
false; // layout keyword is only supported on glsl150+
|
|
g_Config.backend_info.bSupportsGeometryShaders =
|
|
false; // geometry shaders are only supported on glsl150+
|
|
}
|
|
else if (GLExtensions::Version() == 310)
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = Glsl140;
|
|
g_ogl_config.bSupportsImageLoadStore = false; // layout keyword is only supported on glsl150+
|
|
g_ogl_config.bSupportsConservativeDepth =
|
|
false; // layout keyword is only supported on glsl150+
|
|
g_Config.backend_info.bSupportsGeometryShaders =
|
|
false; // geometry shaders are only supported on glsl150+
|
|
}
|
|
else if (GLExtensions::Version() == 320)
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = Glsl150;
|
|
}
|
|
else if (GLExtensions::Version() == 330)
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = Glsl330;
|
|
}
|
|
else if (GLExtensions::Version() >= 430)
|
|
{
|
|
// TODO: We should really parse the GL_SHADING_LANGUAGE_VERSION token.
|
|
if (GLExtensions::Version() >= 450)
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = Glsl450;
|
|
}
|
|
else
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = Glsl430;
|
|
}
|
|
g_ogl_config.bSupportsTextureStorage = true;
|
|
g_ogl_config.bSupportsImageLoadStore = true;
|
|
g_Config.backend_info.bSupportsSSAA = true;
|
|
g_Config.backend_info.bSupportsSettingObjectNames = true;
|
|
|
|
// Compute shaders are core in GL4.3.
|
|
g_Config.backend_info.bSupportsComputeShaders = true;
|
|
if (GLExtensions::Version() >= 450)
|
|
g_ogl_config.bSupportsTextureSubImage = true;
|
|
}
|
|
else
|
|
{
|
|
g_ogl_config.eSupportedGLSLVersion = Glsl400;
|
|
g_Config.backend_info.bSupportsSSAA = true;
|
|
|
|
if (GLExtensions::Version() == 420)
|
|
{
|
|
// Texture storage and shader image load/store are core in GL4.2.
|
|
g_ogl_config.bSupportsTextureStorage = true;
|
|
g_ogl_config.bSupportsImageLoadStore = true;
|
|
}
|
|
}
|
|
|
|
// Desktop OpenGL can't have the Android Extension Pack
|
|
g_ogl_config.bSupportsAEP = false;
|
|
|
|
// Desktop GL requires GL_PROGRAM_POINT_SIZE set to use gl_PointSize in shaders.
|
|
// It is implicitly enabled in GLES.
|
|
glEnable(GL_PROGRAM_POINT_SIZE);
|
|
}
|
|
|
|
// Supported by all GS-supporting ES and 4.3+
|
|
g_Config.backend_info.bSupportsGLLayerInFS = g_Config.backend_info.bSupportsGeometryShaders &&
|
|
g_ogl_config.eSupportedGLSLVersion >= Glsl430;
|
|
|
|
g_Config.backend_info.bSupportsBBox = g_Config.backend_info.bSupportsFragmentStoresAndAtomics;
|
|
|
|
// Either method can do early-z tests. See PixelShaderGen for details.
|
|
g_Config.backend_info.bSupportsEarlyZ =
|
|
g_ogl_config.bSupportsImageLoadStore || g_ogl_config.bSupportsConservativeDepth;
|
|
|
|
glGetIntegerv(GL_MAX_SAMPLES, &g_ogl_config.max_samples);
|
|
if (g_ogl_config.max_samples < 1 || !g_ogl_config.bSupportsMSAA)
|
|
g_ogl_config.max_samples = 1;
|
|
|
|
const bool bSupportsIsHelperInvocation = g_ogl_config.bIsES ?
|
|
g_ogl_config.eSupportedGLSLVersion >= GlslEs320 :
|
|
g_ogl_config.eSupportedGLSLVersion >= Glsl450;
|
|
g_ogl_config.bSupportsKHRShaderSubgroup =
|
|
GLExtensions::Supports("GL_KHR_shader_subgroup") && bSupportsIsHelperInvocation;
|
|
if (g_ogl_config.bSupportsKHRShaderSubgroup)
|
|
{
|
|
// Check for the features: basic + arithmetic + ballot
|
|
GLint supported_features = 0;
|
|
glGetIntegerv(GL_SUBGROUP_SUPPORTED_FEATURES_KHR, &supported_features);
|
|
if (~supported_features &
|
|
(GL_SUBGROUP_FEATURE_BASIC_BIT_KHR | GL_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR |
|
|
GL_SUBGROUP_FEATURE_BALLOT_BIT_KHR))
|
|
{
|
|
g_ogl_config.bSupportsKHRShaderSubgroup = false;
|
|
}
|
|
}
|
|
|
|
// We require texel buffers, image load store, and compute shaders to enable GPU texture decoding.
|
|
// If the driver doesn't expose the extensions, but supports GL4.3/GLES3.1, it will still be
|
|
// enabled in the version check below.
|
|
g_Config.backend_info.bSupportsGPUTextureDecoding =
|
|
g_Config.backend_info.bSupportsPaletteConversion &&
|
|
g_Config.backend_info.bSupportsComputeShaders && g_ogl_config.bSupportsImageLoadStore;
|
|
|
|
// Background compiling is supported only when shared contexts aren't broken.
|
|
g_Config.backend_info.bSupportsBackgroundCompiling =
|
|
!DriverDetails::HasBug(DriverDetails::BUG_SHARED_CONTEXT_SHADER_COMPILATION);
|
|
|
|
// Program binaries are supported on GL4.1+, ARB_get_program_binary, or ES3.
|
|
if (supports_glsl_cache)
|
|
{
|
|
// We need to check the number of formats supported. If zero, don't bother getting the binaries.
|
|
GLint num_formats = 0;
|
|
glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &num_formats);
|
|
supports_glsl_cache = num_formats > 0;
|
|
}
|
|
g_Config.backend_info.bSupportsPipelineCacheData = supports_glsl_cache;
|
|
|
|
int samples;
|
|
glGetIntegerv(GL_SAMPLES, &samples);
|
|
if (samples > 1)
|
|
{
|
|
// MSAA on default framebuffer isn't working because of glBlitFramebuffer.
|
|
// It also isn't useful as we don't render anything to the default framebuffer.
|
|
// We also try to get a non-msaa fb, so this only happens when forced by the driver.
|
|
PanicAlertFmtT(
|
|
"The graphics driver is forcibly enabling anti-aliasing for Dolphin. You need to "
|
|
"turn this off in the graphics driver's settings in order for Dolphin to work.\n\n"
|
|
"(MSAA with {0} samples found on default framebuffer)",
|
|
samples);
|
|
bSuccess = false;
|
|
}
|
|
|
|
if (!bSuccess)
|
|
return false;
|
|
|
|
g_Config.VerifyValidity();
|
|
UpdateActiveConfig();
|
|
|
|
OSD::AddMessage(fmt::format("Video Info: {}, {}, {}", g_ogl_config.gl_vendor,
|
|
g_ogl_config.gl_renderer, g_ogl_config.gl_version),
|
|
5000);
|
|
|
|
if (!g_ogl_config.bSupportsGLBufferStorage && !g_ogl_config.bSupportsGLPinnedMemory)
|
|
{
|
|
OSD::AddMessage(fmt::format("Your OpenGL driver does not support {}_buffer_storage.",
|
|
m_main_gl_context->IsGLES() ? "EXT" : "ARB"),
|
|
60000);
|
|
OSD::AddMessage("This device's performance may be poor.", 60000);
|
|
}
|
|
|
|
INFO_LOG_FMT(VIDEO, "Video Info: {}, {}, {}", g_ogl_config.gl_vendor, g_ogl_config.gl_renderer,
|
|
g_ogl_config.gl_version);
|
|
WARN_LOG_FMT(VIDEO, "Missing OGL Extensions: {}{}{}{}{}{}{}{}{}{}{}{}{}{}",
|
|
g_ActiveConfig.backend_info.bSupportsDualSourceBlend ? "" : "DualSourceBlend ",
|
|
g_ActiveConfig.backend_info.bSupportsPrimitiveRestart ? "" : "PrimitiveRestart ",
|
|
g_ActiveConfig.backend_info.bSupportsEarlyZ ? "" : "EarlyZ ",
|
|
g_ogl_config.bSupportsGLPinnedMemory ? "" : "PinnedMemory ",
|
|
supports_glsl_cache ? "" : "ShaderCache ",
|
|
g_ogl_config.bSupportsGLBaseVertex ? "" : "BaseVertex ",
|
|
g_ogl_config.bSupportsGLBufferStorage ? "" : "BufferStorage ",
|
|
g_ogl_config.bSupportsGLSync ? "" : "Sync ",
|
|
g_ogl_config.bSupportsMSAA ? "" : "MSAA ",
|
|
g_ActiveConfig.backend_info.bSupportsSSAA ? "" : "SSAA ",
|
|
g_ActiveConfig.backend_info.bSupportsGSInstancing ? "" : "GSInstancing ",
|
|
g_ActiveConfig.backend_info.bSupportsClipControl ? "" : "ClipControl ",
|
|
g_ogl_config.bSupportsCopySubImage ? "" : "CopyImageSubData ",
|
|
g_ActiveConfig.backend_info.bSupportsDepthClamp ? "" : "DepthClamp ");
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace OGL
|